package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2ByteOperator {
byte apply(float var1, byte var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2CharOperator {
char apply(float var1, char var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2DoubleOperator {
double apply(float var1, double var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2FloatOperator {
float apply(float var1, float var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2IntOperator {
int apply(float var1, int var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2LongOperator {
long apply(float var1, long var2);
}
package com.hypixel.fastutil.floats;
import com.hypixel.fastutil.FastCollection;
import com.hypixel.fastutil.util.SneakyThrow;
import com.hypixel.fastutil.util.TLRUtil;
import it.unimi.dsi.fastutil.floats.Float2ObjectMap;
import it.unimi.dsi.fastutil.floats.FloatCollection;
import it.unimi.dsi.fastutil.floats.FloatConsumer;
import it.unimi.dsi.fastutil.floats.FloatIterator;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.floats.FloatSpliterator;
import it.unimi.dsi.fastutil.objects.ObjectCollection;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.objects.ObjectSpliterator;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.CountedCompleter;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.Function;
import java.util.function.IntBinaryOperator;
java.util.function.LongBinaryOperator;
java.util.function.Predicate;
java.util.function.ToDoubleFunction;
java.util.function.ToIntFunction;
java.util.function.ToLongFunction;
sun.misc.Unsafe;
<V> {
;
;
;
;
;
;
;
;
;
;
;
MAX_RESIZERS;
RESIZE_STAMP_SHIFT;
-;
-;
-;
;
NCPU;
Node<V>[] table;
Node<V>[] nextTable;
baseCount;
sizeCtl;
transferIndex;
cellsBusy;
CounterCell[] counterCells;
KeySetView<V> keySet;
ValuesView<V> values;
EntrySetView<V> entrySet;
EMPTY;
Unsafe U;
SIZECTL;
TRANSFERINDEX;
BASECOUNT;
CELLSBUSY;
CELLVALUE;
ABASE;
ASHIFT;
{
(h ^ h >>> ) & ;
}
{
c - ;
n |= n >>> ;
n |= n >>> ;
n |= n >>> ;
n |= n >>> ;
n |= n >>> ;
n < ? : (n >= ? : n + );
}
<V> Node<V> {
(Node)U.getObjectVolatile(tab, (()i << ASHIFT) + ABASE);
}
<V> {
U.compareAndSwapObject(tab, (()i << ASHIFT) + ABASE, c, v);
}
<V> {
U.putObjectVolatile(tab, (()i << ASHIFT) + ABASE, v);
}
{
.EMPTY = -;
}
{
.EMPTY = emptyValue;
}
{
(initialCapacity, , -);
}
{
(initialCapacity < ) {
();
} {
initialCapacity >= ? : tableSizeFor(initialCapacity + (initialCapacity >>> ) + );
.sizeCtl = cap;
.EMPTY = emptyValue;
}
}
{
.sizeCtl = ;
.EMPTY = emptyValue;
.putAll(m);
}
{
.sizeCtl = ;
.EMPTY = m.EMPTY;
.putAll(m);
}
{
.sizeCtl = ;
.EMPTY = -;
.putAll(m);
}
{
.sizeCtl = ;
.EMPTY = emptyValue;
.putAll(m);
}
{
(initialCapacity, loadFactor, , -);
}
{
(loadFactor > && initialCapacity >= && concurrencyLevel > ) {
(initialCapacity < concurrencyLevel) {
initialCapacity = concurrencyLevel;
}
()( + ()(()(()initialCapacity) / loadFactor));
size >= ? : tableSizeFor(()size);
.sizeCtl = cap;
.EMPTY = emptyValue;
} {
();
}
}
{
.sumCount();
n < ? : (n > ? : ()n);
}
{
.sumCount() <= ;
}
V {
(key == .EMPTY) {
( + .EMPTY);
} {
spread(Float.hashCode(key));
Node<V>[] tab;
Node<V> e;
n;
((tab = .table) != && (n = tab.length) > && (e = tabAt(tab, n - & h)) != ) {
eh;
((eh = e.hash) == h) {
ek;
((ek = e.key) == key || ek != .EMPTY && key == ek) {
e.val;
}
} (eh < ) {
Node<V> p;
(V)((p = e.find(h, key)) != ? p.val : );
}
((e = e.next) != ) {
ek;
(e.hash == h && ((ek = e.key) == key || ek != .EMPTY && key == ek)) {
e.val;
}
}
}
;
}
}
{
.get(key) != ;
}
{
(value == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label87:
() {
(p != ) {
next = p;
;
}
(baseIndex < baseLimit) {
Node<V>[] t = tab;
n;
(tab != && (n = tab.length) > index && index >= ) {
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
label87;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
;
}
(p == ) {
;
}
V v;
((v = p.val) == value || v != && value.equals(v)) {
;
}
}
}
;
}
}
V {
(V).putVal(key, value, );
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (value == ) {
();
} {
spread(Float.hashCode(key));
;
Node<V>[] tab = .table;
() {
n;
(tab == || (n = tab.length) == ) {
tab = .initTable();
}
Node<V> f;
i;
((f = tabAt(tab, i = n - & hash)) == ) {
(casTabAt(tab, i, (Node), (.EMPTY, hash, key, value, (Node)))) {
;
}
} {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
;
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
binCount = ;
Node<V> p;
((p = (f).putTreeVal(hash, key, value)) != ) {
oldVal = p.val;
(!onlyIfAbsent) {
p.val = value;
}
}
}
} {
label107: {
binCount = ;
Node<V> e;
ek;
(e = f; e.hash != hash || (ek = e.key) != key && (ek == .EMPTY || key != ek); ++binCount) {
Node<V> pred = e;
((e = e.next) == ) {
pred.next = <V>(.EMPTY, hash, key, value, (Node));
label107;
}
}
oldVal = e.val;
(!onlyIfAbsent) {
e.val = value;
}
}
}
}
}
(binCount != ) {
(binCount >= ) {
.treeifyBin(tab, i);
}
(oldVal != ) {
oldVal;
}
;
}
}
}
}
.addCount(, binCount);
;
}
}
{
.tryPresize(m.size());
(Map.Entry<? , ? > e : m.entrySet()) {
.putVal((Float)e.getKey(), e.getValue(), );
}
}
{
.tryPresize(m.size());
(Float2ObjectMap.Entry<? > e : m.float2ObjectEntrySet()) {
.putVal(e.getFloatKey(), e.getValue(), );
}
}
{
.tryPresize(m.size());
ObjectIterator<? .Entry<? >> iterator = m.float2ObjectEntrySet().iterator();
(iterator.hasNext()) {
Float2ObjectMap.Entry<? > next = (Float2ObjectMap.Entry)iterator.next();
.putVal(next.getFloatKey(), next.getValue(), );
}
}
V {
(V).replaceNode(key, (Object), (Object));
}
V {
(V).replaceNode(key, (Object), (Object));
}
V {
(V).remove((Float)key);
}
V {
(key == .EMPTY) {
( + .EMPTY);
} {
spread(Float.hashCode(key));
Node<V>[] tab = .table;
Node<V> f;
n;
i;
(tab != && (n = tab.length) != && (f = tabAt(tab, i = n - & hash)) != ) {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
;
;
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
validated = ;
TreeBin<V> t = (TreeBin)f;
TreeNode<V> r;
TreeNode<V> p;
((r = t.root) != && (p = r.findTreeNode(hash, key, (Class))) != ) {
p.val;
(cv == || cv == pv || pv != && cv.equals(pv)) {
oldVal = pv;
(value != ) {
p.val = value;
} (t.removeTreeNode(p)) {
setTabAt(tab, i, .untreeify(t.first));
}
}
}
}
} {
label126: {
validated = ;
Node<V> e = f;
Node<V> pred = ;
ek;
(e.hash != hash || (ek = e.key) != key && (ek == .EMPTY || key != ek)) {
pred = e;
((e = e.next) == ) {
label126;
}
}
e.val;
(cv == || cv == ev || ev != && cv.equals(ev)) {
oldVal = ev;
(value != ) {
e.val = value;
} (pred != ) {
pred.next = e.next;
} {
setTabAt(tab, i, e.next);
}
}
}
}
}
}
(validated) {
(oldVal != ) {
(value == ) {
.addCount(-, -);
}
oldVal;
}
;
}
}
}
;
}
}
{
;
;
Node<V>[] tab = .table;
(tab != && i < tab.length) {
Node<V> f = tabAt(tab, i);
(f == ) {
++i;
} {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
i = ;
} {
(f) {
(tabAt(tab, i) == f) {
(Node<V> p = (Node<V>)(fh >= ? f : (f TreeBin ? ((TreeBin)f).first : )); p != ; p = p.next) {
--delta;
}
setTabAt(tab, i++, (Node));
}
}
}
}
}
(delta != ) {
.addCount(delta, -);
}
}
KeySetView<V> {
KeySetView<V> ks;
(ks = .keySet) != ? ks : (.keySet = .buildKeySetView());
}
KeySetView<V> {
<V>(, (Object));
}
FastCollection<V> {
ValuesView<V> vs;
(vs = .values) != ? vs : (.values = .buildValuesView());
}
ValuesView<V> {
<V>();
}
ObjectSet<Float2ObjectMap.Entry<V>> float2ObjectEntrySet() {
EntrySetView<V> es;
(es = .entrySet) != ? es : (.entrySet = .buildEntrySetView());
}
ObjectSet<Map.Entry<Float, V>> entrySet() {
.float2ObjectEntrySet();
}
EntrySetView<V> {
<V>();
}
{
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label77: {
() {
(p != ) {
next = p;
label77;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
h += Float.hashCode(p.key) ^ p.val.hashCode();
}
}
h;
}
String {
Node<V>[] t;
(t = .table) == ? : t.length;
Traverser<V> it = <V>(t, f, , f);
();
sb.append();
Node<V> p;
((p = it.advance()) != ) {
() {
p.key;
p.val;
sb.append(k);
sb.append();
sb.append(v == ? : v);
((p = it.advance()) == ) {
;
}
sb.append().append();
}
}
sb.append().toString();
}
{
(o != ) {
(!(o Float2ObjectConcurrentHashMap)) {
;
}
Float2ObjectConcurrentHashMap<?> m = (Float2ObjectConcurrentHashMap)o;
Node<V>[] t;
(t = .table) == ? : t.length;
Traverser<V> it = <V>(t, f, , f);
Node<V> p;
((p = it.advance()) != ) {
p.val;
m.get(p.key);
(v == || v != val && !v.equals(val)) {
;
}
}
(Float2ObjectMap.Entry<?> e : m.float2ObjectEntrySet()) {
Object mv;
Object v;
mk;
((mk = e.getFloatKey()) == m.EMPTY || (mv = e.getValue()) == || (v = .get(mk)) == || mv != v && !mv.equals(v)) {
;
}
}
}
;
}
V {
(V).putVal(key, value, );
}
{
(key == .EMPTY) {
( + .EMPTY);
} {
value != && .replaceNode(key, (Object), value) != ;
}
}
{
(key == .EMPTY) {
( + .EMPTY);
} (oldValue != && newValue != ) {
.replaceNode(key, newValue, oldValue) != ;
} {
();
}
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (value == ) {
();
} {
(V).replaceNode(key, value, (Object));
}
}
V {
V v;
(V)((v = (V).get(key)) == ? defaultValue : v);
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, x);
++count;
}
}
count;
}
}
<X, Y> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, x, y);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
{
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
<X> {
(action == ) {
();
} {
;
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.key, p.val, ii, x);
++count;
}
}
count;
}
}
{
(function == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label88: {
() {
(p != ) {
next = p;
label88;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
p.val;
p.key;
() {
function.apply(key, oldValue);
(newValue == ) {
();
}
(.replaceNode(key, newValue, oldValue) != || (oldValue = (V).get(key)) == ) {
;
}
}
}
}
}
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (mappingFunction == ) {
();
} {
spread(Float.hashCode(key));
;
;
Node<V>[] tab = .table;
() {
n;
(tab == || (n = tab.length) == ) {
tab = .initTable();
}
Node<V> f;
i;
((f = tabAt(tab, i = n - & h)) == ) {
Node<V> r = <V>(.EMPTY);
(r) {
(casTabAt(tab, i, (Node), r)) {
binCount = ;
Node<V> node = ;
{
((val = mappingFunction.apply(key)) != ) {
node = <V>(.EMPTY, h, key, val, (Node));
}
} {
setTabAt(tab, i, node);
}
}
}
(binCount != ) {
;
}
} {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
;
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
binCount = ;
TreeBin<V> t = (TreeBin)f;
TreeNode<V> p;
TreeNode<V> r;
((r = t.root) != && (p = r.findTreeNode(h, key, (Class))) != ) {
val = p.val;
} ((val = mappingFunction.apply(key)) != ) {
added = ;
t.putTreeVal(h, key, val);
}
}
} {
label274: {
binCount = ;
Node<V> e;
ek;
(e = f; e.hash != h || (ek = e.key) != key && (ek == .EMPTY || key != ek); ++binCount) {
Node<V> pred = e;
((e = e.next) == ) {
((val = mappingFunction.apply(key)) != ) {
added = ;
pred.next = <V>(.EMPTY, h, key, val, (Node));
}
label274;
}
}
val = e.val;
}
}
}
}
(binCount != ) {
(binCount >= ) {
.treeifyBin(tab, i);
}
(!added) {
val;
}
;
}
}
}
}
(val != ) {
.addCount(, binCount);
}
val;
}
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (remappingFunction == ) {
();
} {
spread(Float.hashCode(key));
;
;
;
Node<V>[] tab = .table;
() {
n;
(tab == || (n = tab.length) == ) {
tab = .initTable();
}
Node<V> f;
i;
((f = tabAt(tab, i = n - & h)) == ) {
;
}
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
binCount = ;
TreeBin<V> t = (TreeBin)f;
TreeNode<V> r;
TreeNode<V> p;
((r = t.root) != && (p = r.findTreeNode(h, key, (Class))) != ) {
val = remappingFunction.apply(key, p.val);
(val != ) {
p.val = val;
} {
delta = -;
(t.removeTreeNode(p)) {
setTabAt(tab, i, .untreeify(t.first));
}
}
}
}
} {
label111: {
binCount = ;
Node<V> e = f;
Node<V> pred;
ek;
(pred = ; e.hash != h || (ek = e.key) != key && (ek == .EMPTY || key != ek); ++binCount) {
pred = e;
((e = e.next) == ) {
label111;
}
}
val = remappingFunction.apply(key, e.val);
(val != ) {
e.val = val;
} {
delta = -;
Node<V> en = e.next;
(pred != ) {
pred.next = en;
} {
setTabAt(tab, i, en);
}
}
}
}
}
}
(binCount != ) {
;
}
}
}
(delta != ) {
.addCount(()delta, binCount);
}
val;
}
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (remappingFunction == ) {
();
} {
spread(Float.hashCode(key));
;
;
;
Node<V>[] tab = .table;
() {
n;
(tab == || (n = tab.length) == ) {
tab = .initTable();
}
Node<V> f;
i;
((f = tabAt(tab, i = n - & h)) == ) {
Node<V> r = <V>(.EMPTY);
(r) {
(casTabAt(tab, i, (Node), r)) {
binCount = ;
Node<V> node = ;
{
((val = remappingFunction.apply(key, (Object))) != ) {
delta = ;
node = <V>(.EMPTY, h, key, val, (Node));
}
} {
setTabAt(tab, i, node);
}
}
}
(binCount != ) {
;
}
} {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
binCount = ;
TreeBin<V> t = (TreeBin)f;
TreeNode<V> r;
TreeNode<V> p;
((r = t.root) != ) {
p = r.findTreeNode(h, key, (Class));
} {
p = ;
}
(V)(p == ? : p.val);
val = remappingFunction.apply(key, pv);
(val != ) {
(p != ) {
p.val = val;
} {
delta = ;
t.putTreeVal(h, key, val);
}
} (p != ) {
delta = -;
(t.removeTreeNode(p)) {
setTabAt(tab, i, .untreeify(t.first));
}
}
}
} {
label301: {
binCount = ;
Node<V> e = f;
Node<V> pred;
ek;
(pred = ; e.hash != h || (ek = e.key) != key && (ek == .EMPTY || key != ek); ++binCount) {
pred = e;
((e = e.next) == ) {
val = remappingFunction.apply(key, (Object));
(val != ) {
delta = ;
pred.next = <V>(.EMPTY, h, key, val, (Node));
}
label301;
}
}
val = remappingFunction.apply(key, e.val);
(val != ) {
e.val = val;
} {
delta = -;
Node<V> en = e.next;
(pred != ) {
pred.next = en;
} {
setTabAt(tab, i, en);
}
}
}
}
}
}
(binCount != ) {
(binCount >= ) {
.treeifyBin(tab, i);
}
;
}
}
}
}
(delta != ) {
.addCount(()delta, binCount);
}
val;
}
}
V {
(key == .EMPTY) {
( + .EMPTY);
} (value != && remappingFunction != ) {
spread(Float.hashCode(key));
;
;
;
Node<V>[] tab = .table;
() {
n;
(tab == || (n = tab.length) == ) {
tab = .initTable();
}
Node<V> f;
i;
((f = tabAt(tab, i = n - & h)) == ) {
(casTabAt(tab, i, (Node), (.EMPTY, h, key, value, (Node)))) {
delta = ;
val = value;
;
}
} {
fh;
((fh = f.hash) == -) {
tab = .helpTransfer(tab, f);
} {
(f) {
(tabAt(tab, i) == f) {
(fh < ) {
(f TreeBin) {
binCount = ;
TreeBin<V> t = (TreeBin)f;
TreeNode<V> r = t.root;
TreeNode<V> p = r == ? : r.findTreeNode(h, key, (Class));
val = (V)(p == ? value : remappingFunction.apply(p.val, value));
(val != ) {
(p != ) {
p.val = val;
} {
delta = ;
t.putTreeVal(h, key, val);
}
} (p != ) {
delta = -;
(t.removeTreeNode(p)) {
setTabAt(tab, i, .untreeify(t.first));
}
}
}
} {
label132: {
binCount = ;
Node<V> e = f;
Node<V> pred;
ek;
(pred = ; e.hash != h || (ek = e.key) != key && (ek == .EMPTY || key != ek); ++binCount) {
pred = e;
((e = e.next) == ) {
delta = ;
val = value;
pred.next = <V>(.EMPTY, h, key, value, (Node));
label132;
}
}
val = (V)remappingFunction.apply(e.val, value);
(val != ) {
e.val = val;
} {
delta = -;
Node<V> en = e.next;
(pred != ) {
pred.next = en;
} {
setTabAt(tab, i, en);
}
}
}
}
}
}
(binCount != ) {
(binCount >= ) {
.treeifyBin(tab, i);
}
;
}
}
}
}
(delta != ) {
.addCount(()delta, binCount);
}
val;
} {
();
}
}
{
.sumCount();
n < ? : n;
}
FloatSet {
( (), Boolean.TRUE);
}
KeySetView<Boolean> {
<Boolean>( (initialCapacity), Boolean.TRUE);
}
KeySetView<V> {
(mappedValue == ) {
();
} {
<V>(, mappedValue);
}
}
{
Integer.numberOfLeadingZeros(n) | << RESIZE_STAMP_BITS - ;
}
Node<V>[] initTable() {
Node<V>[] tab;
((tab = .table) == || tab.length == ) {
sc;
((sc = .sizeCtl) < ) {
Thread.();
} (U.compareAndSwapInt(, SIZECTL, sc, -)) {
{
((tab = .table) == || tab.length == ) {
sc > ? sc : ;
Node<V>[] nt = [n];
tab = nt;
.table = nt;
sc = n - (n >>> );
}
;
} {
.sizeCtl = sc;
}
}
}
tab;
}
{
CounterCell[] as;
b;
s;
((as = .counterCells) != || !U.compareAndSwapLong(, BASECOUNT, b = .baseCount, s = b + x)) {
;
CounterCell a;
v;
m;
(as == || (m = as.length - ) < || (a = as[TLRUtil.getProbe() & m]) == || !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
.fullAddCount(x, uncontended);
;
}
(check <= ) {
;
}
s = .sumCount();
}
n;
Node<V>[] tab;
sc;
(check >= ) {
(; s >= ()(sc = .sizeCtl) && (tab = .table) != && (n = tab.length) < ; s = .sumCount()) {
resizeStamp(n);
(sc < ) {
Node<V>[] nt;
(sc >>> RESIZE_STAMP_SHIFT != rs || sc == rs + || sc == rs + MAX_RESIZERS || (nt = .nextTable) == || .transferIndex <= ) {
;
}
(U.compareAndSwapInt(, SIZECTL, sc, sc + )) {
.transfer(tab, nt);
}
} (U.compareAndSwapInt(, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + )) {
.transfer(tab, (Node[]));
}
}
}
}
Node<V>[] helpTransfer(Node<V>[] tab, Node<V> f) {
Node<V>[] nextTab;
(tab != && f ForwardingNode && (nextTab = ((ForwardingNode)f).nextTable) != ) {
resizeStamp(tab.length);
sc;
(nextTab == .nextTable && .table == tab && (sc = .sizeCtl) < && sc >>> RESIZE_STAMP_SHIFT == rs && sc != rs + && sc != rs + MAX_RESIZERS && .transferIndex > ) {
(U.compareAndSwapInt(, SIZECTL, sc, sc + )) {
.transfer(tab, nextTab);
;
}
}
nextTab;
} {
.table;
}
}
{
size >= ? : tableSizeFor(size + (size >>> ) + );
sc;
((sc = .sizeCtl) >= ) {
Node<V>[] tab = .table;
n;
(tab != && (n = tab.length) != ) {
(c <= sc || n >= ) {
;
}
(tab == .table) {
resizeStamp(n);
(sc < ) {
Node<V>[] nt;
(sc >>> RESIZE_STAMP_SHIFT != rs || sc == rs + || sc == rs + MAX_RESIZERS || (nt = .nextTable) == || .transferIndex <= ) {
;
}
(U.compareAndSwapInt(, SIZECTL, sc, sc + )) {
.transfer(tab, nt);
}
} (U.compareAndSwapInt(, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + )) {
.transfer(tab, (Node[]));
}
}
} {
n = sc > c ? sc : c;
(U.compareAndSwapInt(, SIZECTL, sc, -)) {
{
(.table == tab) {
Node<V>[] nt = [n];
.table = nt;
sc = n - (n >>> );
}
} {
.sizeCtl = sc;
}
}
}
}
}
{
tab.length;
stride;
((stride = NCPU > ? (n >>> ) / NCPU : n) < ) {
stride = ;
}
(nextTab == ) {
{
Node<V>[] nt = [n << ];
nextTab = nt;
} (Throwable var27) {
.sizeCtl = ;
;
}
.nextTable = nextTab;
.transferIndex = n;
}
nextTab.length;
ForwardingNode<V> fwd = <V>(.EMPTY, nextTab);
;
;
;
;
() {
(!advance) {
(i >= && i < n && i + n < nextn) {
Node<V> f;
((f = tabAt(tab, i)) == ) {
advance = casTabAt(tab, i, (Node), fwd);
} {
fh;
((fh = f.hash) == -) {
advance = ;
} {
(f) {
(tabAt(tab, i) == f) {
(fh >= ) {
fh & n;
Node<V> lastRun = f;
(Node<V> p = f.next; p != ; p = p.next) {
p.hash & n;
(b != runBit) {
runBit = b;
lastRun = p;
}
}
Node<V> ln;
Node<V> hn;
(runBit == ) {
ln = lastRun;
hn = ;
} {
hn = lastRun;
ln = ;
}
(Node<V> p = f; p != lastRun; p = p.next) {
p.hash;
p.key;
p.val;
((ph & n) == ) {
ln = <V>(.EMPTY, ph, pk, pv, ln);
} {
hn = <V>(.EMPTY, ph, pk, pv, hn);
}
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = ;
} (f TreeBin) {
TreeBin<V> t = (TreeBin)f;
TreeNode<V> lo = ;
TreeNode<V> loTail = ;
TreeNode<V> hi = ;
TreeNode<V> hiTail = ;
;
;
(Node<V> e = t.first; e != ; e = e.next) {
e.hash;
TreeNode<V> p = <V>(.EMPTY, h, e.key, e.val, (Node), (TreeNode));
((h & n) == ) {
((p.prev = loTail) == ) {
lo = p;
} {
loTail.next = p;
}
loTail = p;
++lc;
} {
((p.prev = hiTail) == ) {
hi = p;
} {
hiTail.next = p;
}
hiTail = p;
++hc;
}
}
Node<V> ln = (Node<V>)(lc <= ? .untreeify(lo) : (hc != ? (.EMPTY, lo) : t));
Node<V> hn = (Node<V>)(hc <= ? .untreeify(hi) : (lc != ? (.EMPTY, hi) : t));
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = ;
}
}
}
}
}
} {
(finishing) {
.nextTable = ;
.table = nextTab;
.sizeCtl = (n << ) - (n >>> );
;
}
sc;
(U.compareAndSwapInt(, SIZECTL, sc = .sizeCtl, sc - )) {
(sc - != resizeStamp(n) << RESIZE_STAMP_SHIFT) {
;
}
advance = ;
finishing = ;
i = n;
}
}
}
--i;
(i < bound && !finishing) {
nextIndex;
((nextIndex = .transferIndex) <= ) {
i = -;
advance = ;
} {
nextBound;
(U.compareAndSwapInt(, TRANSFERINDEX, nextIndex, nextBound = nextIndex > stride ? nextIndex - stride : )) {
bound = nextBound;
i = nextIndex - ;
advance = ;
}
}
} {
advance = ;
}
}
}
{
CounterCell[] as = .counterCells;
.baseCount;
(as != ) {
( ; i < as.length; ++i) {
CounterCell a;
((a = as[i]) != ) {
sum += a.value;
}
}
}
sum;
}
{
h;
((h = TLRUtil.getProbe()) == ) {
TLRUtil.localInit();
h = TLRUtil.getProbe();
wasUncontended = ;
}
;
() {
CounterCell[] as;
n;
((as = .counterCells) != && (n = as.length) > ) {
CounterCell a;
((a = as[n - & h]) == ) {
(.cellsBusy == ) {
(x);
(.cellsBusy == && U.compareAndSwapInt(, CELLSBUSY, , )) {
;
{
CounterCell[] rs;
m;
j;
((rs = .counterCells) != && (m = rs.length) > && rs[j = m - & h] == ) {
rs[j] = r;
created = ;
}
} {
.cellsBusy = ;
}
(created) {
;
}
;
}
}
collide = ;
} (!wasUncontended) {
wasUncontended = ;
} {
v;
(U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)) {
;
}
(.counterCells == as && n < NCPU) {
(!collide) {
collide = ;
} (.cellsBusy == && U.compareAndSwapInt(, CELLSBUSY, , )) {
{
(.counterCells == as) {
CounterCell[] rs = [n << ];
( ; i < n; ++i) {
rs[i] = as[i];
}
.counterCells = rs;
}
} {
.cellsBusy = ;
}
collide = ;
;
}
} {
collide = ;
}
}
h = TLRUtil.advanceProbe(h);
} (.cellsBusy == && .counterCells == as && U.compareAndSwapInt(, CELLSBUSY, , )) {
;
{
(.counterCells == as) {
CounterCell[] rs = [];
rs[h & ] = (x);
.counterCells = rs;
init = ;
}
} {
.cellsBusy = ;
}
(init) {
;
}
} {
v;
(U.compareAndSwapLong(, BASECOUNT, v = .baseCount, v + x)) {
;
}
}
}
}
{
(tab != ) {
n;
((n = tab.length) < ) {
.tryPresize(n << );
} {
Node<V> b;
((b = tabAt(tab, index)) != && b.hash >= ) {
(b) {
(tabAt(tab, index) == b) {
TreeNode<V> hd = ;
TreeNode<V> tl = ;
(Node<V> e = b; e != ; e = e.next) {
TreeNode<V> p = <V>(.EMPTY, e.hash, e.key, e.val, (Node), (TreeNode));
((p.prev = tl) == ) {
hd = p;
} {
tl.next = p;
}
tl = p;
}
setTabAt(tab, index, (.EMPTY, hd));
}
}
}
}
}
}
<V> Node<V> {
Node<V> hd = ;
Node<V> tl = ;
(Node<V> q = b; q != ; q = q.next) {
Node<V> p = <V>(.EMPTY, q.hash, q.key, q.val, (Node));
(tl == ) {
hd = p;
} {
tl.next = p;
}
tl = p;
}
hd;
}
{
n;
(b != && (n = .sumCount()) > && n >= b) {
ForkJoinPool.getCommonPoolParallelism() << ;
n;
b > && (n = n / b) < ()sp ? ()n : sp;
} {
;
}
}
{
(action == ) {
();
} {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, action)).invoke();
}
}
<U> {
(transformer != && action != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, transformer, action)).invoke();
} {
();
}
}
<U> U {
(searchFunction == ) {
();
} {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, searchFunction, ())).invoke();
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val);
(u != ) {
u;
}
}
}
;
}
}
<U, X> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(searchFunction == ) {
();
} {
Node<V>[] tt;
((tt = .table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label83: {
() {
(p != ) {
next = p;
label83;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
searchFunction.apply(p.key, p.val, x);
(u != ) {
u;
}
}
}
;
}
}
<U> U {
(transformer != && reducer != ) {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceMappingsTask), transformer, reducer)).invoke();
} {
();
}
}
<U> U {
(transformer != && reducer != ) {
Node<V>[] tt;
((tt = .table) == ) {
;
} {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label90: {
() {
(p != ) {
next = p;
label90;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
r;
}
U u;
((u = transformer.apply(p.key, p.val)) != ) {
r = (U)(r == ? u : reducer.apply(r, u));
}
}
}
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceMappingsToDoubleTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceMappingsToLongTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceMappingsToIntTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(action == ) {
();
} {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, action)).invoke();
}
}
<U> {
(transformer != && action != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, transformer, action)).invoke();
} {
();
}
}
<U> U {
(searchFunction == ) {
();
} {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, searchFunction, ())).invoke();
}
}
{
(reducer == ) {
();
} {
( (.EMPTY, (BulkTask), .batchFor(parallelismThreshold), , , .table, (ReduceKeysTask), reducer)).invoke0();
}
}
<U> U {
(transformer != && reducer != ) {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceKeysTask), transformer, reducer)).invoke();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceKeysToDoubleTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceKeysToLongTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceKeysToIntTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(action == ) {
();
} {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, action)).invoke();
}
}
<U> {
(transformer != && action != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, transformer, action)).invoke();
} {
();
}
}
<U> U {
(searchFunction == ) {
();
} {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, searchFunction, ())).invoke();
}
}
V {
(reducer == ) {
();
} {
(V)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (ReduceValuesTask), reducer)).invoke();
}
}
<U> U {
(transformer != && reducer != ) {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceValuesTask), transformer, reducer)).invoke();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceValuesToDoubleTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceValuesToLongTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceValuesToIntTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(action == ) {
();
} {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, action)).invoke();
}
}
<U> {
(transformer != && action != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, transformer, action)).invoke();
} {
();
}
}
<U> U {
(searchFunction == ) {
();
} {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, searchFunction, ())).invoke();
}
}
Entry<V> {
(reducer == ) {
();
} {
(Entry)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (ReduceEntriesTask), reducer)).invoke();
}
}
<U> U {
(transformer != && reducer != ) {
(U)( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceEntriesTask), transformer, reducer)).invoke();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceEntriesToDoubleTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceEntriesToLongTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
{
(transformer != && reducer != ) {
( ((BulkTask), .batchFor(parallelismThreshold), , , .table, (MapReduceEntriesToIntTask), transformer, basis, reducer)).invoke0();
} {
();
}
}
V {
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
Node<V>[] tab;
(tab = .table) == ? : tab.length;
f;
f;
;
label86:
(next != || !b) {
b |= ;
Node<V> e = next;
(next != ) {
e = next.next;
}
() {
(e != ) {
next = e;
(predicate.test(e.val)) {
e.val;
}
label86;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((e = tabAt(tab, index)) != && e.hash < ) {
(e ForwardingNode) {
tab = ((ForwardingNode)e).nextTable;
e = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(e TreeBin) {
e = ((TreeBin)e).first;
} {
e = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> next1 = stack.next;
stack.next = spare;
stack = next1;
spare = s;
}
}
}
next = ;
}
;
}
{
MAX_RESIZERS = ( << - RESIZE_STAMP_BITS) - ;
RESIZE_STAMP_SHIFT = - RESIZE_STAMP_BITS;
NCPU = Runtime.getRuntime().availableProcessors();
{
Unsafe.class.getDeclaredField();
f.setAccessible();
U = (Unsafe)f.get((Object));
Class<?> k = Float2ObjectConcurrentHashMap.class;
SIZECTL = U.objectFieldOffset(k.getDeclaredField());
TRANSFERINDEX = U.objectFieldOffset(k.getDeclaredField());
BASECOUNT = U.objectFieldOffset(k.getDeclaredField());
CELLSBUSY = U.objectFieldOffset(k.getDeclaredField());
Class<?> ck = CounterCell.class;
CELLVALUE = U.objectFieldOffset(ck.getDeclaredField());
Class<?> ak = Node[].class;
ABASE = ()U.arrayBaseOffset(ak);
U.arrayIndexScale(ak);
((scale & scale - ) != ) {
();
} {
ASHIFT = - Integer.numberOfLeadingZeros(scale);
}
} (Exception e) {
(e);
}
}
<V> <V> {
EMPTY;
hash;
key;
V val;
Node<V> next;
{
.EMPTY = empty;
.hash = hash;
.key = key;
.val = val;
.next = next;
}
{
.key == .EMPTY;
}
Float {
.key;
}
{
.key;
}
V {
.val;
}
{
Float.hashCode(.key) ^ .val.hashCode();
}
String {
(.isEmpty()) {
+ String.valueOf(.val);
} {
.key;
var10000 + + String.valueOf(.val);
}
}
V {
();
}
{
.isEmpty();
(o Entry) {
(empty != ((Entry)o).isEmpty()) {
;
} (!empty && .key != ((Entry)o).getFloatKey()) {
;
} {
.val.equals(((Entry)o).getValue());
}
} {
;
}
}
Node<V> {
Node<V> e = ;
(k != .EMPTY) {
{
ek;
(e.hash == h && ((ek = e.key) == k || ek != .EMPTY && k == ek)) {
e;
}
} ((e = e.next) != );
}
;
}
}
<V> {
;
loadFactor;
{
.loadFactor = lf;
}
}
<V> <V> {
Node<V>[] nextTable;
{
(empty, -, empty, (Object), (Node));
.nextTable = tab;
}
Node<V> {
Node<V>[] tab = .nextTable;
label41:
() {
Node<V> e;
n;
(k != .EMPTY && tab != && (n = tab.length) != && (e = Float2ObjectConcurrentHashMap.<V>tabAt(tab, n - & h)) != ) {
eh;
ek;
((eh = e.hash) != h || (ek = e.key) != k && (ek == .EMPTY || k != ek)) {
(eh < ) {
(!(e ForwardingNode)) {
e.find(h, k);
}
tab = ((ForwardingNode)e).nextTable;
label41;
}
((e = e.next) == ) {
;
}
}
e;
}
;
}
}
}
<V> <V> {
{
(empty, -, empty, (Object), (Node));
}
Node<V> {
;
}
}
{
value;
{
.value = x;
}
}
<V> <V> {
TreeNode<V> parent;
TreeNode<V> left;
TreeNode<V> right;
TreeNode<V> prev;
red;
{
(empty, hash, key, val, next);
.parent = parent;
}
Node<V> {
.findTreeNode(h, k, (Class));
}
TreeNode<V> {
(k != .EMPTY) {
TreeNode<V> p = ;
{
TreeNode<V> pl = p.left;
TreeNode<V> pr = p.right;
ph;
((ph = p.hash) > h) {
p = pl;
} (ph < h) {
p = pr;
} {
pk;
((pk = p.key) == k || pk != .EMPTY && k == pk) {
p;
}
(pl == ) {
p = pr;
} (pr == ) {
p = pl;
} {
dir;
((dir = Float.compare(k, pk)) != ) {
p = dir < ? pl : pr;
} {
TreeNode<V> q;
((q = pr.findTreeNode(h, k, kc)) != ) {
q;
}
p = pl;
}
}
}
} (p != );
}
;
}
}
<V> <V> {
TreeNode<V> root;
TreeNode<V> first;
Thread waiter;
lockState;
;
;
;
Unsafe U;
LOCKSTATE;
{
Float.compare(a, b);
comp > ? : -;
}
{
(empty, -, empty, (Object), (Node));
.first = b;
TreeNode<V> r = ;
TreeNode<V> next;
(TreeNode<V> x = b; x != ; x = next) {
next = (TreeNode)x.next;
x.left = x.right = ;
(r == ) {
x.parent = ;
x.red = ;
r = x;
} {
x.key;
x.hash;
Class<?> kc = ;
TreeNode<V> p = r;
dir;
TreeNode<V> xp;
{
p.key;
ph;
((ph = p.hash) > h) {
dir = -;
} (ph < h) {
dir = ;
} ((dir = Float.compare(k, pk)) == ) {
dir = .tieBreakOrder(k, pk);
}
xp = p;
} ((p = dir <= ? p.left : p.right) != );
x.parent = xp;
(dir <= ) {
xp.left = x;
} {
xp.right = x;
}
r = .<V>balanceInsertion(r, x);
}
}
.root = r;
.checkInvariants(.root);
}
{
(!U.compareAndSwapInt(, LOCKSTATE, , )) {
.contendedLock();
}
}
{
.lockState = ;
}
{
;
s;
{
(((s = .lockState) & -) != ) {
((s & ) == ) {
(U.compareAndSwapInt(, LOCKSTATE, s, s | )) {
waiting = ;
.waiter = Thread.currentThread();
}
} (waiting) {
LockSupport.park();
}
}
} (!U.compareAndSwapInt(, LOCKSTATE, s, ));
(waiting) {
.waiter = ;
}
}
Node<V> {
(k != .EMPTY) {
Node<V> e = .first;
(e != ) {
s;
(((s = .lockState) & ) != ) {
ek;
(e.hash == h && ((ek = e.key) == k || ek != .EMPTY && k == ek)) {
e;
}
e = e.next;
} (U.compareAndSwapInt(, LOCKSTATE, s, s + )) {
TreeNode<V> p;
{
TreeNode<V> r;
p = (r = .root) == ? : r.findTreeNode(h, k, (Class));
} {
Thread w;
(U.getAndAddInt(, LOCKSTATE, -) == && (w = .waiter) != ) {
LockSupport.unpark(w);
}
}
p;
}
}
}
;
}
TreeNode<V> {
Class<?> kc = ;
;
TreeNode<V> p = .root;
() {
(p == ) {
.first = .root = <V>(.EMPTY, h, k, v, (Node), (TreeNode));
} {
dir;
ph;
((ph = p.hash) > h) {
dir = -;
} (ph < h) {
dir = ;
} {
pk;
((pk = p.key) == k || pk != .EMPTY && k == pk) {
p;
}
((dir = Float.compare(k, pk)) == ) {
(!searched) {
searched = ;
TreeNode<V> q;
TreeNode<V> ch;
((ch = p.left) != && (q = ch.findTreeNode(h, k, kc)) != || (ch = p.right) != && (q = ch.findTreeNode(h, k, kc)) != ) {
q;
}
}
dir = .tieBreakOrder(k, pk);
}
}
TreeNode<V> xp = p;
((p = dir <= ? p.left : p.right) != ) {
;
}
TreeNode<V> f = .first;
TreeNode<V> x;
.first = x = <V>(.EMPTY, h, k, v, f, xp);
(f != ) {
f.prev = x;
}
(dir <= ) {
xp.left = x;
} {
xp.right = x;
}
(!xp.red) {
x.red = ;
} {
.lockRoot();
{
.root = .<V>balanceInsertion(.root, x);
} {
.unlockRoot();
}
}
}
.checkInvariants(.root);
;
}
}
{
TreeNode<V> next = (TreeNode)p.next;
TreeNode<V> pred = p.prev;
(pred == ) {
.first = next;
} {
pred.next = next;
}
(next != ) {
next.prev = pred;
}
(.first == ) {
.root = ;
;
} {
TreeNode<V> r;
TreeNode<V> rl;
((r = .root) != && r.right != && (rl = r.left) != && rl.left != ) {
.lockRoot();
{
TreeNode<V> pl = p.left;
TreeNode<V> pr = p.right;
TreeNode<V> replacement;
(pl != && pr != ) {
TreeNode<V> s;
TreeNode<V> sl;
(s = pr; (sl = s.left) != ; s = sl) {
}
s.red;
s.red = p.red;
p.red = c;
TreeNode<V> sr = s.right;
TreeNode<V> pp = p.parent;
(s == pr) {
p.parent = s;
s.right = p;
} {
TreeNode<V> sp = s.parent;
((p.parent = sp) != ) {
(s == sp.left) {
sp.left = p;
} {
sp.right = p;
}
}
((s.right = pr) != ) {
pr.parent = s;
}
}
p.left = ;
((p.right = sr) != ) {
sr.parent = p;
}
((s.left = pl) != ) {
pl.parent = s;
}
((s.parent = pp) == ) {
r = s;
} (p == pp.left) {
pp.left = s;
} {
pp.right = s;
}
(sr != ) {
replacement = sr;
} {
replacement = p;
}
} (pl != ) {
replacement = pl;
} (pr != ) {
replacement = pr;
} {
replacement = p;
}
(replacement != p) {
TreeNode<V> pp = replacement.parent = p.parent;
(pp == ) {
r = replacement;
} (p == pp.left) {
pp.left = replacement;
} {
pp.right = replacement;
}
p.left = p.right = p.parent = ;
}
.root = p.red ? r : .balanceDeletion(r, replacement);
TreeNode<V> pp;
(p == replacement && (pp = p.parent) != ) {
(p == pp.left) {
pp.left = ;
} (p == pp.right) {
pp.right = ;
}
p.parent = ;
}
} {
.unlockRoot();
}
.checkInvariants(.root);
;
} {
;
}
}
}
<V> TreeNode<V> {
TreeNode<V> r;
(p != && (r = p.right) != ) {
TreeNode<V> rl;
((rl = p.right = r.left) != ) {
rl.parent = p;
}
TreeNode<V> pp;
((pp = r.parent = p.parent) == ) {
root = r;
r.red = ;
} (pp.left == p) {
pp.left = r;
} {
pp.right = r;
}
r.left = p;
p.parent = r;
}
root;
}
<V> TreeNode<V> {
TreeNode<V> l;
(p != && (l = p.left) != ) {
TreeNode<V> lr;
((lr = p.left = l.right) != ) {
lr.parent = p;
}
TreeNode<V> pp;
((pp = l.parent = p.parent) == ) {
root = l;
l.red = ;
} (pp.right == p) {
pp.right = l;
} {
pp.left = l;
}
l.right = p;
p.parent = l;
}
root;
}
<V> TreeNode<V> {
x.red = ;
TreeNode<V> xp;
((xp = x.parent) != ) {
TreeNode<V> xpp;
(!xp.red || (xpp = xp.parent) == ) {
root;
}
TreeNode<V> xppl;
(xp == (xppl = xpp.left)) {
TreeNode<V> xppr;
((xppr = xpp.right) != && xppr.red) {
xppr.red = ;
xp.red = ;
xpp.red = ;
x = xpp;
} {
(x == xp.right) {
x = xp;
root = .<V>rotateLeft(root, xp);
xpp = (xp = xp.parent) == ? : xp.parent;
}
(xp != ) {
xp.red = ;
(xpp != ) {
xpp.red = ;
root = .<V>rotateRight(root, xpp);
}
}
}
} (xppl != && xppl.red) {
xppl.red = ;
xp.red = ;
xpp.red = ;
x = xpp;
} {
(x == xp.left) {
x = xp;
root = .<V>rotateRight(root, xp);
xpp = (xp = xp.parent) == ? : xp.parent;
}
(xp != ) {
xp.red = ;
(xpp != ) {
xpp.red = ;
root = .<V>rotateLeft(root, xpp);
}
}
}
}
x.red = ;
x;
}
<V> TreeNode<V> {
(x != && x != root) {
TreeNode<V> xp;
((xp = x.parent) == ) {
x.red = ;
x;
}
(x.red) {
x.red = ;
root;
}
TreeNode<V> xpl;
((xpl = xp.left) == x) {
TreeNode<V> xpr;
((xpr = xp.right) != && xpr.red) {
xpr.red = ;
xp.red = ;
root = .<V>rotateLeft(root, xp);
xpr = (xp = x.parent) == ? : xp.right;
}
(xpr == ) {
x = xp;
} {
TreeNode<V> sl = xpr.left;
TreeNode<V> sr = xpr.right;
(sr != && sr.red || sl != && sl.red) {
(sr == || !sr.red) {
(sl != ) {
sl.red = ;
}
xpr.red = ;
root = .<V>rotateRight(root, xpr);
xpr = (xp = x.parent) == ? : xp.right;
}
(xpr != ) {
xpr.red = xp == ? : xp.red;
((sr = xpr.right) != ) {
sr.red = ;
}
}
(xp != ) {
xp.red = ;
root = .<V>rotateLeft(root, xp);
}
x = root;
} {
xpr.red = ;
x = xp;
}
}
} {
(xpl != && xpl.red) {
xpl.red = ;
xp.red = ;
root = .<V>rotateRight(root, xp);
xpl = (xp = x.parent) == ? : xp.left;
}
(xpl == ) {
x = xp;
} {
TreeNode<V> sl = xpl.left;
TreeNode<V> sr = xpl.right;
(sl != && sl.red || sr != && sr.red) {
(sl == || !sl.red) {
(sr != ) {
sr.red = ;
}
xpl.red = ;
root = .<V>rotateLeft(root, xpl);
xpl = (xp = x.parent) == ? : xp.left;
}
(xpl != ) {
xpl.red = xp == ? : xp.red;
((sl = xpl.left) != ) {
sl.red = ;
}
}
(xp != ) {
xp.red = ;
root = .<V>rotateRight(root, xp);
}
x = root;
} {
xpl.red = ;
x = xp;
}
}
}
}
root;
}
<V> {
TreeNode<V> tp = t.parent;
TreeNode<V> tl = t.left;
TreeNode<V> tr = t.right;
TreeNode<V> tb = t.prev;
TreeNode<V> tn = (TreeNode)t.next;
(tb != && tb.next != t) {
;
} (tn != && tn.prev != t) {
;
} (tp != && t != tp.left && t != tp.right) {
;
} (tl == || tl.parent == t && tl.hash <= t.hash) {
(tr == || tr.parent == t && tr.hash >= t.hash) {
(t.red && tl != && tl.red && tr != && tr.red) {
;
} (tl != && !.checkInvariants(tl)) {
;
} {
tr == || .checkInvariants(tr);
}
} {
;
}
} {
;
}
}
{
{
Unsafe.class.getDeclaredField();
f.setAccessible();
U = (Unsafe)f.get((Object));
Class<?> k = TreeBin.class;
LOCKSTATE = U.objectFieldOffset(k.getDeclaredField());
} (Exception e) {
(e);
}
}
}
<V> {
length;
index;
Node<V>[] tab;
TableStack<V> next;
{
}
}
<V> {
Node<V>[] tab;
Node<V> next;
TableStack<V> stack;
TableStack<V> spare;
index;
baseIndex;
baseLimit;
baseSize;
{
.tab = tab;
.baseSize = size;
.baseIndex = .index = index;
.baseLimit = limit;
.next = ;
}
Node<V> {
Node<V> e;
((e = .next) != ) {
e = e.next;
}
(e == ) {
Node<V>[] t;
i;
n;
(.baseIndex >= .baseLimit || (t = .tab) == || (n = t.length) <= (i = .index) || i < ) {
.next = ;
}
((e = Float2ObjectConcurrentHashMap.<V>tabAt(t, i)) != && e.hash < ) {
(e ForwardingNode) {
.tab = ((ForwardingNode)e).nextTable;
e = ;
.pushState(t, i, n);
;
}
(e TreeBin) {
e = ((TreeBin)e).first;
} {
e = ;
}
}
(.stack != ) {
.recoverState(n);
} ((.index = i + .baseSize) >= n) {
.index = ++.baseIndex;
}
}
.next = e;
}
{
TableStack<V> s = .spare;
(s != ) {
.spare = s.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = i;
s.next = .stack;
.stack = s;
}
{
TableStack<V> s;
len;
((s = .stack) != && (.index += len = s.length) >= n) {
n = len;
.index = s.index;
.tab = s.tab;
s.tab = ;
TableStack<V> next = s.next;
s.next = .spare;
.stack = next;
.spare = s;
}
(s == && (.index += .baseSize) >= n) {
.index = ++.baseIndex;
}
}
}
<V> <V> {
Float2ObjectConcurrentHashMap<V> map;
Node<V> lastReturned;
{
(tab, size, index, limit);
.map = map;
.advance();
}
{
.next != ;
}
{
.next != ;
}
{
Node<V> p;
((p = .lastReturned) == ) {
();
} {
.lastReturned = ;
.map.replaceNode(p.key, (Object), (Object));
}
}
}
<V> {
Node<V>[] tab;
Node<V> next;
TableStack<V> stack;
TableStack<V> spare;
index;
baseIndex;
baseLimit;
baseSize;
Float2ObjectConcurrentHashMap<V> map;
Node<V> lastReturned;
{
.tab = tab;
.baseSize = size;
.baseIndex = .index = index;
.baseLimit = limit;
.next = ;
.map = map;
.advance();
}
Node<V> {
Node<V> e;
((e = .next) != ) {
e = e.next;
}
(e == ) {
Node<V>[] t;
i;
n;
(.baseIndex >= .baseLimit || (t = .tab) == || (n = t.length) <= (i = .index) || i < ) {
.next = ;
}
((e = Float2ObjectConcurrentHashMap.<V>tabAt(t, i)) != && e.hash < ) {
(e ForwardingNode) {
.tab = ((ForwardingNode)e).nextTable;
e = ;
.pushState(t, i, n);
;
}
(e TreeBin) {
e = ((TreeBin)e).first;
} {
e = ;
}
}
(.stack != ) {
.recoverState(n);
} ((.index = i + .baseSize) >= n) {
.index = ++.baseIndex;
}
}
.next = e;
}
{
TableStack<V> s = .spare;
(s != ) {
.spare = s.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = i;
s.next = .stack;
.stack = s;
}
{
TableStack<V> s;
len;
((s = .stack) != && (.index += len = s.length) >= n) {
n = len;
.index = s.index;
.tab = s.tab;
s.tab = ;
TableStack<V> next = s.next;
s.next = .spare;
.stack = next;
.spare = s;
}
(s == && (.index += .baseSize) >= n) {
.index = ++.baseIndex;
}
}
{
.next != ;
}
{
.next != ;
}
{
Node<V> p;
((p = .lastReturned) == ) {
();
} {
.lastReturned = ;
.map.replaceNode(p.key, (Object), (Object));
}
}
{
Node<V> p;
((p = .next) == ) {
();
} {
p.key;
.lastReturned = p;
.advance();
k;
}
}
}
<V> <V> <V>, Enumeration<V> {
{
(tab, index, size, limit, map);
}
V {
Node<V> p;
((p = .next) == ) {
();
} {
p.val;
.lastReturned = p;
.advance();
v;
}
}
V {
(V).next();
}
}
<V> <V> <Float2ObjectMap.Entry<V>> {
{
(tab, index, size, limit, map);
}
Entry<V> {
Node<V> p;
((p = .next) == ) {
();
} {
p.key;
p.val;
.lastReturned = p;
.advance();
<V>(p.isEmpty(), k, v, .map);
}
}
}
<V> .Entry<V> {
;
Float ;
;
V ;
;
String ;
;
V ;
}
<V> <V> {
empty;
key;
V val;
Float2ObjectConcurrentHashMap<V> map;
{
.empty = empty;
.key = key;
.val = val;
.map = map;
}
{
.empty;
}
Float {
.key;
}
{
.key;
}
V {
.val;
}
String {
(.empty) {
+ String.valueOf(.val);
} {
.key;
var10000 + + String.valueOf(.val);
}
}
{
( == o) {
;
} (o Entry) {
(.empty != ((Entry)o).isEmpty()) {
;
} (!.empty && .key != ((Entry)o).getFloatKey()) {
;
} {
.val.equals(((Entry)o).getValue());
}
} {
;
}
}
{
.empty ? : ;
result = * result + Float.hashCode(.key);
result = * result + .val.hashCode();
result;
}
V {
(value == ) {
();
} {
.val;
.val = value;
.map.put(.key, value);
v;
}
}
}
<V> <V> {
est;
{
(tab, size, index, limit);
.est = est;
}
FloatSpliterator {
i;
f;
h;
(h = (i = .baseIndex) + (f = .baseLimit) >>> ) <= i ? : (.tab, .baseSize, .baseLimit = h, f, .est >>>= );
}
{
action FloatConsumer ? .tryAdvance((FloatConsumer)action) : .tryAdvance((FloatConsumer)((value) -> action.accept(value)));
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) != ) {
action.accept(p.key);
}
}
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) == ) {
;
} {
action.accept(p.key);
;
}
}
}
{
.est;
}
{
;
}
}
<V> <V> <V> {
est;
{
(tab, size, index, limit);
.est = est;
}
ObjectSpliterator<V> {
i;
f;
h;
(h = (i = .baseIndex) + (f = .baseLimit) >>> ) <= i ? : (.tab, .baseSize, .baseLimit = h, f, .est >>>= );
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) != ) {
action.accept(p.val);
}
}
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) == ) {
;
} {
action.accept(p.val);
;
}
}
}
{
.est;
}
{
;
}
}
<V> <V> <Float2ObjectMap.Entry<V>> {
Float2ObjectConcurrentHashMap<V> map;
est;
{
(tab, size, index, limit);
.map = map;
.est = est;
}
ObjectSpliterator<Float2ObjectMap.Entry<V>> trySplit() {
i;
f;
h;
(h = (i = .baseIndex) + (f = .baseLimit) >>> ) <= i ? : (.tab, .baseSize, .baseLimit = h, f, .est >>>= , .map);
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) != ) {
action.accept( (p.isEmpty(), p.key, p.val, .map));
}
}
}
{
(action == ) {
();
} {
Node<V> p;
((p = .advance()) == ) {
;
} {
action.accept( (p.isEmpty(), p.key, p.val, .map));
;
}
}
}
{
.est;
}
{
;
}
}
<K, E> <E>, Serializable {
;
Float2ObjectConcurrentHashMap<K> map;
;
{
.map = map;
}
Float2ObjectConcurrentHashMap<K> {
.map;
}
{
.map.clear();
}
{
.map.size();
}
{
.map.isEmpty();
}
ObjectIterator<E> ;
;
;
Object[] toArray() {
.map.mappingCount();
(sz > ) {
();
} {
()sz;
Object[] r = [n];
;
(E e : ) {
(i == n) {
(n >= ) {
();
}
(n >= ) {
n = ;
} {
n += (n >>> ) + ;
}
r = Arrays.copyOf(r, n);
}
r[i++] = e;
}
i == n ? r : Arrays.copyOf(r, i);
}
}
<T> T[] toArray(T[] a) {
.map.mappingCount();
(sz > ) {
();
} {
()sz;
T[] r = (T[])(a.length >= m ? a : (Object[])Array.newInstance(a.getClass().getComponentType(), m));
r.length;
;
(E e : ) {
(i == n) {
(n >= ) {
();
}
(n >= ) {
n = ;
} {
n += (n >>> ) + ;
}
r = (T[])Arrays.copyOf(r, n);
}
r[i++] = e;
}
(a == r && i < n) {
r[i] = ;
r;
} {
(T[])(i == n ? r : Arrays.copyOf(r, i));
}
}
}
String {
();
sb.append();
Iterator<E> it = .iterator();
(it.hasNext()) {
() {
it.next();
sb.append(e == ? : e);
(!it.hasNext()) {
;
}
sb.append().append();
}
}
sb.append().toString();
}
{
(c != ) {
(Object e : c) {
(e == || !.contains(e)) {
;
}
}
}
;
}
{
(c == ) {
();
} {
;
Iterator<E> it = .iterator();
(it.hasNext()) {
(c.contains(it.next())) {
it.remove();
modified = ;
}
}
modified;
}
}
{
(c == ) {
();
} {
;
Iterator<E> it = .iterator();
(it.hasNext()) {
(!c.contains(it.next())) {
it.remove();
modified = ;
}
}
modified;
}
}
}
<V> {
;
Float2ObjectConcurrentHashMap<V> map;
V value;
{
.map = map;
.value = value;
}
V {
.value;
}
{
.map.containsKey(o);
}
{
.map.remove(o) != ;
}
FloatIterator {
Float2ObjectConcurrentHashMap<V> m = .map;
Node<V>[] t;
(t = m.table) == ? : t.length;
(t, f, , f, m);
}
{
V v;
((v = .value) == ) {
();
} {
.map.putVal(e, v, ) == ;
}
}
{
;
V v;
((v = .value) == ) {
();
} {
c.iterator();
(iter.hasNext()) {
iter.nextFloat();
(.map.putVal(e, v, ) == ) {
added = ;
}
}
added;
}
}
{
;
( .iterator(); iter.hasNext(); h += Float.hashCode(iter.nextFloat())) {
}
h;
}
{
FloatSet c;
o FloatSet && ((c = (FloatSet)o) == || .containsAll(c) && c.containsAll());
}
{
.map.EMPTY;
}
{
.map.size();
}
{
.map.isEmpty();
}
Object[] toArray() {
Object[] out = [.size()];
.iterator();
i;
(i = ; i < out.length && iter.hasNext(); ++i) {
out[i] = iter.nextFloat();
}
(out.length > i + ) {
out[i] = .map.EMPTY;
}
out;
}
Object[] toArray(Object[] dest) {
.iterator();
i;
(i = ; i < dest.length && iter.hasNext() && i <= dest.length; ++i) {
dest[i] = iter.next();
}
(dest.length > i + ) {
dest[i] = .map.EMPTY;
}
dest;
}
[] toFloatArray() {
[] out = [.size()];
.iterator();
i;
(i = ; i < out.length && iter.hasNext(); ++i) {
out[i] = iter.next();
}
(out.length > i + ) {
out[i] = .map.EMPTY;
}
out;
}
[] toArray([] dest) {
.iterator();
i;
(i = ; i < dest.length && iter.hasNext() && i <= dest.length; ++i) {
dest[i] = iter.next();
}
(dest.length > i + ) {
dest[i] = .map.EMPTY;
}
dest;
}
[] toFloatArray([] dest) {
.toArray(dest);
}
{
(Object element : collection) {
(!(element Long)) {
;
}
(Float)element;
(!.contains(c)) {
;
}
}
;
}
{
collection.iterator();
(iter.hasNext()) {
iter.next();
(!.contains(element)) {
;
}
}
;
}
{
array.length;
(i-- > ) {
(!.contains(array[i])) {
;
}
}
;
}
{
;
(Float element : collection) {
element;
(.add(e)) {
changed = ;
}
}
changed;
}
{
;
array.length;
(i-- > ) {
(.add(array[i])) {
changed = ;
}
}
changed;
}
{
;
.iterator();
(iter.hasNext()) {
(!collection.contains(iter.next())) {
iter.remove();
modified = ;
}
}
modified;
}
{
( == collection) {
;
} {
;
.iterator();
(iter.hasNext()) {
(!collection.contains(iter.next())) {
iter.remove();
modified = ;
}
}
modified;
}
}
{
;
.iterator();
(iter.hasNext()) {
(Arrays.binarySearch(array, iter.next()) < ) {
iter.remove();
modified = ;
}
}
modified;
}
{
;
(Object element : collection) {
(element Float) {
(Float)element;
(.remove(c)) {
changed = ;
}
}
}
changed;
}
{
;
collection.iterator();
(iter.hasNext()) {
iter.next();
(.remove(element)) {
changed = ;
}
}
changed;
}
{
;
array.length;
(i-- > ) {
(.remove(array[i])) {
changed = ;
}
}
changed;
}
{
.map.clear();
}
FloatSpliterator {
Float2ObjectConcurrentHashMap<V> m = .map;
m.sumCount();
Node<V>[] t;
(t = m.table) == ? : t.length;
(t, f, , f, n < ? : n);
}
}
<V> <V, V> <V>, Serializable {
;
{
(map);
}
{
.map.containsValue(o);
}
{
(o != ) {
Iterator<V> it = .iterator();
(it.hasNext()) {
(o.equals(it.next())) {
it.remove();
;
}
}
}
;
}
ObjectIterator<V> {
Float2ObjectConcurrentHashMap<V> m = .map;
Node<V>[] t;
(t = m.table) == ? : t.length;
<V>(t, f, , f, m);
}
{
();
}
{
();
}
ObjectSpliterator<V> {
Float2ObjectConcurrentHashMap<V> m = .map;
m.sumCount();
Node<V>[] t;
(t = m.table) == ? : t.length;
<V>(t, f, , f, n < ? : n);
}
{
(action == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
action.accept(p.val);
}
}
}
}
<A, B, C, D> {
(consumer == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
consumer.accept(p.val, a, d1, d2, d3, d4, d5, d6, d7, d8, d9, b, c, d);
}
}
}
}
<A, B, C, D> {
(consumer == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
consumer.accept(p.val, a, d1, d2, d3, d4, d5, d6, b, c, d);
}
}
}
}
{
(consumer == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
consumer.accept(p.val, ii);
}
}
}
}
{
(consumer == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
consumer.accept(p.val, ii);
}
}
}
}
{
(consumer == ) {
();
} {
Node<V>[] tt;
((tt = .map.table) != ) {
Node<V>[] tab = tt;
Node<V> next = ;
TableStack<V> stack = ;
TableStack<V> spare = ;
;
;
tt.length;
tt.length;
() {
Node<V> p = ;
p = next;
(next != ) {
p = next.next;
}
label80: {
() {
(p != ) {
next = p;
label80;
}
(baseIndex >= baseLimit) {
;
}
Node<V>[] t = tab;
n;
(tab == || (n = tab.length) <= index || index < ) {
;
}
((p = Float2ObjectConcurrentHashMap.<V>tabAt(tab, index)) != && p.hash < ) {
(p ForwardingNode) {
tab = ((ForwardingNode)p).nextTable;
p = ;
TableStack<V> s = spare;
(spare != ) {
spare = spare.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = index;
s.next = stack;
stack = s;
;
}
(p TreeBin) {
p = ((TreeBin)p).first;
} {
p = ;
}
}
(stack == ) {
((index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
} {
() {
TableStack<V> s = stack;
len;
(stack == || (index += len = stack.length) < n) {
(stack == && (index += baseSize) >= n) {
++baseIndex;
index = baseIndex;
}
;
}
n = len;
index = stack.index;
tab = stack.tab;
stack.tab = ;
TableStack<V> anext = stack.next;
stack.next = spare;
stack = anext;
spare = s;
}
}
}
next = ;
}
(p == ) {
;
}
consumer.accept(p.val, ii);
}
}
}
}
}
<V> <V, Float2ObjectMap.Entry<V>> <Float2ObjectMap.Entry<V>>, Serializable {
;
{
(map);
}
{
(o Float2ObjectMap.Entry) {
Float2ObjectMap.Entry<?> e;
(e = (Float2ObjectMap.Entry)o).getFloatKey();
(!((Entry)o).isEmpty()) {
Object v;
Object r;
(r = .map.get(k)) != && (v = e.getValue()) != && (v == r || v.equals(r));
}
}
;
}
{
(o Float2ObjectMap.Entry) {
Float2ObjectMap.Entry<?> e;
(e = (Float2ObjectMap.Entry)o).getFloatKey();
(!((Entry)o).isEmpty()) {
Object v;
(v = e.getValue()) != && .map.remove(k, v);
}
}
;
}
ObjectIterator<Float2ObjectMap.Entry<V>> iterator() {
Float2ObjectConcurrentHashMap<V> m = .map;
Node<V>[] t;
(t = m.table) == ? : t.length;
<Float2ObjectMap.Entry<V>>(t, f, , f, m);
}
{
.map.putVal(e.getFloatKey(), e.getValue(), ) == ;
}
{
;
(Float2ObjectMap.Entry<V> e : c) {
(.add(e)) {
added = ;
}
}
added;
}
{
;
Node<V>[] t;
Node<V> p;
((t = .map.table) != ) {
(Traverser<V> it = <V>(t, t.length, , t.length); (p = it.advance()) != ; h += p.hashCode()) {
}
}
h;
}
{
Set<?> c;
o Set && ((c = (Set)o) == || .containsAll(c) && c.containsAll());
}
ObjectSpliterator<Float2ObjectMap.Entry<V>> spliterator() {
Float2ObjectConcurrentHashMap<V> m = .map;
m.sumCount();
Node<V>[] t;
(t = m.table) == ? : t.length;
<Float2ObjectMap.Entry<V>>(t, f, , f, n < ? : n, m);
}
{
(action == ) {
();
} {
Node<V>[] t;
((t = .map.table) != ) {
Traverser<V> it = <V>(t, t.length, , t.length);
Node<V> p;
((p = it.advance()) != ) {
action.accept( (p.isEmpty(), p.key, p.val, .map));
}
}
}
}
}
<V, R> <R> {
Node<V>[] tab;
Node<V> next;
TableStack<V> stack;
TableStack<V> spare;
index;
baseIndex;
baseLimit;
baseSize;
batch;
{
(par);
.batch = b;
.index = .baseIndex = i;
((.tab = t) == ) {
.baseSize = .baseLimit = ;
} (par == ) {
.baseSize = .baseLimit = t.length;
} {
.baseLimit = f;
.baseSize = par.baseSize;
}
}
Node<V> {
Node<V> e;
((e = .next) != ) {
e = e.next;
}
(e == ) {
Node<V>[] t;
i;
n;
(.baseIndex >= .baseLimit || (t = .tab) == || (n = t.length) <= (i = .index) || i < ) {
.next = ;
}
((e = Float2ObjectConcurrentHashMap.<V>tabAt(t, i)) != && e.hash < ) {
(e ForwardingNode) {
.tab = ((ForwardingNode)e).nextTable;
e = ;
.pushState(t, i, n);
;
}
(e TreeBin) {
e = ((TreeBin)e).first;
} {
e = ;
}
}
(.stack != ) {
.recoverState(n);
} ((.index = i + .baseSize) >= n) {
.index = ++.baseIndex;
}
}
.next = e;
}
{
TableStack<V> s = .spare;
(s != ) {
.spare = s.next;
} {
s = <V>();
}
s.tab = t;
s.length = n;
s.index = i;
s.next = .stack;
.stack = s;
}
{
TableStack<V> s;
len;
((s = .stack) != && (.index += len = s.length) >= n) {
n = len;
.index = s.index;
.tab = s.tab;
s.tab = ;
TableStack<V> next = s.next;
s.next = .spare;
.stack = next;
.spare = s;
}
(s == && (.index += .baseSize) >= n) {
.index = ++.baseIndex;
}
}
}
<V> <V, Float> {
result;
{
(par, b, i, f, t);
}
{
.quietlyInvoke();
.getException();
(exc != ) {
SneakyThrow.sneakyThrow(exc);
} {
.result;
}
}
}
<V> <V, Long> {
result;
{
(par, b, i, f, t);
}
{
.quietlyInvoke();
.getException();
(exc != ) {
SneakyThrow.sneakyThrow(exc);
} {
.result;
}
}
}
<V> <V, Integer> {
result;
{
(par, b, i, f, t);
}
{
.quietlyInvoke();
.getException();
(exc != ) {
SneakyThrow.sneakyThrow(exc);
} {
.result;
}
}
}
<V> <V, Double> {
result;
{
(par, b, i, f, t);
}
{
.quietlyInvoke();
.getException();
(exc != ) {
SneakyThrow.sneakyThrow(exc);
} {
.result;
}
}
}
<V> <V, Void> {
FloatConsumer action;
{
(p, b, i, f, t);
.action = action;
}
{
FloatConsumer action;
((action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, action)).fork();
}
((p = .advance()) != ) {
action.accept(p.key);
}
.propagateCompletion();
}
}
}
<V> <V, Void> {
Consumer<? V> action;
{
(p, b, i, f, t);
.action = action;
}
{
Consumer<? V> action;
((action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, action)).fork();
}
((p = .advance()) != ) {
action.accept(p.val);
}
.propagateCompletion();
}
}
}
<V> <V, Void> {
Consumer<? Entry<V>> action;
{
(p, b, i, f, t);
.action = action;
}
{
Consumer<? Entry<V>> action;
((action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, action)).fork();
}
((p = .advance()) != ) {
action.accept(p);
}
.propagateCompletion();
}
}
}
<V> <V, Void> {
FloatObjConsumer<? V> action;
{
(p, b, i, f, t);
.action = action;
}
{
FloatObjConsumer<? V> action;
((action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, action)).fork();
}
((p = .advance()) != ) {
action.accept(p.key, p.val);
}
.propagateCompletion();
}
}
}
<V, U> <V, Void> {
FloatFunction<? > transformer;
Consumer<? U> action;
{
(p, b, i, f, t);
.transformer = transformer;
.action = action;
}
{
FloatFunction<? > transformer;
Consumer<? U> action;
((transformer = .transformer) != && (action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, transformer, action)).fork();
}
((p = .advance()) != ) {
U u;
((u = transformer.apply(p.key)) != ) {
action.accept(u);
}
}
.propagateCompletion();
}
}
}
<V, U> <V, Void> {
Function<? V, ? > transformer;
Consumer<? U> action;
{
(p, b, i, f, t);
.transformer = transformer;
.action = action;
}
{
Function<? V, ? > transformer;
Consumer<? U> action;
((transformer = .transformer) != && (action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, transformer, action)).fork();
}
((p = .advance()) != ) {
U u;
((u = (U)transformer.apply(p.val)) != ) {
action.accept(u);
}
}
.propagateCompletion();
}
}
}
<V, U> <V, Void> {
Function<Entry<V>, ? > transformer;
Consumer<? U> action;
{
(p, b, i, f, t);
.transformer = transformer;
.action = action;
}
{
Function<Entry<V>, ? > transformer;
Consumer<? U> action;
((transformer = .transformer) != && (action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, transformer, action)).fork();
}
((p = .advance()) != ) {
U u;
((u = (U)transformer.apply(p)) != ) {
action.accept(u);
}
}
.propagateCompletion();
}
}
}
<V, U> <V, Void> {
FloatObjFunction<? V, ? > transformer;
Consumer<? U> action;
{
(p, b, i, f, t);
.transformer = transformer;
.action = action;
}
{
FloatObjFunction<? V, ? > transformer;
Consumer<? U> action;
((transformer = .transformer) != && (action = .action) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, transformer, action)).fork();
}
((p = .advance()) != ) {
U u;
((u = transformer.apply(p.key, p.val)) != ) {
action.accept(u);
}
}
.propagateCompletion();
}
}
}
<V, U> <V, U> {
FloatFunction<? > searchFunction;
AtomicReference<U> result;
{
(p, b, i, f, t);
.searchFunction = searchFunction;
.result = result;
}
U {
(U).result.get();
}
{
FloatFunction<? > searchFunction;
AtomicReference<U> result;
((searchFunction = .searchFunction) != && (result = .result) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
(result.get() != ) {
;
}
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, searchFunction, result)).fork();
}
(result.get() == ) {
Node<V> p;
((p = .advance()) == ) {
.propagateCompletion();
;
}
U u;
((u = searchFunction.apply(p.key)) != ) {
(result.compareAndSet((Object), u)) {
.quietlyCompleteRoot();
}
;
}
}
}
}
}
<V, U> <V, U> {
Function<? V, ? > searchFunction;
AtomicReference<U> result;
{
(p, b, i, f, t);
.searchFunction = searchFunction;
.result = result;
}
U {
(U).result.get();
}
{
Function<? V, ? > searchFunction;
AtomicReference<U> result;
((searchFunction = .searchFunction) != && (result = .result) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
(result.get() != ) {
;
}
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, searchFunction, result)).fork();
}
(result.get() == ) {
Node<V> p;
((p = .advance()) == ) {
.propagateCompletion();
;
}
U u;
((u = (U)searchFunction.apply(p.val)) != ) {
(result.compareAndSet((Object), u)) {
.quietlyCompleteRoot();
}
;
}
}
}
}
}
<V, U> <V, U> {
Function<Entry<V>, ? > searchFunction;
AtomicReference<U> result;
{
(p, b, i, f, t);
.searchFunction = searchFunction;
.result = result;
}
U {
(U).result.get();
}
{
Function<Entry<V>, ? > searchFunction;
AtomicReference<U> result;
((searchFunction = .searchFunction) != && (result = .result) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
(result.get() != ) {
;
}
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, searchFunction, result)).fork();
}
(result.get() == ) {
Node<V> p;
((p = .advance()) == ) {
.propagateCompletion();
;
}
U u;
((u = (U)searchFunction.apply(p)) != ) {
(result.compareAndSet((Object), u)) {
.quietlyCompleteRoot();
}
;
}
}
}
}
}
<V, U> <V, U> {
FloatObjFunction<? V, ? > searchFunction;
AtomicReference<U> result;
{
(p, b, i, f, t);
.searchFunction = searchFunction;
.result = result;
}
U {
(U).result.get();
}
{
FloatObjFunction<? V, ? > searchFunction;
AtomicReference<U> result;
((searchFunction = .searchFunction) != && (result = .result) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
(result.get() != ) {
;
}
.addToPendingCount();
( (, .batch >>>= , .baseLimit = h, f, .tab, searchFunction, result)).fork();
}
(result.get() == ) {
Node<V> p;
((p = .advance()) == ) {
.propagateCompletion();
;
}
U u;
((u = searchFunction.apply(p.key, p.val)) != ) {
(result.compareAndSet((Object), u)) {
.quietlyCompleteRoot();
}
;
}
}
}
}
}
<V> <V> {
EMPTY;
FloatReduceTaskOperator reducer;
ReduceKeysTask<V> rights;
ReduceKeysTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.EMPTY = EMPTY;
.reducer = reducer;
}
Float {
();
}
{
FloatReduceTaskOperator reducer;
((reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(.EMPTY, , .batch >>>= , .baseLimit = h, f, .tab, .rights, reducer)).fork();
}
i = ;
.EMPTY;
((p = .advance()) != ) {
p.key;
(!i) {
i = ;
r = u;
} (!p.isEmpty()) {
i = ;
r = reducer.reduce(.EMPTY, r, u);
}
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
ReduceKeysTask<V> t = (ReduceKeysTask)c;
(ReduceKeysTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
sr;
((sr = s.result) != .EMPTY) {
tr;
t.result = (tr = t.result) == .EMPTY ? sr : reducer.reduce(.EMPTY, tr, sr);
}
}
}
}
}
}
<V> <V, V> {
BiFunction<? V, ? V, ? > reducer;
V result;
ReduceValuesTask<V> rights;
ReduceValuesTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.reducer = reducer;
}
V {
.result;
}
{
BiFunction<? V, ? V, ? > reducer;
((reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, reducer)).fork();
}
(r = ; (p = .advance()) != ; r = (V)(r == ? v : reducer.apply(r, v))) {
v = p.val;
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
ReduceValuesTask<V> t = (ReduceValuesTask)c;
(ReduceValuesTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
V sr;
((sr = s.result) != ) {
V tr;
t.result = (V)((tr = t.result) == ? sr : reducer.apply(tr, sr));
}
}
}
}
}
}
<V> <V, Entry<V>> {
BiFunction<Entry<V>, Entry<V>, ? <V>> reducer;
Entry<V> result;
ReduceEntriesTask<V> rights;
ReduceEntriesTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.reducer = reducer;
}
Entry<V> {
.result;
}
{
BiFunction<Entry<V>, Entry<V>, ? <V>> reducer;
((reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, reducer)).fork();
}
(r = ; (p = .advance()) != ; r = (Entry<V>)(r == ? p : (Entry)reducer.apply(r, p))) {
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
ReduceEntriesTask<V> t = (ReduceEntriesTask)c;
(ReduceEntriesTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
Entry<V> sr;
((sr = s.result) != ) {
Entry<V> tr;
t.result = (tr = t.result) == ? sr : (Entry)reducer.apply(tr, sr);
}
}
}
}
}
}
<V, U> <V, U> {
FloatFunction<? > transformer;
BiFunction<? U, ? U, ? > reducer;
U result;
MapReduceKeysTask<V, U> rights;
MapReduceKeysTask<V, U> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.reducer = reducer;
}
U {
.result;
}
{
FloatFunction<? > transformer;
BiFunction<? U, ? U, ? > reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V, U>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, reducer)).fork();
}
;
((p = .advance()) != ) {
U u;
((u = transformer.apply(p.key)) != ) {
r = (U)(r == ? u : reducer.apply(r, u));
}
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceKeysTask<V, U> t = (MapReduceKeysTask)c;
(MapReduceKeysTask<V, U> s = t.rights; s != ; s = t.rights = s.nextRight) {
U sr;
((sr = s.result) != ) {
U tr;
t.result = (U)((tr = t.result) == ? sr : reducer.apply(tr, sr));
}
}
}
}
}
}
<V, U> <V, U> {
Function<? V, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
U result;
MapReduceValuesTask<V, U> rights;
MapReduceValuesTask<V, U> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.reducer = reducer;
}
U {
.result;
}
{
Function<? V, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V, U>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, reducer)).fork();
}
;
((p = .advance()) != ) {
U u;
((u = (U)transformer.apply(p.val)) != ) {
r = (U)(r == ? u : reducer.apply(r, u));
}
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceValuesTask<V, U> t = (MapReduceValuesTask)c;
(MapReduceValuesTask<V, U> s = t.rights; s != ; s = t.rights = s.nextRight) {
U sr;
((sr = s.result) != ) {
U tr;
t.result = (U)((tr = t.result) == ? sr : reducer.apply(tr, sr));
}
}
}
}
}
}
<V, U> <V, U> {
Function<Entry<V>, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
U result;
MapReduceEntriesTask<V, U> rights;
MapReduceEntriesTask<V, U> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.reducer = reducer;
}
U {
.result;
}
{
Function<Entry<V>, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V, U>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, reducer)).fork();
}
;
((p = .advance()) != ) {
U u;
((u = (U)transformer.apply(p)) != ) {
r = (U)(r == ? u : reducer.apply(r, u));
}
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceEntriesTask<V, U> t = (MapReduceEntriesTask)c;
(MapReduceEntriesTask<V, U> s = t.rights; s != ; s = t.rights = s.nextRight) {
U sr;
((sr = s.result) != ) {
U tr;
t.result = (U)((tr = t.result) == ? sr : reducer.apply(tr, sr));
}
}
}
}
}
}
<V, U> <V, U> {
FloatObjFunction<? V, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
U result;
MapReduceMappingsTask<V, U> rights;
MapReduceMappingsTask<V, U> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.reducer = reducer;
}
U {
.result;
}
{
FloatObjFunction<? V, ? > transformer;
BiFunction<? U, ? U, ? > reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V, U>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, reducer)).fork();
}
;
((p = .advance()) != ) {
U u;
((u = transformer.apply(p.key, p.val)) != ) {
r = (U)(r == ? u : reducer.apply(r, u));
}
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceMappingsTask<V, U> t = (MapReduceMappingsTask)c;
(MapReduceMappingsTask<V, U> s = t.rights; s != ; s = t.rights = s.nextRight) {
U sr;
((sr = s.result) != ) {
U tr;
t.result = (U)((tr = t.result) == ? sr : reducer.apply(tr, sr));
}
}
}
}
}
}
<V> <V> {
FloatToDoubleFunction transformer;
DoubleBinaryOperator reducer;
basis;
MapReduceKeysToDoubleTask<V> rights;
MapReduceKeysToDoubleTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Double {
();
}
{
FloatToDoubleFunction transformer;
DoubleBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceKeysToDoubleTask<V> t = (MapReduceKeysToDoubleTask)c;
(MapReduceKeysToDoubleTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsDouble(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToDoubleFunction<? V> transformer;
DoubleBinaryOperator reducer;
basis;
MapReduceValuesToDoubleTask<V> rights;
MapReduceValuesToDoubleTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Double {
();
}
{
ToDoubleFunction<? V> transformer;
DoubleBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceValuesToDoubleTask<V> t = (MapReduceValuesToDoubleTask)c;
(MapReduceValuesToDoubleTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsDouble(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToDoubleFunction<Entry<V>> transformer;
DoubleBinaryOperator reducer;
basis;
MapReduceEntriesToDoubleTask<V> rights;
MapReduceEntriesToDoubleTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Double {
();
}
{
ToDoubleFunction<Entry<V>> transformer;
DoubleBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsDouble(r, transformer.applyAsDouble(p));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceEntriesToDoubleTask<V> t = (MapReduceEntriesToDoubleTask)c;
(MapReduceEntriesToDoubleTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsDouble(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToDoubleFloatObjFunction<? V> transformer;
DoubleBinaryOperator reducer;
basis;
MapReduceMappingsToDoubleTask<V> rights;
MapReduceMappingsToDoubleTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Double {
();
}
{
ToDoubleFloatObjFunction<? V> transformer;
DoubleBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key, p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceMappingsToDoubleTask<V> t = (MapReduceMappingsToDoubleTask)c;
(MapReduceMappingsToDoubleTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsDouble(t.result, s.result);
}
}
}
}
}
<V> <V> {
FloatToLongFunction transformer;
LongBinaryOperator reducer;
basis;
MapReduceKeysToLongTask<V> rights;
MapReduceKeysToLongTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Long {
();
}
{
FloatToLongFunction transformer;
LongBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsLong(r, transformer.applyAsLong(p.key));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceKeysToLongTask<V> t = (MapReduceKeysToLongTask)c;
(MapReduceKeysToLongTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsLong(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToLongFunction<? V> transformer;
LongBinaryOperator reducer;
basis;
MapReduceValuesToLongTask<V> rights;
MapReduceValuesToLongTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Long {
();
}
{
ToLongFunction<? V> transformer;
LongBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsLong(r, transformer.applyAsLong(p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceValuesToLongTask<V> t = (MapReduceValuesToLongTask)c;
(MapReduceValuesToLongTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsLong(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToLongFunction<Entry<V>> transformer;
LongBinaryOperator reducer;
basis;
MapReduceEntriesToLongTask<V> rights;
MapReduceEntriesToLongTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Long {
();
}
{
ToLongFunction<Entry<V>> transformer;
LongBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsLong(r, transformer.applyAsLong(p));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceEntriesToLongTask<V> t = (MapReduceEntriesToLongTask)c;
(MapReduceEntriesToLongTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsLong(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToLongFloatObjFunction<? V> transformer;
LongBinaryOperator reducer;
basis;
MapReduceMappingsToLongTask<V> rights;
MapReduceMappingsToLongTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Long {
();
}
{
ToLongFloatObjFunction<? V> transformer;
LongBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsLong(r, transformer.applyAsLong(p.key, p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceMappingsToLongTask<V> t = (MapReduceMappingsToLongTask)c;
(MapReduceMappingsToLongTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsLong(t.result, s.result);
}
}
}
}
}
<V> <V> {
FloatToIntFunction transformer;
IntBinaryOperator reducer;
basis;
MapReduceKeysToIntTask<V> rights;
MapReduceKeysToIntTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Integer {
();
}
{
FloatToIntFunction transformer;
IntBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsInt(r, transformer.applyAsInt(p.key));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceKeysToIntTask<V> t = (MapReduceKeysToIntTask)c;
(MapReduceKeysToIntTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsInt(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToIntFunction<? V> transformer;
IntBinaryOperator reducer;
basis;
MapReduceValuesToIntTask<V> rights;
MapReduceValuesToIntTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Integer {
();
}
{
ToIntFunction<? V> transformer;
IntBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsInt(r, transformer.applyAsInt(p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceValuesToIntTask<V> t = (MapReduceValuesToIntTask)c;
(MapReduceValuesToIntTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsInt(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToIntFunction<Entry<V>> transformer;
IntBinaryOperator reducer;
basis;
MapReduceEntriesToIntTask<V> rights;
MapReduceEntriesToIntTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Integer {
();
}
{
ToIntFunction<Entry<V>> transformer;
IntBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsInt(r, transformer.applyAsInt(p));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceEntriesToIntTask<V> t = (MapReduceEntriesToIntTask)c;
(MapReduceEntriesToIntTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsInt(t.result, s.result);
}
}
}
}
}
<V> <V> {
ToIntFloatObjFunction<? V> transformer;
IntBinaryOperator reducer;
basis;
MapReduceMappingsToIntTask<V> rights;
MapReduceMappingsToIntTask<V> nextRight;
{
(p, b, i, f, t);
.nextRight = nextRight;
.transformer = transformer;
.basis = basis;
.reducer = reducer;
}
Integer {
();
}
{
ToIntFloatObjFunction<? V> transformer;
IntBinaryOperator reducer;
((transformer = .transformer) != && (reducer = .reducer) != ) {
.basis;
.baseIndex;
f;
h;
(.batch > && (h = (f = .baseLimit) + i >>> ) > i) {
.addToPendingCount();
(.rights = <V>(, .batch >>>= , .baseLimit = h, f, .tab, .rights, transformer, r, reducer)).fork();
}
((p = .advance()) != ) {
r = reducer.applyAsInt(r, transformer.applyAsInt(p.key, p.val));
}
.result = r;
(CountedCompleter<?> c = .firstComplete(); c != ; c = c.nextComplete()) {
MapReduceMappingsToIntTask<V> t = (MapReduceMappingsToIntTask)c;
(MapReduceMappingsToIntTask<V> s = t.rights; s != ; s = t.rights = s.nextRight) {
t.result = reducer.applyAsInt(t.result, s.result);
}
}
}
}
}
<V, X> {
;
}
<V, X> {
;
}
<V, X> {
;
}
<V, X> {
;
}
<V, X, J> {
J ;
}
<V, X> {
;
}
<V, X> {
;
}
<V, X> {
;
}
<R> {
R ;
}
<V> {
;
}
<V, J> {
J ;
}
<V> {
;
}
<V> {
;
}
<V, J> {
J ;
}
<V> {
;
}
<V, J> {
J ;
}
<V, J> {
J ;
}
<V> {
;
}
<V, J> {
J ;
}
<V> {
;
}
<V, J> {
J ;
}
<V> {
;
}
<V, J> {
J ;
}
{
;
}
{
;
}
{
;
}
{
;
}
<V, X, Y> {
;
}
<V> {
;
}
<T> {
;
}
<V> {
;
}
<V> {
;
}
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2ObjectOperator<V> {
V apply(float var1, V var2);
}
package com.hypixel.fastutil.floats;
@FunctionalInterface
public interface Float2ShortOperator {
short apply(float var1, short var2);
}