Double2ObjectConcurrentHashMap class
Пакет: com.hypixel.fastutil.doubles
Файл: com/hypixel/fastutil/doubles/Double2ObjectConcurrentHashMap.java
Поля (2707)
| Модификаторы | Тип | Имя |
|---|---|---|
|
|
ABASE |
|
|
ASHIFT |
|
|
BASECOUNT |
|
|
CELLSBUSY |
|
|
CELLVALUE |
|
public final double |
EMPTY |
|
public final double |
EMPTY |
|
protected static final long |
LOCKSTATE |
|
|
LOCKSTATE |
|
public static final int |
READER |
|
|
SIZECTL |
|
|
TRANSFERINDEX |
|
|
U |
|
protected static final Unsafe |
U |
|
|
U |
|
public static final int |
WAITER |
|
public static final int |
WRITER |
|
public final DoubleConsumer |
action |
|
public int |
baseIndex |
|
public int |
baseIndex |
|
public int |
baseIndex |
|
public int |
baseLimit |
|
public int |
baseLimit |
|
public int |
baseLimit |
|
public final int |
baseSize |
|
public final int |
baseSize |
|
public final int |
baseSize |
|
public final double |
basis |
|
public final int |
basis |
|
public final long |
basis |
|
public final double |
basis |
|
public final int |
basis |
|
public final long |
basis |
|
public final double |
basis |
|
public final int |
basis |
|
public final long |
basis |
|
public final double |
basis |
|
public final int |
basis |
|
public final long |
basis |
|
public int |
batch |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
break |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
|
continue |
|
public final boolean |
empty |
|
public long |
est |
|
public long |
est |
|
public long |
est |
|
public volatile Double2ObjectConcurrentHashMap.TreeNode<V> |
first |
|
public final int |
hash |
|
public int |
index |
|
public int |
index |
|
public int |
index |
|
public int |
index |
|
public final double |
key |
|
public final double |
key |
|
public Double2ObjectConcurrentHashMap.Node<V> |
lastReturned |
|
public Double2ObjectConcurrentHashMap.Node<V> |
lastReturned |
|
public Double2ObjectConcurrentHashMap.TreeNode<V> |
left |
|
public int |
length |
|
public final float |
loadFactor |
|
public volatile int |
lockState |
|
public final Double2ObjectConcurrentHashMap<V> |
map |
|
public final Double2ObjectConcurrentHashMap<K> |
map |
|
public final Double2ObjectConcurrentHashMap<V> |
map |
|
public final Double2ObjectConcurrentHashMap<V> |
map |
|
public final Double2ObjectConcurrentHashMap<V> |
map |
|
public final Double2ObjectConcurrentHashMap<V> |
map |
|
public Double2ObjectConcurrentHashMap.Node<V> |
next |
|
public Double2ObjectConcurrentHashMap.Node<V> |
next |
|
public volatile Double2ObjectConcurrentHashMap.Node<V> |
next |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
next |
|
public Double2ObjectConcurrentHashMap.Node<V> |
next |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.ReduceKeysTask<V> |
nextRight |
|
public Double2ObjectConcurrentHashMap.ReduceValuesTask<V> |
nextRight |
|
public final Double2ObjectConcurrentHashMap.Node<V>[] |
nextTable |
|
protected static final String |
oomeMsg |
|
public Double2ObjectConcurrentHashMap.TreeNode<V> |
parent |
|
public Double2ObjectConcurrentHashMap.TreeNode<V> |
prev |
|
public boolean |
red |
|
public final DoubleBinaryOperator |
reducer |
|
public final IntBinaryOperator |
reducer |
|
public final LongBinaryOperator |
reducer |
|
public final DoubleBinaryOperator |
reducer |
|
public final IntBinaryOperator |
reducer |
|
public final LongBinaryOperator |
reducer |
|
public final DoubleBinaryOperator |
reducer |
|
public final IntBinaryOperator |
reducer |
|
public final LongBinaryOperator |
reducer |
|
public final DoubleBinaryOperator |
reducer |
|
public final IntBinaryOperator |
reducer |
|
public final LongBinaryOperator |
reducer |
|
public final Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator |
reducer |
|
public double |
result |
|
public double |
result |
|
public int |
result |
|
public long |
result |
|
public U |
result |
|
public U |
result |
|
public U |
result |
|
public U |
result |
|
public Double2ObjectConcurrentHashMap.Entry<V> |
result |
|
public V |
result |
|
public final AtomicReference<U> |
result |
|
public final AtomicReference<U> |
result |
|
public final AtomicReference<U> |
result |
|
public final AtomicReference<U> |
result |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
|
return |
|
public Double2ObjectConcurrentHashMap.TreeNode<V> |
right |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.ReduceKeysTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.ReduceValuesTask<V> |
rights |
|
public Double2ObjectConcurrentHashMap.TreeNode<V> |
root |
final |
long |
serialVersionUID |
|
public static final long |
serialVersionUID |
|
public static final long |
serialVersionUID |
|
public static final long |
serialVersionUID |
|
public static final long |
serialVersionUID |
|
public static final long |
serialVersionUID |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Double2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Double2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Double2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Double2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Double2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public final Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final Double2ObjectConcurrentHashMap.DoubleToDoubleFunction |
transformer |
|
public final Double2ObjectConcurrentHashMap.DoubleToIntFunction |
transformer |
|
public final Double2ObjectConcurrentHashMap.DoubleToLongFunction |
transformer |
|
public V |
val |
|
public volatile V |
val |
|
public volatile long |
value |
|
public final V |
value |
|
Field |
var0 |
|
Field |
var0 |
|
int |
var1 |
|
|
var1 |
|
long |
var1 |
|
long |
var1 |
|
Double2ObjectConcurrentHashMap.KeySetView |
var1 |
|
Double2ObjectConcurrentHashMap.ValuesView |
var1 |
|
Double2ObjectConcurrentHashMap.EntrySetView |
var1 |
|
int |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
long |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var1 |
|
Class |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
long |
var1 |
|
StringBuilder |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
Double2ObjectConcurrentHashMap |
var1 |
|
int |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
Consumer |
var1 |
|
DoubleConsumer |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleObjConsumer |
var1 |
|
Function |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleObjFunction |
var1 |
|
Function |
var1 |
|
Consumer |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
Object[] |
var1 |
|
double[] |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
int |
var1 |
|
|
var1 |
|
Function |
var1 |
|
Double2ObjectConcurrentHashMap.ToDoubleFunction |
var1 |
|
ToIntFunction |
var1 |
|
ToLongFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleToDoubleFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleToIntFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleToLongFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleObjFunction |
var1 |
|
Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction |
var1 |
|
Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction |
var1 |
|
Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction |
var1 |
|
Function |
var1 |
|
Double2ObjectConcurrentHashMap.ToDoubleFunction |
var1 |
|
ToIntFunction |
var1 |
|
ToLongFunction |
var1 |
|
BiFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator |
var1 |
|
BiFunction |
var1 |
|
Function |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleFunction |
var1 |
|
Double2ObjectConcurrentHashMap.DoubleObjFunction |
var1 |
|
Function |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
boolean |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Class |
var1 |
|
Double2ObjectConcurrentHashMap.Node |
var1 |
|
int |
var1 |
|
Double2ObjectConcurrentHashMap |
var1 |
|
Double2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
Object |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
Double2ObjectConcurrentHashMap.TableStack |
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
Double2ObjectConcurrentHashMap.TableStack |
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
Double2ObjectConcurrentHashMap.Node |
var10 |
|
long |
var10 |
|
int |
var10 |
|
|
var10 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
Double2ObjectConcurrentHashMap.Node |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask |
var10 |
|
Double2ObjectConcurrentHashMap.Node |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask |
var10 |
|
Double2ObjectConcurrentHashMap.Node |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask |
var10 |
|
Double2ObjectConcurrentHashMap.Node |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask |
var10 |
|
Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask |
var10 |
|
double |
var10 |
|
Class |
var10 |
|
double |
var10 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var10 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var10 |
|
|
var10 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
int |
var10000 |
|
double |
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
Object |
var11 |
|
|
var11 |
|
|
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
Object |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
boolean |
var11 |
|
|
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
boolean |
var11 |
|
Double2ObjectConcurrentHashMap.ReduceEntriesTask |
var11 |
|
Object |
var11 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var11 |
|
boolean |
var11 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var11 |
|
Double2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
Double2ObjectConcurrentHashMap.Node[] |
var12 |
|
Object |
var12 |
|
|
var12 |
|
|
var12 |
|
boolean |
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node[] |
var12 |
|
ObjectIterator |
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
Double2ObjectConcurrentHashMap.Node[] |
var12 |
|
boolean |
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var12 |
|
Double2ObjectConcurrentHashMap.Node[] |
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
Object |
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
boolean |
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.ReduceValuesTask |
var12 |
|
int |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Thread |
var12 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var12 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var12 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var12 |
|
Double2ObjectConcurrentHashMap.Node[] |
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Double2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
int |
var13 |
|
int |
var13 |
|
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
int |
var13 |
|
int |
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.MapReduceEntriesTask |
var13 |
|
Double2ObjectConcurrentHashMap.MapReduceKeysTask |
var13 |
|
Double2ObjectConcurrentHashMap.MapReduceMappingsTask |
var13 |
|
Double2ObjectConcurrentHashMap.MapReduceValuesTask |
var13 |
|
double |
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var13 |
|
|
var13 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var13 |
|
int |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node[] |
var13 |
|
Double2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
int |
var14 |
|
|
var14 |
|
double |
var14 |
|
int |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
|
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
int |
var14 |
|
int |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
int |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
int |
var14 |
|
double |
var14 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var14 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var14 |
|
int |
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
Double2ObjectConcurrentHashMap.Node[] |
var14 |
|
Double2ObjectConcurrentHashMap.TableStack |
var15 |
|
double |
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.TableStack |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
int |
var15 |
|
int |
var15 |
|
int |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
int |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.TableStack |
var15 |
|
double |
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
Double2ObjectConcurrentHashMap.Node[] |
var15 |
|
Double2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
int |
var15 |
|
Double2ObjectConcurrentHashMap.TableStack |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
int |
var15 |
|
int |
var15 |
|
|
var15 |
|
Double2ObjectConcurrentHashMap.ReduceKeysTask |
var15 |
|
Double2ObjectConcurrentHashMap.TableStack |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
int |
var16 |
|
double |
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
int |
var16 |
|
int |
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.Node[] |
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.Node[] |
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var16 |
|
double |
var16 |
|
double |
var16 |
|
Double2ObjectConcurrentHashMap.Node |
var16 |
|
|
var16 |
|
int |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
|
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var16 |
|
|
var16 |
|
int |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Double2ObjectConcurrentHashMap.Node |
var17 |
|
Object |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Object |
var17 |
|
double |
var17 |
|
Double2ObjectConcurrentHashMap.Node |
var17 |
|
|
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
int |
var17 |
|
int |
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
int |
var17 |
|
Double2ObjectConcurrentHashMap.TableStack |
var17 |
|
Object |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
int |
var18 |
|
int |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
|
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
|
var18 |
|
Double2ObjectConcurrentHashMap.Node |
var18 |
|
Double2ObjectConcurrentHashMap.Node |
var18 |
|
Double2ObjectConcurrentHashMap.Node |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
int |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var18 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var18 |
|
Double2ObjectConcurrentHashMap.Node[] |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
Double2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Object |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
int |
var19 |
|
int |
var19 |
|
int |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Object |
var19 |
|
Double2ObjectConcurrentHashMap.Node |
var19 |
|
int |
var19 |
|
Object |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Double2ObjectConcurrentHashMap.Node[] |
var19 |
|
|
var19 |
|
|
var19 |
|
Double2ObjectConcurrentHashMap.TableStack |
var19 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
ObjectIterator |
var2 |
|
ObjectIterator |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
int |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
|
var2 |
|
int |
var2 |
|
|
var2 |
|
Double2ObjectConcurrentHashMap.CounterCell |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
|
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
|
var2 |
|
|
var2 |
|
Class |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap.TableStack |
var2 |
|
long |
var2 |
|
Iterator |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
Throwable |
var2 |
|
Throwable |
var2 |
|
double |
var2 |
|
double |
var2 |
|
double |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Set |
var2 |
|
Double2ObjectConcurrentHashMap |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
int |
var2 |
|
int |
var2 |
|
int |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
int |
var2 |
|
Throwable |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap.TableStack |
var2 |
|
double |
var2 |
|
Double2ObjectConcurrentHashMap |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
DoubleIterator |
var2 |
|
DoubleSet |
var2 |
|
DoubleIterator |
var2 |
|
DoubleIterator |
var2 |
|
DoubleIterator |
var2 |
|
DoubleIterator |
var2 |
|
DoubleIterator |
var2 |
|
int |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
Double2ObjectConcurrentHashMap |
var2 |
|
int |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
Throwable |
var2 |
|
Object |
var2 |
|
BiFunction |
var2 |
|
DoubleBinaryOperator |
var2 |
|
IntBinaryOperator |
var2 |
|
LongBinaryOperator |
var2 |
|
BiFunction |
var2 |
|
DoubleBinaryOperator |
var2 |
|
IntBinaryOperator |
var2 |
|
LongBinaryOperator |
var2 |
|
BiFunction |
var2 |
|
DoubleBinaryOperator |
var2 |
|
IntBinaryOperator |
var2 |
|
LongBinaryOperator |
var2 |
|
BiFunction |
var2 |
|
DoubleBinaryOperator |
var2 |
|
IntBinaryOperator |
var2 |
|
LongBinaryOperator |
var2 |
|
boolean |
var2 |
|
int |
var2 |
|
int |
var2 |
|
int |
var2 |
|
AtomicReference |
var2 |
|
AtomicReference |
var2 |
|
AtomicReference |
var2 |
|
AtomicReference |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap.TableStack |
var2 |
|
int |
var2 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var2 |
|
Object |
var2 |
|
int |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
Double2ObjectConcurrentHashMap.Node |
var2 |
|
Iterator |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap |
var2 |
|
Double2ObjectConcurrentHashMap.Node[] |
var2 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Double2ObjectConcurrentHashMap.Node |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
int |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
int |
var20 |
|
double |
var20 |
|
double |
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Double2ObjectConcurrentHashMap.Node |
var20 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var20 |
|
Double2ObjectConcurrentHashMap.Node |
var20 |
|
|
var20 |
|
|
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Double2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Double2ObjectConcurrentHashMap.TreeBin |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TreeBin |
var21 |
|
int |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Object |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Object |
var21 |
|
Object |
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Object |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var22 |
|
Double2ObjectConcurrentHashMap.TreeBin |
var22 |
|
Object |
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
|
var22 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var23 |
|
Double2ObjectConcurrentHashMap.TableStack |
var23 |
|
|
var23 |
|
Double2ObjectConcurrentHashMap.TableStack |
var23 |
|
|
var23 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var23 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var23 |
|
int |
var23 |
|
|
var23 |
|
|
var23 |
|
|
var23 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var24 |
|
int |
var24 |
|
Double2ObjectConcurrentHashMap.Node[] |
var24 |
|
int |
var24 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var25 |
|
Double2ObjectConcurrentHashMap.Node[] |
var25 |
|
|
var25 |
|
|
var25 |
|
int |
var25 |
|
Double2ObjectConcurrentHashMap.Node |
var26 |
|
Double2ObjectConcurrentHashMap.TreeBin |
var26 |
|
Double2ObjectConcurrentHashMap.Node |
var26 |
|
|
var26 |
|
|
var26 |
|
int |
var26 |
|
Double2ObjectConcurrentHashMap.TreeBin |
var27 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var27 |
|
Double2ObjectConcurrentHashMap.TableStack |
var27 |
|
|
var27 |
|
|
var27 |
|
Double2ObjectConcurrentHashMap.Node |
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
Double2ObjectConcurrentHashMap.Node |
var28 |
|
|
var28 |
|
Double2ObjectConcurrentHashMap.Node |
var28 |
|
|
var28 |
|
Double2ObjectConcurrentHashMap.TableStack |
var28 |
|
|
var28 |
|
|
var28 |
|
Double2ObjectConcurrentHashMap.Node[] |
var28 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var29 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var29 |
|
|
var29 |
|
|
var29 |
|
int |
var29 |
|
int |
var29 |
|
|
var29 |
|
|
var29 |
|
|
var29 |
|
int |
var29 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry |
var3 |
|
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry |
var3 |
|
int |
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.Traverser |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
int |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var3 |
|
|
var3 |
|
int |
var3 |
|
long |
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.Node |
var3 |
|
Double2ObjectConcurrentHashMap.Node |
var3 |
|
|
var3 |
|
long |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node |
var3 |
|
|
var3 |
|
|
var3 |
|
Class |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
|
var3 |
|
Object |
var3 |
|
Iterator |
var3 |
|
Iterator |
var3 |
|
int |
var3 |
|
Double2ObjectConcurrentHashMap.Traverser |
var3 |
|
long |
var3 |
|
Double2ObjectConcurrentHashMap.Traverser |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Object |
var3 |
|
Object |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
double |
var3 |
|
int |
var3 |
|
DoubleIterator |
var3 |
|
DoubleIterator |
var3 |
|
DoubleIterator |
var3 |
|
DoubleIterator |
var3 |
|
int |
var3 |
|
long |
var3 |
|
int |
var3 |
|
int |
var3 |
|
double |
var3 |
|
|
var3 |
|
int |
var3 |
|
|
var3 |
|
long |
var3 |
|
|
var3 |
|
int |
var3 |
|
double |
var3 |
|
|
var3 |
|
int |
var3 |
|
|
var3 |
|
long |
var3 |
|
|
var3 |
|
int |
var3 |
|
double |
var3 |
|
|
var3 |
|
int |
var3 |
|
|
var3 |
|
long |
var3 |
|
|
var3 |
|
int |
var3 |
|
double |
var3 |
|
|
var3 |
|
int |
var3 |
|
|
var3 |
|
long |
var3 |
|
|
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
|
var3 |
|
|
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var3 |
|
int |
var3 |
|
int |
var3 |
|
long |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
Double2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var30 |
|
int |
var30 |
|
int |
var30 |
|
|
var30 |
|
Double2ObjectConcurrentHashMap.Node |
var31 |
|
long |
var31 |
|
int |
var31 |
|
Double2ObjectConcurrentHashMap.TableStack |
var31 |
|
int |
var32 |
|
Double2ObjectConcurrentHashMap.CounterCell |
var32 |
|
int |
var32 |
|
int |
var32 |
|
Double2ObjectConcurrentHashMap.Node |
var33 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var33 |
|
Double2ObjectConcurrentHashMap.Node |
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
Double2ObjectConcurrentHashMap.TableStack |
var33 |
|
boolean |
var34 |
|
|
var34 |
|
Double2ObjectConcurrentHashMap.Node[] |
var34 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var35 |
|
|
var35 |
|
int |
var35 |
|
Double2ObjectConcurrentHashMap.TableStack |
var35 |
|
|
var35 |
|
int |
var36 |
|
|
var36 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var37 |
|
|
var37 |
|
Double2ObjectConcurrentHashMap.TableStack |
var37 |
|
int |
var38 |
|
int |
var38 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var39 |
|
|
var39 |
|
Double2ObjectConcurrentHashMap.TableStack |
var39 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
StringBuilder |
var4 |
|
int |
var4 |
|
Object |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
|
var4 |
|
int |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
Object[] |
var4 |
|
|
var4 |
|
int |
var4 |
|
Object |
var4 |
|
Object |
var4 |
|
Object |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
DoubleIterator |
var4 |
|
double |
var4 |
|
double |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TableStack |
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Double2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Double2ObjectConcurrentHashMap.Node[] |
var4 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var40 |
|
|
var40 |
|
int |
var41 |
|
Double2ObjectConcurrentHashMap.TableStack |
var41 |
|
|
var41 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
Double2ObjectConcurrentHashMap.Traverser |
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Object |
var5 |
|
|
var5 |
|
|
var5 |
|
Object |
var5 |
|
|
var5 |
|
|
var5 |
|
Object |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
long |
var5 |
|
int |
var5 |
|
int |
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
boolean |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
Object[] |
var5 |
|
|
var5 |
|
Object |
var5 |
|
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
double |
var5 |
|
double |
var5 |
|
double |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
double |
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
|
var5 |
|
int |
var5 |
|
Class |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
Double2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Double2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
long |
var6 |
|
int |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
double |
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
Object |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node[] |
var6 |
|
Double2ObjectConcurrentHashMap.ForwardingNode |
var6 |
|
Double2ObjectConcurrentHashMap.CounterCell[] |
var6 |
|
long |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
ObjectIterator |
var6 |
|
int |
var6 |
|
|
var6 |
|
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
int |
var6 |
|
Double2ObjectConcurrentHashMap.Entry |
var6 |
|
double |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var6 |
|
double |
var6 |
|
boolean |
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var6 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var6 |
|
int |
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Double2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Object |
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
long |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.Node[] |
var7 |
|
boolean |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.CounterCell |
var7 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
int |
var7 |
|
Double2ObjectConcurrentHashMap.Entry |
var7 |
|
Object |
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
Double2ObjectConcurrentHashMap.Node |
var7 |
|
double |
var7 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var7 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var7 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var7 |
|
int |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Double2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var8 |
|
double |
var8 |
|
int |
var8 |
|
Double2ObjectConcurrentHashMap.Node |
var8 |
|
int |
var8 |
|
|
var8 |
|
int |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.Node |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.Node |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
Double2ObjectConcurrentHashMap.Node |
var8 |
|
Double2ObjectConcurrentHashMap.Node[] |
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.Node[] |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
boolean |
var8 |
|
|
var8 |
|
int |
var8 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var8 |
|
|
var8 |
|
int |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
ObjectIterator |
var8 |
|
double |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Double2ObjectConcurrentHashMap.Entry |
var8 |
|
|
var8 |
|
double |
var8 |
|
Object |
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var8 |
|
double |
var8 |
|
int |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Double2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
int |
var9 |
|
Double2ObjectConcurrentHashMap.Node |
var9 |
|
Double2ObjectConcurrentHashMap.Node |
var9 |
|
Double2ObjectConcurrentHashMap.Node[] |
var9 |
|
|
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.CounterCell |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
long |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
int |
var9 |
|
Object |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask |
var9 |
|
Double2ObjectConcurrentHashMap.Node |
var9 |
|
Double2ObjectConcurrentHashMap.Node |
var9 |
|
int |
var9 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var9 |
|
|
var9 |
|
int |
var9 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var9 |
|
|
var9 |
|
Double2ObjectConcurrentHashMap.TreeNode |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
public volatile Thread |
waiter |
Методы (1464)
| Модификаторы | Возврат | Сигнатура |
|---|---|---|
|
public |
BaseIteratorpublic BaseIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) |
|
protected |
BulkTaskprotected BulkTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
CollectionViewpublic CollectionView(Double2ObjectConcurrentHashMap<K> var1) |
|
public |
CounterCellpublic CounterCell(long var1) |
|
public |
DoubleReturningBulkTaskpublic DoubleReturningBulkTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
DoubleReturningBulkTask2public DoubleReturningBulkTask2(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
EntryIteratorpublic EntryIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) |
|
public |
EntrySetViewpublic EntrySetView(Double2ObjectConcurrentHashMap<V> var1) |
|
public |
EntrySpliteratorpublic EntrySpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5, Double2ObjectConcurrentHashMap<V> var7) |
abstract |
throw new |
Errorthrow new Error("data type scale not a power of two") |
abstract |
throw new |
Errorthrow new Error(var5) |
abstract |
throw new |
Errorthrow new Error(var2) |
|
public |
ForEachEntryTaskpublic ForEachEntryTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super Double2ObjectConcurrentHashMap.Entry<V>> var6) |
|
public |
ForEachKeyTaskpublic ForEachKeyTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5, DoubleConsumer var6) |
|
public |
ForEachMappingTaskpublic ForEachMappingTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var6) |
|
public |
ForEachTransformedEntryTaskpublic ForEachTransformedEntryTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedKeyTaskpublic ForEachTransformedKeyTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedMappingTaskpublic ForEachTransformedMappingTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedValueTaskpublic ForEachTransformedValueTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachValueTaskpublic ForEachValueTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super V> var6) |
|
public |
ForwardingNodepublic ForwardingNode(double var1, Double2ObjectConcurrentHashMap.Node<V>[] var3) |
abstract |
throw new |
IllegalArgumentExceptionthrow new IllegalArgumentException() |
abstract |
throw new |
IllegalArgumentExceptionthrow new IllegalArgumentException("Key is EMPTY: " + this.EMPTY) |
abstract |
throw new |
IllegalStateExceptionthrow new IllegalStateException() |
|
public |
IntReturningBulkTaskpublic IntReturningBulkTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
KeyIteratorpublic KeyIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) |
|
public |
KeySetViewpublic KeySetView(Double2ObjectConcurrentHashMap<V> var1, V var2) |
|
public |
KeySpliteratorpublic KeySpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) |
|
public |
LongReturningBulkTaskpublic LongReturningBulkTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
MapEntrypublic MapEntry(boolean var1, double var2, V var4, Double2ObjectConcurrentHashMap<V> var5) |
|
public |
MapReduceEntriesTaskpublic MapReduceEntriesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> var6,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceEntriesToDoubleTaskpublic MapReduceEntriesToDoubleTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceEntriesToIntTaskpublic MapReduceEntriesToIntTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> var6,
ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceEntriesToLongTaskpublic MapReduceEntriesToLongTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> var6,
ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceKeysTaskpublic MapReduceKeysTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> var6,
Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceKeysToDoubleTaskpublic MapReduceKeysToDoubleTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToDoubleFunction var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceKeysToIntTaskpublic MapReduceKeysToIntTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToIntFunction var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceKeysToLongTaskpublic MapReduceKeysToLongTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToLongFunction var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceMappingsTaskpublic MapReduceMappingsTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> var6,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceMappingsToDoubleTaskpublic MapReduceMappingsToDoubleTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceMappingsToIntTaskpublic MapReduceMappingsToIntTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> var6,
Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction<? super V> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceMappingsToLongTaskpublic MapReduceMappingsToLongTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> var6,
Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction<? super V> var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceValuesTaskpublic MapReduceValuesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> var6,
Function<? super V, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceValuesToDoubleTaskpublic MapReduceValuesToDoubleTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceValuesToIntTaskpublic MapReduceValuesToIntTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> var6,
ToIntFunction<? super V> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceValuesToLongTaskpublic MapReduceValuesToLongTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> var6,
ToLongFunction<? super V> var7,
long var8,
LongBinaryOperator var10) |
abstract |
throw new |
NoSuchElementExceptionthrow new NoSuchElementException() |
|
public |
Nodepublic Node(double var1, int var3, double var4, V var6, Double2ObjectConcurrentHashMap.Node<V> var7) |
abstract |
throw new |
NullPointerExceptionthrow new NullPointerException() |
abstract |
throw new |
OutOfMemoryErrorthrow new OutOfMemoryError("Required array size too large") |
|
public |
ReduceEntriesTaskpublic ReduceEntriesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> var6,
BiFunction<Double2ObjectConcurrentHashMap.Entry<V>, Double2ObjectConcurrentHashMap.Entry<V>, ? extends Double2ObjectConcurrentHashMap.Entry<V>> var7) |
|
public |
ReduceKeysTaskpublic ReduceKeysTask(double var1,
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var3,
int var4,
int var5,
int var6,
Double2ObjectConcurrentHashMap.Node<V>[] var7,
Double2ObjectConcurrentHashMap.ReduceKeysTask<V> var8,
Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator var9) |
|
public |
ReduceValuesTaskpublic ReduceValuesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.ReduceValuesTask<V> var6,
BiFunction<? super V, ? super V, ? extends V> var7) |
|
public |
ReservationNodepublic ReservationNode(double var1) |
|
public |
SearchEntriesTaskpublic SearchEntriesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchKeysTaskpublic SearchKeysTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchMappingsTaskpublic SearchMappingsTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchValuesTaskpublic SearchValuesTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
Segmentpublic Segment(float var1) |
|
public |
TableStackpublic TableStack() |
|
public |
Traverserpublic Traverser(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4) |
|
public |
TreeBinpublic TreeBin(double var1, Double2ObjectConcurrentHashMap.TreeNode<V> var3) |
|
public |
TreeNodepublic TreeNode(double var1, int var3, double var4, V var6, Double2ObjectConcurrentHashMap.Node<V> var7, Double2ObjectConcurrentHashMap.TreeNode<V> var8) |
abstract |
throw new |
UnsupportedOperationExceptionthrow new UnsupportedOperationException() |
|
public |
ValueIteratorpublic ValueIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) |
|
public |
ValueSpliteratorpublic ValueSpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) |
|
public |
ValuesViewpublic ValuesView(Double2ObjectConcurrentHashMap<V> var1) |
abstract |
void |
acceptvoid accept(double var1, V var3, byte var4, X var5) |
abstract |
void |
acceptvoid accept(double var1, V var3, X var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, double var4, X var6) |
abstract |
void |
acceptvoid accept(double var1, V var3, float var4, X var5) |
abstract |
void |
acceptvoid accept(double var1, V var3, int var4, X var5) |
abstract |
void |
acceptvoid accept(double var1, V var3, long var4, X var6) |
abstract |
void |
acceptvoid accept(double var1, V var3, short var4, X var5) |
abstract |
void |
acceptvoid accept(double var1, V var3, byte var4) |
abstract |
void |
acceptvoid accept(double var1, V var3) |
abstract |
void |
acceptvoid accept(double var1, V var3, double var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, float var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, int var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, long var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, short var4) |
abstract |
void |
acceptvoid accept(double var1, V var3, X var4, Y var5) |
|
public boolean |
addpublic boolean add(it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V> var1) |
|
public boolean |
addpublic boolean add(double var1) |
|
public final boolean |
addpublic final boolean add(V var1) |
|
public boolean |
addAllpublic boolean addAll(Collection<? extends it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) |
|
public boolean |
addAllpublic boolean addAll(DoubleCollection var1) |
|
public boolean |
addAllpublic boolean addAll(Collection<? extends Double> var1) |
|
public boolean |
addAllpublic boolean addAll(double[] var1) |
|
public final boolean |
addAllpublic final boolean addAll(Collection<? extends V> var1) |
final |
void |
addCountvoid addCount(long var1, int var3) |
|
protected final Double2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Double2ObjectConcurrentHashMap.Node<V> advance() |
|
protected final Double2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Double2ObjectConcurrentHashMap.Node<V> advance() |
|
protected final Double2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Double2ObjectConcurrentHashMap.Node<V> advance() |
abstract |
J |
applyJ apply(double var1, V var3, X var4) |
abstract |
R |
applyR apply(double var1) |
abstract |
J |
applyJ apply(double var1, V var3, byte var4) |
abstract |
J |
applyJ apply(double var1, V var3, double var4) |
abstract |
J |
applyJ apply(double var1, V var3, float var4) |
abstract |
J |
applyJ apply(double var1, V var3) |
abstract |
J |
applyJ apply(double var1, V var3, int var4) |
abstract |
J |
applyJ apply(double var1, V var3, long var4) |
abstract |
J |
applyJ apply(double var1, V var3, short var4) |
abstract |
double |
applyAsDoubledouble applyAsDouble(double var1) |
abstract |
double |
applyAsDoubledouble applyAsDouble(double var1, V var3) |
abstract |
double |
applyAsDoubledouble applyAsDouble(T var1) |
abstract |
int |
applyAsIntint applyAsInt(double var1) |
abstract |
int |
applyAsIntint applyAsInt(double var1, V var3) |
abstract |
long |
applyAsLonglong applyAsLong(double var1) |
abstract |
long |
applyAsLonglong applyAsLong(double var1, V var3) |
|
protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> |
balanceDeletionprotected <V> Double2ObjectConcurrentHashMap.TreeNode<V> balanceDeletion(Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2) |
|
protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> |
balanceInsertionprotected <V> Double2ObjectConcurrentHashMap.TreeNode<V> balanceInsertion(Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2) |
final |
int |
batchForint batchFor(long var1) |
protected |
Double2ObjectConcurrentHashMap.EntrySetView<V> |
buildEntrySetViewDouble2ObjectConcurrentHashMap.EntrySetView<V> buildEntrySetView() |
protected |
Double2ObjectConcurrentHashMap.KeySetView<V> |
buildKeySetViewDouble2ObjectConcurrentHashMap.KeySetView<V> buildKeySetView() |
protected |
Double2ObjectConcurrentHashMap.ValuesView<V> |
buildValuesViewDouble2ObjectConcurrentHashMap.ValuesView<V> buildValuesView() |
final |
<V> boolean |
casTabAt<V> boolean casTabAt(Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Double2ObjectConcurrentHashMap.Node<V> var2, Double2ObjectConcurrentHashMap.Node<V> var3) |
|
public int |
characteristicspublic int characteristics() |
|
public int |
characteristicspublic int characteristics() |
|
public int |
characteristicspublic int characteristics() |
|
protected <V> boolean |
checkInvariantsprotected <V> boolean checkInvariants(Double2ObjectConcurrentHashMap.TreeNode<V> var1) |
public |
void |
clearvoid clear() |
|
public final void |
clearpublic final void clear() |
|
public void |
clearpublic void clear() |
public |
V |
computeV compute(double var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends V> var3) |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
|
public final void |
computepublic final void compute() |
public |
V |
computeIfAbsentV computeIfAbsent(double var1, Double2ObjectConcurrentHashMap.DoubleFunction<? extends V> var3) |
public |
V |
computeIfPresentV computeIfPresent(double var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends V> var3) |
|
public boolean |
containspublic boolean contains(Object var1) |
|
public boolean |
containspublic boolean contains(double var1) |
|
public final boolean |
containspublic final boolean contains(Object var1) |
abstract |
public abstract boolean |
containspublic abstract boolean contains(Object var1) |
|
public final boolean |
containsAllpublic final boolean containsAll(Collection<?> var1) |
|
public boolean |
containsAllpublic boolean containsAll(Collection<?> var1) |
|
public boolean |
containsAllpublic boolean containsAll(DoubleCollection var1) |
|
public boolean |
containsAllpublic boolean containsAll(double[] var1) |
public |
boolean |
containsKeyboolean containsKey(double var1) |
public |
boolean |
containsValueboolean containsValue(Object var1) |
|
protected final void |
contendedLockprotected final void contendedLock() |
public |
ObjectSet<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> |
double2ObjectEntrySetObjectSet<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> double2ObjectEntrySet() |
|
public final boolean |
equalspublic final boolean equals(Object var1) |
|
public boolean |
equalspublic boolean equals(Object var1) |
|
public boolean |
equalspublic boolean equals(Object var1) |
|
public final boolean |
equalspublic final boolean equals(Object var1) |
abstract |
boolean |
equalsboolean equals(Object var1) |
|
public long |
estimateSizepublic long estimateSize() |
|
public long |
estimateSizepublic long estimateSize() |
|
public long |
estimateSizepublic long estimateSize() |
|
protected Double2ObjectConcurrentHashMap.Node<V> |
findprotected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) |
|
protected Double2ObjectConcurrentHashMap.Node<V> |
findprotected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) |
|
protected Double2ObjectConcurrentHashMap.Node<V> |
findprotected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) |
|
protected final Double2ObjectConcurrentHashMap.Node<V> |
findprotected final Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) |
|
protected Double2ObjectConcurrentHashMap.Node<V> |
findprotected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) |
|
protected final Double2ObjectConcurrentHashMap.TreeNode<V> |
findTreeNodeprotected final Double2ObjectConcurrentHashMap.TreeNode<V> findTreeNode(int var1, double var2, Class<?> var4) |
|
|
for for(Double2ObjectConcurrentHashMap.Node var18 = var11.next; var18 != null; var18 = var18.next) |
|
|
for for(Double2ObjectConcurrentHashMap.Node var36 = var11; var36 != var17; var36 = var36.next) |
|
|
for for(Double2ObjectConcurrentHashMap.Node var23 = var34.first; var23 != null; var23 = var23.next) |
|
|
for for(int var5 = 0; var5 < var1.length; var5++) |
|
|
for for(int var35 = 0; var35 < var8; var35++) |
|
|
for for(Double2ObjectConcurrentHashMap.Node var9 = var3; var9 != null; var9 = var9.next) |
|
|
for for(Double2ObjectConcurrentHashMap.Node var4 = var1; var4 != null; var4 = var4.next) |
|
|
for for(Object var3 : var1) |
|
|
for for(it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var4 : var1) |
|
|
for for(Object var3 : var1) |
|
|
for for(Double var4 : var1) |
|
|
for for(Object var4 : var1) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceEntriesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceKeysTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceMappingsTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceValuesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.ReduceEntriesTask var5 = var11.rights; var5 != null; var5 = var11.rights = var5.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.ReduceKeysTask var7 = var15.rights; var7 != null; var7 = var15.rights = var7.nextRight) |
|
|
for for(Double2ObjectConcurrentHashMap.ReduceValuesTask var5 = var12.rights; var5 != null; var5 = var12.rights = var5.nextRight) |
abstract |
|
for for(var3 = 0; var3 < var1.length && var2.hasNext() |
abstract |
|
for for(CountedCompleter var11 = this.firstComplete() |
abstract |
|
for for(CountedCompleter var9 = this.firstComplete() |
abstract |
|
for for(CountedCompleter var8 = this.firstComplete() |
abstract |
|
for for(CountedCompleter var10 = this.firstComplete() |
abstract |
|
for for(CountedCompleter var14 = this.firstComplete() |
public |
int |
forEachint forEach(Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var1) |
public |
<X> int |
forEach<X> int forEach(Double2ObjectConcurrentHashMap.DoubleBiObjConsumer<? super V, X> var1, X var2) |
public |
<X, Y> int |
forEach<X, Y> int forEach(Double2ObjectConcurrentHashMap.DoubleTriObjConsumer<? super V, X, Y> var1, X var2, Y var3) |
public |
void |
forEachvoid forEach(long var1, Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var3) |
public |
<U> void |
forEach<U> void forEach(long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var3, Consumer<? super U> var4) |
|
public void |
forEachpublic void forEach(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) |
|
public void |
forEachpublic void forEach(Consumer<? super V> var1) |
|
public <A, B, C, D> void |
forEachpublic <A, B, C, D> void forEach(FastCollection.FastConsumerD9<? super V, A, B, C, D> var1,
A var2,
double var3,
double var5,
double var7,
double var9,
double var11,
double var13,
double var15,
double var17,
double var19,
B var21,
C var22,
D var23) |
|
public <A, B, C, D> void |
forEachpublic <A, B, C, D> void forEach(FastCollection.FastConsumerD6<? super V, A, B, C, D> var1,
A var2,
double var3,
double var5,
double var7,
double var9,
double var11,
double var13,
B var15,
C var16,
D var17) |
public |
void |
forEachEntryvoid forEachEntry(long var1, Consumer<? super Double2ObjectConcurrentHashMap.Entry<V>> var3) |
public |
<U> void |
forEachEntry<U> void forEachEntry(long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3, Consumer<? super U> var4) |
public |
void |
forEachKeyvoid forEachKey(long var1, DoubleConsumer var3) |
public |
<U> void |
forEachKey<U> void forEachKey(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var3, Consumer<? super U> var4) |
|
public void |
forEachRemainingpublic void forEachRemaining(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) |
|
public void |
forEachRemainingpublic void forEachRemaining(DoubleConsumer var1) |
|
public void |
forEachRemainingpublic void forEachRemaining(Consumer<? super V> var1) |
public |
void |
forEachValuevoid forEachValue(long var1, Consumer<? super V> var3) |
public |
<U> void |
forEachValue<U> void forEachValue(long var1, Function<? super V, ? extends U> var3, Consumer<? super U> var4) |
public |
int |
forEachWithByteint forEachWithByte(Double2ObjectConcurrentHashMap.DoubleObjByteConsumer<? super V> var1, byte var2) |
public |
<X> int |
forEachWithByte<X> int forEachWithByte(Double2ObjectConcurrentHashMap.DoubleBiObjByteConsumer<? super V, X> var1, byte var2, X var3) |
public |
int |
forEachWithDoubleint forEachWithDouble(Double2ObjectConcurrentHashMap.DoubleObjDoubleConsumer<? super V> var1, double var2) |
public |
<X> int |
forEachWithDouble<X> int forEachWithDouble(Double2ObjectConcurrentHashMap.DoubleBiObjDoubleConsumer<? super V, X> var1, double var2, X var4) |
public |
int |
forEachWithFloatint forEachWithFloat(Double2ObjectConcurrentHashMap.DoubleObjFloatConsumer<? super V> var1, float var2) |
public |
<X> int |
forEachWithFloat<X> int forEachWithFloat(Double2ObjectConcurrentHashMap.DoubleBiObjFloatConsumer<? super V, X> var1, float var2, X var3) |
|
public void |
forEachWithFloatpublic void forEachWithFloat(FastCollection.FastConsumerF<? super V> var1, float var2) |
public |
int |
forEachWithIntint forEachWithInt(Double2ObjectConcurrentHashMap.DoubleObjIntConsumer<? super V> var1, int var2) |
public |
<X> int |
forEachWithInt<X> int forEachWithInt(Double2ObjectConcurrentHashMap.DoubleBiObjIntConsumer<? super V, X> var1, int var2, X var3) |
|
public void |
forEachWithIntpublic void forEachWithInt(FastCollection.FastConsumerI<? super V> var1, int var2) |
public |
int |
forEachWithLongint forEachWithLong(Double2ObjectConcurrentHashMap.DoubleObjLongConsumer<? super V> var1, long var2) |
public |
<X> int |
forEachWithLong<X> int forEachWithLong(Double2ObjectConcurrentHashMap.DoubleBiObjLongConsumer<? super V, X> var1, long var2, X var4) |
|
public void |
forEachWithLongpublic void forEachWithLong(FastCollection.FastConsumerL<? super V> var1, long var2) |
public |
int |
forEachWithShortint forEachWithShort(Double2ObjectConcurrentHashMap.DoubleObjShortConsumer<? super V> var1, short var2) |
public |
<X> int |
forEachWithShort<X> int forEachWithShort(Double2ObjectConcurrentHashMap.DoubleBiObjShortConsumer<? super V, X> var1, short var2, X var3) |
final |
void |
fullAddCountvoid fullAddCount(long var1, boolean var3) |
public |
V |
getV get(double var1) |
|
public double |
getDoubleKeypublic double getDoubleKey() |
|
public final double |
getDoubleKeypublic final double getDoubleKey() |
abstract |
double |
getDoubleKeydouble getDoubleKey() |
|
public Double |
getKeypublic Double getKey() |
|
public final Double |
getKeypublic final Double getKey() |
abstract |
Double |
getKeyDouble getKey() |
|
public Double2ObjectConcurrentHashMap<K> |
getMappublic Double2ObjectConcurrentHashMap<K> getMap() |
|
public V |
getMappedValuepublic V getMappedValue() |
|
public double |
getNoEntryValuepublic double getNoEntryValue() |
public |
V |
getOrDefaultV getOrDefault(double var1, V var3) |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final Double |
getRawResultpublic final Double getRawResult() |
|
public final Integer |
getRawResultpublic final Integer getRawResult() |
|
public final Long |
getRawResultpublic final Long getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final Double |
getRawResultpublic final Double getRawResult() |
|
public final Integer |
getRawResultpublic final Integer getRawResult() |
|
public final Long |
getRawResultpublic final Long getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final Double |
getRawResultpublic final Double getRawResult() |
|
public final Integer |
getRawResultpublic final Integer getRawResult() |
|
public final Long |
getRawResultpublic final Long getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final Double |
getRawResultpublic final Double getRawResult() |
|
public final Integer |
getRawResultpublic final Integer getRawResult() |
|
public final Long |
getRawResultpublic final Long getRawResult() |
|
public final Double2ObjectConcurrentHashMap.Entry<V> |
getRawResultpublic final Double2ObjectConcurrentHashMap.Entry<V> getRawResult() |
|
public final Double |
getRawResultpublic final Double getRawResult() |
|
public final V |
getRawResultpublic final V getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public final U |
getRawResultpublic final U getRawResult() |
|
public V |
getValuepublic V getValue() |
|
public final V |
getValuepublic final V getValue() |
abstract |
V |
getValueV getValue() |
|
public final boolean |
hasMoreElementspublic final boolean hasMoreElements() |
|
public final boolean |
hasMoreElementspublic final boolean hasMoreElements() |
|
public final boolean |
hasNextpublic final boolean hasNext() |
|
public final boolean |
hasNextpublic final boolean hasNext() |
|
public final int |
hashCodepublic final int hashCode() |
|
public int |
hashCodepublic int hashCode() |
|
public int |
hashCodepublic int hashCode() |
|
public final int |
hashCodepublic final int hashCode() |
abstract |
int |
hashCodeint hashCode() |
final |
Double2ObjectConcurrentHashMap.Node<V>[] |
helpTransferDouble2ObjectConcurrentHashMap.Node<V>[] helpTransfer(Double2ObjectConcurrentHashMap.Node<V>[] var1, Double2ObjectConcurrentHashMap.Node<V> var2) |
|
|
if if(var1 < 0) |
|
|
if if(var2 > 0.0F && var1 >= 0 && var3 > 0) |
|
|
if if(var1 < var3) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var4.hash == var10) |
|
|
if if(var4.key == var1 || var8 != this.EMPTY && var1 == var8) |
|
|
if if(var4.hash == var10) |
|
|
if if(var4.key == var1 || var11 != this.EMPTY && var1 == var11) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var4 != null) |
|
|
if if(var11 != null) |
|
|
if if(var8 < var9) |
|
|
if if(var3 != null) |
|
|
if if(var10000 > var7 && var13 >= 0) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var3 == null) |
|
|
if if(var8.hash == -1) |
|
|
if if(var11 < 0) |
|
|
if if(var8 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(!var4) |
|
|
if if(var14.hash == var5) |
|
|
if if(var14.key == var1 || var15 != this.EMPTY && var1 == var15) |
|
|
if if(!var4) |
|
|
if if(var6 != 0) |
|
|
if if(var6 >= 8) |
|
|
if if(var12 != null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var7.hash == -1) |
|
|
if if(var10 < 0) |
|
|
if if(var7 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var3 != null) |
|
|
if if(var14.hash == var5) |
|
|
if if(var14.key == var1 || var16 != this.EMPTY && var1 == var16) |
|
|
if if(var3 != null) |
|
|
if if(var12) |
|
|
if if(var11 != null) |
|
|
if if(var3 == null) |
|
|
if if(var6 == null) |
|
|
if if(var6.hash == -1) |
|
|
if if(var1 != 0L) |
|
|
if if(this.table != null) |
|
|
if if(var4 != null) |
|
|
if if(var11 != null) |
|
|
if if(var8 >= var9) |
|
|
if if(var3 == null) |
|
|
if if(var10000 <= var7 || var13 < 0) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var1 != this) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var8 != null) |
|
|
if if(var15 != null) |
|
|
if if(var12 >= var13) |
|
|
if if(var7 == null) |
|
|
if if(var10000 <= var11 || var17 < 0) |
|
|
if if(var15 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var23 != null) |
|
|
if if(var15 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var9 == null) |
|
|
if if(var9 != null) |
|
|
if if(var15 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var7 != null) |
|
|
if if(var14 != null) |
|
|
if if(var11 >= var12) |
|
|
if if(var6 == null) |
|
|
if if(var10000 <= var10 || var16 < 0) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var8 == null) |
|
|
if if(var8 != null) |
|
|
if if(var14 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var8 != null) |
|
|
if if(var15 != null) |
|
|
if if(var12 >= var13) |
|
|
if if(var7 == null) |
|
|
if if(var10000 <= var11 || var17 < 0) |
|
|
if if(var15 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var23 != null) |
|
|
if if(var15 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var9 == null) |
|
|
if if(var9 != null) |
|
|
if if(var15 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var4 != null) |
|
|
if if(var11 != null) |
|
|
if if(var8 >= var9) |
|
|
if if(var3 == null) |
|
|
if if(var10000 <= var7 || var13 < 0) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var22 == null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var3 == null) |
|
|
if if(var6 != 0) |
|
|
if if(var8.hash == -1) |
|
|
if if(var11 < 0) |
|
|
if if(var8 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var14.hash == var4) |
|
|
if if(var14.key == var1 || var15 != this.EMPTY && var1 == var15) |
|
|
if if(var6 != 0) |
|
|
if if(var6 >= 8) |
|
|
if if(!var12) |
|
|
if if(var5 != null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var3 == null) |
|
|
if if(var9.hash == -1) |
|
|
if if(var12 < 0) |
|
|
if if(var9 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 != null) |
|
|
if if(var14.hash == var4) |
|
|
if if(var14.key == var1 || var16 != this.EMPTY && var1 == var16) |
|
|
if if(var5 != null) |
|
|
if if(var15 != null) |
|
|
if if(var7 != 0) |
|
|
if if(var6 != 0) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var3 == null) |
|
|
if if(var7 != 0) |
|
|
if if(var9.hash == -1) |
|
|
if if(var12 < 0) |
|
|
if if(var9 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var26.root != null) |
|
|
if if(var5 != null) |
|
|
if if(var29 != null) |
|
|
if if(var14.hash == var4) |
|
|
if if(var14.key == var1 || var16 != this.EMPTY && var1 == var16) |
|
|
if if(var5 != null) |
|
|
if if(var15 != null) |
|
|
if if(var5 != null) |
|
|
if if(var7 != 0) |
|
|
if if(var7 >= 8) |
|
|
if if(var6 != 0) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var10.hash == -1) |
|
|
if if(var13 < 0) |
|
|
if if(var10 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 != null) |
|
|
if if(var24 != null) |
|
|
if if(var15.hash == var5) |
|
|
if if(var15.key == var1 || var17 != this.EMPTY && var1 == var17) |
|
|
if if(var6 != null) |
|
|
if if(var16 != null) |
|
|
if if(var8 != 0) |
|
|
if if(var8 >= 8) |
|
|
if if(var7 != 0) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null && var1.length != 0) |
|
|
if if(this.sizeCtl < 0) |
|
|
if if(this.table == null || var1.length == 0) |
|
|
if if(this.counterCells == null) |
|
|
if if(var3 <= 1) |
|
|
if if(var3 >= 0) |
|
|
if if(var7 < this.sizeCtl) |
|
|
if if(var16 < 0) |
|
|
if if(var16 >>> RESIZE_STAMP_SHIFT != var13 || var16 == var13 + 1 || var16 == var13 + MAX_RESIZERS) |
|
|
if if(this.nextTable == null || this.transferIndex <= 0) |
|
|
if if(var1 != null && var2 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(this.sizeCtl >= 0 || var4 >>> RESIZE_STAMP_SHIFT != var5 || var4 == var5 + 1 || var4 == var5 + MAX_RESIZERS || this.transferIndex <= 0) |
|
|
if if(this.sizeCtl < 0) |
|
|
if if(var2 <= var3 || var5 >= 1073741824) |
|
|
if if(var4 == this.table) |
|
|
if if(var3 < 0) |
|
|
if if(var3 >>> RESIZE_STAMP_SHIFT != var11 || var3 == var11 + 1 || var3 == var11 + MAX_RESIZERS) |
|
|
if if(this.nextTable == null || this.transferIndex <= 0) |
|
|
if if(this.table == var4) |
|
|
if if(var2 == null) |
|
|
if if(var9 >= 0 && var9 < var3 && var9 + var3 < var29) |
|
|
if if(var11.hash == -1) |
|
|
if if(var12 >= 0) |
|
|
if if(var19 != var16) |
|
|
if if(var16 == 0) |
|
|
if if(var8) |
|
|
if if(--var9 < var10 && !var8) |
|
|
if if(this.transferIndex <= 0) |
|
|
if if(var1 != null) |
|
|
if if(this.cellsBusy == 0) |
|
|
if if(var34) |
|
|
if if(this.counterCells != var6 || var8 >= NCPU) |
|
|
if if(this.counterCells == var6) |
|
|
if if(this.counterCells == var6) |
|
|
if if(var11) |
|
|
if if(var1 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var4 != null) |
|
|
if if(var11 != null) |
|
|
if if(var8 >= var9) |
|
|
if if(var3 == null) |
|
|
if if(var10000 <= var7 || var13 < 0) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var19 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var20 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var20 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var20 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var20 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var21 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var20 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
|
|
if if(var21 != null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var1 != null && var2 != null) |
|
|
if if(this.table == null) |
|
|
if if(var5 != null) |
|
|
if if(var13 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var13 == null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var5 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var5 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var5 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 == null) |
|
|
if if(var3 == null) |
|
|
if if(var3 != null && var4 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var6 != null) |
|
|
if if(var3 != null && var5 != null) |
|
|
if if(var3 != null) |
|
|
if if(var7 < var9) |
|
|
if if(var2 != null) |
|
|
if if(var10000 > var6 && var14 >= 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var4 == null) |
|
|
if if(var4 != null) |
|
|
if if(this.lastReturned == null) |
|
|
if if(this.next != null) |
|
|
if if(var1 != null) |
|
|
if if(this.baseIndex >= this.baseLimit) |
|
|
if if(this.tab == null) |
|
|
if if(var10000 <= this.index || var3 < 0) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(this.stack != null) |
|
|
if if(var4 != null) |
|
|
if if(this.stack != null) |
|
|
if if(var1 > 2147483639L) |
|
|
if if(var5 == var3) |
|
|
if if(var3 >= 2147483639) |
|
|
if if(var3 >= 1073741819) |
|
|
if if(var2 > 2147483639L) |
|
|
if if(var7 == var6) |
|
|
if if(var6 >= 2147483639) |
|
|
if if(var6 >= 1073741819) |
|
|
if if(var1 == var5 && var7 < var6) |
|
|
if if(var1 != this) |
|
|
if if(var1 == null) |
|
|
if if(var1 == null) |
|
|
if if(var2 != null) |
|
|
if if(var2 != null) |
|
|
if if(this.next == null) |
|
|
if if(var1 instanceof it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry) |
|
|
if if(var1 instanceof it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry) |
|
|
if if(this.map.table != null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var1 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.action != null) |
|
|
if if(this.action != null) |
|
|
if if(this.action != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.action != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.action != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.action != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.action != null) |
|
|
if if(this.action != null) |
|
|
if if(var5.hash == var1) |
|
|
if if(var5.key == var2 || var8 != this.EMPTY && var2 == var8) |
|
|
if if(var7 < 0) |
|
|
if if(var2 != null) |
|
|
if if(this.next != null) |
|
|
if if(var1 != null) |
|
|
if if(this.baseIndex >= this.baseLimit) |
|
|
if if(this.tab == null) |
|
|
if if(var10000 <= this.index || var3 < 0) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(this.stack != null) |
|
|
if if(var4 != null) |
|
|
if if(this.stack != null) |
|
|
if if(this.lastReturned == null) |
|
|
if if(this.next == null) |
|
|
if if(this.value == null) |
|
|
if if(this.value == null) |
|
|
if if(var1.length > var3 + 1) |
|
|
if if(var1.length > var3 + 1) |
|
|
if if(var1.length > var3 + 1) |
|
|
if if(var1.length > var3 + 1) |
|
|
if if(this == var1) |
|
|
if if(var4 instanceof Double) |
|
|
if if(var1 == null) |
|
|
if if(var1 == null) |
|
|
if if(var2 != null) |
|
|
if if(this == var1) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.Entry) |
|
|
if if(var1 == null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(var6.result != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(var6.result != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(var6.result != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(var6.result != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(this.transformer != null) |
|
|
if if(this.reducer != null) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.Entry) |
|
|
if if(var2 != this.EMPTY) |
|
|
if if(var4.hash == var1) |
|
|
if if(var4.key == var2 || var5 != this.EMPTY && var2 == var5) |
|
|
if if(this.reducer != null) |
|
|
if if(var5.result != null) |
|
|
if if(this.reducer != null) |
|
|
if if(!var12) |
|
|
if if(var7.result != this.EMPTY) |
|
|
if if(this.reducer != null) |
|
|
if if(var5.result != null) |
|
|
if if(this.searchFunction != null) |
|
|
if if(this.result != null) |
|
|
if if(this.searchFunction != null) |
|
|
if if(this.result != null) |
|
|
if if(this.searchFunction != null) |
|
|
if if(this.result != null) |
|
|
if if(this.searchFunction != null) |
|
|
if if(this.result != null) |
|
|
if if(this.next != null) |
|
|
if if(var1 != null) |
|
|
if if(this.baseIndex >= this.baseLimit) |
|
|
if if(this.tab == null) |
|
|
if if(var10000 <= this.index || var3 < 0) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(this.stack != null) |
|
|
if if(var4 != null) |
|
|
if if(this.stack != null) |
|
|
if if(var4 == null) |
|
|
if if(var11.hash > var9) |
|
|
if if(var12 <= 0) |
|
|
if if(var1) |
|
|
if if(var2 != this.EMPTY) |
|
|
if if(var4.hash == var1) |
|
|
if if(var4.key == var2 || var6 != this.EMPTY && var2 == var6) |
|
|
if if(this.waiter != null) |
|
|
if if(var7 == null) |
|
|
if if(var7.hash > var1) |
|
|
if if(var7.key == var2 || var10 != this.EMPTY && var2 == var10) |
|
|
if if(!var6) |
|
|
if if(var14 != null) |
|
|
if if(var8 <= 0) |
|
|
if if(!var18.red) |
|
|
if if(var3 == null) |
|
|
if if(var2 != null) |
|
|
if if(this.first == null) |
|
|
if if(this.root != null && var4.right != null) |
|
|
if if(var4.left != null && var5.left != null) |
|
|
if if(var7 != null && var8 != null) |
|
|
if if(var9.left == null) |
|
|
if if(var9 == var8) |
|
|
if if(var9 == var14.left) |
|
|
if if(var12 != null) |
|
|
if if(var6 != var1) |
|
|
if if(var18 == null) |
|
|
if if(var1 == var6) |
|
|
if if(var1.parent != null) |
|
|
if if(var1 == var19.left) |
|
|
if if(var2 != null) |
|
|
if if(var2.right != null) |
|
|
if if(var2 != null) |
|
|
if if(var2.left != null) |
|
|
if if(var2.parent == null) |
|
|
if if(!var3.red) |
|
|
if if(var3.parent == null) |
|
|
if if(var3 == var4.left) |
|
|
if if(var4.right != null && var6.red) |
|
|
if if(var2 == var3.right) |
|
|
if if(var3 != null) |
|
|
if if(var4 != null) |
|
|
if if(var2 == var3.left) |
|
|
if if(var3 != null) |
|
|
if if(var4 != null) |
|
|
if if(var2.parent == null) |
|
|
if if(var2.red) |
|
|
if if(var3.left == var2) |
|
|
if if(var3.right != null && var5.red) |
|
|
if if(var5 == null) |
|
|
if if(var10 != null && var10.red || var9 != null && var9.red) |
|
|
if if(var10 == null || !var10.red) |
|
|
if if(var9 != null) |
|
|
if if(var5 != null) |
|
|
if if(var5.right != null) |
|
|
if if(var3 != null) |
|
|
if if(var4 != null && var4.red) |
|
|
if if(var4 == null) |
|
|
if if(var6 != null && var6.red || var7 != null && var7.red) |
|
|
if if(var6 == null || !var6.red) |
|
|
if if(var7 != null) |
|
|
if if(var4 != null) |
|
|
if if(var4.left != null) |
|
|
if if(var3 != null) |
|
|
if if(var5 != null && var5.next != var1) |
|
|
if if(var6 != null && var6.prev != var1) |
|
|
if if(var2 != null && var1 != var2.left && var1 != var2.right) |
|
|
if if(var3 == null || var3.parent == var1 && var3.hash <= var1.hash) |
|
|
if if(var4 == null || var4.parent == var1 && var4.hash >= var1.hash) |
|
|
if if(var1.red && var3 != null && var3.red && var4 != null && var4.red) |
|
|
if if(var2 != this.EMPTY) |
|
|
if if(var5.hash > var1) |
|
|
if if(var5.key == var2 || var8 != this.EMPTY && var2 == var8) |
|
|
if if(var11 == null) |
|
|
if if(this.next == null) |
|
|
if if(var1 == null) |
|
|
if if(var1 == null) |
|
|
if if(var1 != null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var4 != null) |
|
|
if if(var11 != null) |
|
|
if if(var8 >= var9) |
|
|
if if(var3 == null) |
|
|
if if(var10000 <= var7 || var13 < 0) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var11 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var26 != null) |
|
|
if if(var33 != null) |
|
|
if if(var30 >= var31) |
|
|
if if(var25 == null) |
|
|
if if(var10000 <= var29 || var35 < 0) |
|
|
if if(var33 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var41 != null) |
|
|
if if(var33 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var27 == null) |
|
|
if if(var27 != null) |
|
|
if if(var33 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var20 != null) |
|
|
if if(var27 != null) |
|
|
if if(var24 >= var25) |
|
|
if if(var19 == null) |
|
|
if if(var10000 <= var23 || var29 < 0) |
|
|
if if(var27 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var35 != null) |
|
|
if if(var27 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var21 == null) |
|
|
if if(var21 != null) |
|
|
if if(var27 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var5 != null) |
|
|
if if(var12 != null) |
|
|
if if(var9 >= var10) |
|
|
if if(var4 == null) |
|
|
if if(var10000 <= var8 || var14 < 0) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var6 == null) |
|
|
if if(var6 != null) |
|
|
if if(var12 == null) |
|
|
if if(var1 == null) |
|
|
if if(this.map.table != null) |
|
|
if if(var6 != null) |
|
|
if if(var13 != null) |
|
|
if if(var10 >= var11) |
|
|
if if(var5 == null) |
|
|
if if(var10000 <= var9 || var15 < 0) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Double2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
final |
Double2ObjectConcurrentHashMap.Node<V>[] |
initTableDouble2ObjectConcurrentHashMap.Node<V>[] initTable() |
|
protected double |
invoke0protected double invoke0() |
|
protected double |
invoke0protected double invoke0() |
|
protected int |
invoke0protected int invoke0() |
|
protected long |
invoke0protected long invoke0() |
public |
boolean |
isEmptyboolean isEmpty() |
|
public final boolean |
isEmptypublic final boolean isEmpty() |
|
public boolean |
isEmptypublic boolean isEmpty() |
|
public boolean |
isEmptypublic boolean isEmpty() |
|
public final boolean |
isEmptypublic final boolean isEmpty() |
|
public ObjectIterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> |
iteratorpublic ObjectIterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> iterator() |
|
public DoubleIterator |
iteratorpublic DoubleIterator iterator() |
|
public final ObjectIterator<V> |
iteratorpublic final ObjectIterator<V> iterator() |
abstract |
public abstract ObjectIterator<E> |
iteratorpublic abstract ObjectIterator<E> iterator() |
public |
Double2ObjectConcurrentHashMap.KeySetView<V> |
keySetDouble2ObjectConcurrentHashMap.KeySetView<V> keySet() |
public |
Double2ObjectConcurrentHashMap.KeySetView<V> |
keySetDouble2ObjectConcurrentHashMap.KeySetView<V> keySet(V var1) |
|
protected final void |
lockRootprotected final void lockRoot() |
public |
long |
mappingCountlong mappingCount() |
public |
V |
mergeV merge(double var1, V var3, BiFunction<? super V, ? super V, ? extends V> var4) |
static |
DoubleSet |
newKeySetDoubleSet newKeySet() |
static |
Double2ObjectConcurrentHashMap.KeySetView<Boolean> |
newKeySetDouble2ObjectConcurrentHashMap.KeySetView<Boolean> newKeySet(int var0) |
|
public final Double2ObjectConcurrentHashMap.Entry<V> |
nextpublic final Double2ObjectConcurrentHashMap.Entry<V> next() |
|
public final V |
nextpublic final V next() |
|
public final double |
nextDoublepublic final double nextDouble() |
|
public final V |
nextElementpublic final V nextElement() |
|
protected void |
pushStateprotected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
|
protected void |
pushStateprotected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
|
protected void |
pushStateprotected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
public |
V |
putV put(double var1, V var3) |
public |
void |
putAllvoid putAll(Map<? extends Double, ? extends V> var1) |
public |
void |
putAllvoid putAll(Double2ObjectConcurrentHashMap<? extends V> var1) |
public |
void |
putAllvoid putAll(Double2ObjectMap<V> var1) |
public |
V |
putIfAbsentV putIfAbsent(double var1, V var3) |
|
protected final Double2ObjectConcurrentHashMap.TreeNode<V> |
putTreeValprotected final Double2ObjectConcurrentHashMap.TreeNode<V> putTreeVal(int var1, double var2, V var4) |
final |
V |
putValV putVal(double var1, V var3, boolean var4) |
|
protected void |
recoverStateprotected void recoverState(int var1) |
|
protected void |
recoverStateprotected void recoverState(int var1) |
|
protected void |
recoverStateprotected void recoverState(int var1) |
public |
<U> U |
reduce<U> U reduce(long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
<U> U |
reduce<U> U reduce(Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var1, BiFunction<? super U, ? super U, ? extends U> var2) |
abstract |
double |
reducedouble reduce(double var1, double var3, double var5) |
public |
Double2ObjectConcurrentHashMap.Entry<V> |
reduceEntriesDouble2ObjectConcurrentHashMap.Entry<V> reduceEntries(long var1,
BiFunction<Double2ObjectConcurrentHashMap.Entry<V>, Double2ObjectConcurrentHashMap.Entry<V>, ? extends Double2ObjectConcurrentHashMap.Entry<V>> var3) |
public |
<U> U |
reduceEntries<U> U reduceEntries(long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
double |
reduceEntriesToDoubledouble reduceEntriesToDouble(long var1, Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceEntriesToIntint reduceEntriesToInt(long var1, ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceEntriesToLonglong reduceEntriesToLong(long var1, ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, long var4, LongBinaryOperator var6) |
public |
double |
reduceKeysdouble reduceKeys(long var1, Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator var3) |
public |
<U> U |
reduceKeys<U> U reduceKeys(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
double |
reduceKeysToDoubledouble reduceKeysToDouble(long var1, Double2ObjectConcurrentHashMap.DoubleToDoubleFunction var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceKeysToIntint reduceKeysToInt(long var1, Double2ObjectConcurrentHashMap.DoubleToIntFunction var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceKeysToLonglong reduceKeysToLong(long var1, Double2ObjectConcurrentHashMap.DoubleToLongFunction var3, long var4, LongBinaryOperator var6) |
public |
double |
reduceToDoubledouble reduceToDouble(long var1, Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction<? super V> var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceToIntint reduceToInt(long var1, Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction<? super V> var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceToLonglong reduceToLong(long var1, Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction<? super V> var3, long var4, LongBinaryOperator var6) |
public |
V |
reduceValuesV reduceValues(long var1, BiFunction<? super V, ? super V, ? extends V> var3) |
public |
<U> U |
reduceValues<U> U reduceValues(long var1, Function<? super V, ? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
double |
reduceValuesToDoubledouble reduceValuesToDouble(long var1, Double2ObjectConcurrentHashMap.ToDoubleFunction<? super V> var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceValuesToIntint reduceValuesToInt(long var1, ToIntFunction<? super V> var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceValuesToLonglong reduceValuesToLong(long var1, ToLongFunction<? super V> var3, long var4, LongBinaryOperator var6) |
public |
V |
removeV remove(double var1) |
public |
boolean |
removeboolean remove(double var1, Object var3) |
|
public final void |
removepublic final void remove() |
|
public boolean |
removepublic boolean remove(Object var1) |
|
public final void |
removepublic final void remove() |
|
public boolean |
removepublic boolean remove(double var1) |
|
public final boolean |
removepublic final boolean remove(Object var1) |
abstract |
public abstract boolean |
removepublic abstract boolean remove(Object var1) |
|
public final boolean |
removeAllpublic final boolean removeAll(Collection<?> var1) |
|
public boolean |
removeAllpublic boolean removeAll(Collection<?> var1) |
|
public boolean |
removeAllpublic boolean removeAll(DoubleCollection var1) |
|
public boolean |
removeAllpublic boolean removeAll(double[] var1) |
|
protected final boolean |
removeTreeNodeprotected final boolean removeTreeNode(Double2ObjectConcurrentHashMap.TreeNode<V> var1) |
public |
boolean |
replaceboolean replace(double var1, V var3, V var4) |
public |
V |
replaceV replace(double var1, V var3) |
public |
void |
replaceAllvoid replaceAll(Double2ObjectOperator<V> var1) |
final |
V |
replaceNodeV replaceNode(double var1, V var3, Object var4) |
final |
int |
resizeStampint resizeStamp(int var0) |
|
public final boolean |
retainAllpublic final boolean retainAll(Collection<?> var1) |
|
public boolean |
retainAllpublic boolean retainAll(Collection<?> var1) |
|
public boolean |
retainAllpublic boolean retainAll(DoubleCollection var1) |
|
public boolean |
retainAllpublic boolean retainAll(double[] var1) |
|
protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> |
rotateLeftprotected <V> Double2ObjectConcurrentHashMap.TreeNode<V> rotateLeft(Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2) |
|
protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> |
rotateRightprotected <V> Double2ObjectConcurrentHashMap.TreeNode<V> rotateRight(Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2) |
public |
<U> U |
search<U> U search(long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var3) |
public |
<U> U |
search<U> U search(Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? extends U> var1) |
public |
<U, X> U |
search<U, X> U search(Double2ObjectConcurrentHashMap.DoubleBiObjFunction<? super V, X, ? extends U> var1, X var2) |
public |
<U> U |
searchEntries<U> U searchEntries(long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3) |
public |
<U> U |
searchKeys<U> U searchKeys(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? extends U> var3) |
public |
<U> U |
searchValues<U> U searchValues(long var1, Function<? super V, ? extends U> var3) |
public |
<U> U |
searchWithByte<U> U searchWithByte(Double2ObjectConcurrentHashMap.DoubleObjByteFunction<? super V, ? extends U> var1, byte var2) |
public |
<U> U |
searchWithDouble<U> U searchWithDouble(Double2ObjectConcurrentHashMap.DoubleObjDoubleFunction<? super V, ? extends U> var1, double var2) |
public |
<U> U |
searchWithFloat<U> U searchWithFloat(Double2ObjectConcurrentHashMap.DoubleObjFloatFunction<? super V, ? extends U> var1, float var2) |
public |
<U> U |
searchWithInt<U> U searchWithInt(Double2ObjectConcurrentHashMap.DoubleObjIntFunction<? super V, ? extends U> var1, int var2) |
public |
<U> U |
searchWithLong<U> U searchWithLong(Double2ObjectConcurrentHashMap.DoubleObjLongFunction<? super V, ? extends U> var1, long var2) |
public |
<U> U |
searchWithShort<U> U searchWithShort(Double2ObjectConcurrentHashMap.DoubleObjShortFunction<? super V, ? extends U> var1, short var2) |
final |
<V> void |
setTabAt<V> void setTabAt(Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Double2ObjectConcurrentHashMap.Node<V> var2) |
abstract |
|
setTabAt setTabAt(var6, var9, var14.next) |
abstract |
|
setTabAt setTabAt(var4, var3++, null) |
abstract |
|
setTabAt setTabAt(var7, var10, var28) |
abstract |
|
setTabAt setTabAt(var8, var11, var18) |
abstract |
|
setTabAt setTabAt(var8, var11, var28) |
abstract |
|
setTabAt setTabAt(var9, var12, var19) |
abstract |
|
setTabAt setTabAt(var2, var9, var14) |
abstract |
|
setTabAt setTabAt(var2, var9 + var3, var15) |
abstract |
|
setTabAt setTabAt(var1, var9, var6) |
abstract |
|
setTabAt setTabAt(var2, var9, var31) |
abstract |
|
setTabAt setTabAt(var2, var9 + var3, var33) |
|
public V |
setValuepublic V setValue(V var1) |
|
public final V |
setValuepublic final V setValue(V var1) |
abstract |
V |
setValueV setValue(V var1) |
public |
int |
sizeint size() |
|
public final int |
sizepublic final int size() |
|
public int |
sizepublic int size() |
|
public ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> |
spliteratorpublic ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> spliterator() |
|
public DoubleSpliterator |
spliteratorpublic DoubleSpliterator spliterator() |
|
public ObjectSpliterator<V> |
spliteratorpublic ObjectSpliterator<V> spliterator() |
final |
int |
spreadint spread(int var0) |
final |
long |
sumCountlong sumCount() |
abstract |
|
super super(var1, var2, var3, var4) |
abstract |
|
super super(var1) |
abstract |
|
super super(var1, var2, var3, var4, var5) |
abstract |
|
super super(var1, -1, var1, null, null) |
abstract |
|
super super(var3, var4, var5, var6, var7) |
abstract |
|
super super(var1, -3, var1, null, null) |
abstract |
|
super super(var1, -2, var1, null, null) |
abstract |
|
super super(var1, var3, var4, var6, var7) |
|
|
synchronized synchronized(var8) |
|
|
synchronized synchronized(var7) |
|
|
synchronized synchronized(var6) |
|
|
synchronized synchronized(var26) |
|
|
synchronized synchronized(var8) |
|
|
synchronized synchronized(var9) |
|
|
synchronized synchronized(var13) |
|
|
synchronized synchronized(var9) |
|
|
synchronized synchronized(var10) |
|
|
synchronized synchronized(var11) |
|
|
synchronized synchronized(var3) |
final |
<V> Double2ObjectConcurrentHashMap.Node<V> |
tabAt<V> Double2ObjectConcurrentHashMap.Node<V> tabAt(Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1) |
final |
int |
tableSizeForint tableSizeFor(int var0) |
abstract |
|
this this(var1, true, -1.0) |
abstract |
|
this this(var1, var2, 1, -1.0) |
|
protected int |
tieBreakOrderprotected int tieBreakOrder(double var1, double var3) |
|
public final Object[] |
toArraypublic final Object[] toArray() |
|
public final <T> T[] |
toArraypublic final <T> T[] toArray(T[] var1) |
|
public Object[] |
toArraypublic Object[] toArray() |
|
public Object[] |
toArraypublic Object[] toArray(Object[] var1) |
|
public double[] |
toArraypublic double[] toArray(double[] var1) |
|
public double[] |
toDoubleArraypublic double[] toDoubleArray() |
|
public double[] |
toDoubleArraypublic double[] toDoubleArray(double[] var1) |
|
public final String |
toStringpublic final String toString() |
|
public String |
toStringpublic String toString() |
|
public final String |
toStringpublic final String toString() |
abstract |
String |
toStringString toString() |
final |
void |
transfervoid transfer(Double2ObjectConcurrentHashMap.Node<V>[] var1, Double2ObjectConcurrentHashMap.Node<V>[] var2) |
final |
void |
treeifyBinvoid treeifyBin(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super Double> var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(DoubleConsumer var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super V> var1) |
final |
void |
tryPresizevoid tryPresize(int var1) |
|
public ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> |
trySplitpublic ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> trySplit() |
|
public DoubleSpliterator |
trySplitpublic DoubleSpliterator trySplit() |
|
public ObjectSpliterator<V> |
trySplitpublic ObjectSpliterator<V> trySplit() |
|
protected final void |
unlockRootprotected final void unlockRoot() |
protected |
<V> Double2ObjectConcurrentHashMap.Node<V> |
untreeify<V> Double2ObjectConcurrentHashMap.Node<V> untreeify(Double2ObjectConcurrentHashMap.Node<V> var1) |
public |
V |
valueMatchingV valueMatching(Predicate<V> var1) |
public |
FastCollection<V> |
valuesFastCollection<V> values() |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var4 != null && var3 < var4.length) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var3 == this.nextTable && this.table == var1) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(!var7) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var3 != null || !var11) |
|
|
while while(var12 == null) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var2-- > 0) |
|
|
while while(var3-- > 0) |
|
|
while while(var3-- > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(this.batch > 0) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var5 != null) |
|
|
while while(true) |
|
|
while while(var4 != null) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(var2 != null && var2 != var1) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
|
|
while while(true) |
Исходный код
Показать/скрыть
class="kw">package com.hypixel.fastutil.doubles;
class="kw">import com.hypixel.fastutil.FastCollection;
class="kw">import com.hypixel.fastutil.util.SneakyThrow;
class="kw">import com.hypixel.fastutil.util.TLRUtil;
class="kw">import it.unimi.dsi.fastutil.doubles.Double2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.doubles.DoubleCollection;
class="kw">import it.unimi.dsi.fastutil.doubles.DoubleIterator;
class="kw">import it.unimi.dsi.fastutil.doubles.DoubleSet;
class="kw">import it.unimi.dsi.fastutil.doubles.DoubleSpliterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectCollection;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSpliterator;
class="kw">import java.io.Serializable;
class="kw">import java.lang.reflect.Array;
class="kw">import java.lang.reflect.Field;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.Enumeration;
class="kw">import java.util.Iterator;
class="kw">import java.util.Map;
class="kw">import java.util.NoSuchElementException;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.CountedCompleter;
class="kw">import java.util.concurrent.ForkJoinPool;
class="kw">import java.util.concurrent.atomic.AtomicReference;
class="kw">import java.util.concurrent.locks.LockSupport;
class="kw">import java.util.concurrent.locks.ReentrantLock;
class="kw">import java.util.function.BiFunction;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.function.DoubleBinaryOperator;
class="kw">import java.util.function.DoubleConsumer;
class="kw">import java.util.function.Function;
class="kw">import java.util.function.IntBinaryOperator;
class="kw">import java.util.function.LongBinaryOperator;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.function.ToIntFunction;
class="kw">import java.util.function.ToLongFunction;
class="kw">import sun.misc.Unsafe;
class="kw">public class Double2ObjectConcurrentHashMap<V> {
class="kw">protected class="kw">static class="kw">final long serialVersionUID = 7249069246763182397L;
class="kw">protected class="kw">static class="kw">final int MAXIMUM_CAPACITY = 1073741824;
class="kw">protected class="kw">static class="kw">final int DEFAULT_CAPACITY = 16;
class="kw">protected class="kw">static class="kw">final int MAX_ARRAY_SIZE = 2147483639;
class="kw">protected class="kw">static class="kw">final int DEFAULT_CONCURRENCY_LEVEL = 16;
class="kw">protected class="kw">static class="kw">final float LOAD_FACTOR = 0.75F;
class="kw">protected class="kw">static class="kw">final int TREEIFY_THRESHOLD = 8;
class="kw">protected class="kw">static class="kw">final int UNTREEIFY_THRESHOLD = 6;
class="kw">protected class="kw">static class="kw">final int MIN_TREEIFY_CAPACITY = 64;
class="kw">protected class="kw">static class="kw">final int MIN_TRANSFER_STRIDE = 16;
class="kw">protected class="kw">static int RESIZE_STAMP_BITS = 16;
class="kw">protected class="kw">static class="kw">final int MAX_RESIZERS = (1 << 32 - RESIZE_STAMP_BITS) - 1;
class="kw">protected class="kw">static class="kw">final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
class="kw">protected class="kw">static class="kw">final int MOVED = -1;
class="kw">protected class="kw">static class="kw">final int TREEBIN = -2;
class="kw">protected class="kw">static class="kw">final int RESERVED = -3;
class="kw">protected class="kw">static class="kw">final int HASH_BITS = Integer.MAX_VALUE;
class="kw">protected class="kw">static class="kw">final int NCPU = Runtime.getRuntime().availableProcessors();
class="kw">protected class="kw">transient class="kw">volatile Double2ObjectConcurrentHashMap.Node<V>[] table;
class="kw">protected class="kw">transient class="kw">volatile Double2ObjectConcurrentHashMap.Node<V>[] nextTable;
class="kw">protected class="kw">transient class="kw">volatile long baseCount;
class="kw">protected class="kw">transient class="kw">volatile int sizeCtl;
class="kw">protected class="kw">transient class="kw">volatile int transferIndex;
class="kw">protected class="kw">transient class="kw">volatile int cellsBusy;
class="kw">protected class="kw">transient class="kw">volatile Double2ObjectConcurrentHashMap.CounterCell[] counterCells;
class="kw">protected class="kw">transient Double2ObjectConcurrentHashMap.KeySetView<V> keySet;
class="kw">protected class="kw">transient Double2ObjectConcurrentHashMap.ValuesView<V> values;
class="kw">protected class="kw">transient Double2ObjectConcurrentHashMap.EntrySetView<V> entrySet;
class="kw">protected class="kw">final double EMPTY;
class="kw">protected class="kw">static class="kw">final Unsafe U;
class="kw">protected class="kw">static class="kw">final long SIZECTL;
class="kw">protected class="kw">static class="kw">final long TRANSFERINDEX;
class="kw">protected class="kw">static class="kw">final long BASECOUNT;
class="kw">protected class="kw">static class="kw">final long CELLSBUSY;
class="kw">protected class="kw">static class="kw">final long CELLVALUE;
class="kw">protected class="kw">static class="kw">final long ABASE;
class="kw">protected class="kw">static class="kw">final int ASHIFT;
class="kw">protected class="kw">static class="kw">final int spread(int var0) {
class="kw">return (var0 ^ var0 >>> 16) & 2147483647;
}
class="kw">protected class="kw">static class="kw">final int tableSizeFor(int var0) {
int var1 = var0 - 1;
var1 |= var1 >>> 1;
var1 |= var1 >>> 2;
var1 |= var1 >>> 4;
var1 |= var1 >>> 8;
var1 |= var1 >>> 16;
class="kw">return var1 < 0 ? 1 : (var1 >= 1073741824 ? 1073741824 : var1 + 1);
}
class="kw">protected class="kw">static class="kw">final <V> Double2ObjectConcurrentHashMap.Node<V> tabAt(Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1) {
class="kw">return (Double2ObjectConcurrentHashMap.Node<V>)U.getObjectVolatile(var0, ((long)var1 << ASHIFT) + ABASE);
}
class="kw">protected class="kw">static class="kw">final <V> boolean casTabAt(
Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Double2ObjectConcurrentHashMap.Node<V> var2, Double2ObjectConcurrentHashMap.Node<V> var3
) {
class="kw">return U.compareAndSwapObject(var0, ((long)var1 << ASHIFT) + ABASE, var2, var3);
}
class="kw">protected class="kw">static class="kw">final <V> void setTabAt(Double2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Double2ObjectConcurrentHashMap.Node<V> var2) {
U.putObjectVolatile(var0, ((long)var1 << ASHIFT) + ABASE, var2);
}
class="kw">public Double2ObjectConcurrentHashMap() {
this.EMPTY = -1.0;
}
class="kw">public Double2ObjectConcurrentHashMap(boolean var1, double var2) {
this.EMPTY = var2;
}
class="kw">public Double2ObjectConcurrentHashMap(int var1) {
this(var1, true, -1.0);
}
class="kw">public Double2ObjectConcurrentHashMap(int var1, boolean var2, double var3) {
if (var1 < 0) {
throw new IllegalArgumentException();
}
int var5 = var1 >= 536870912 ? 1073741824 : tableSizeFor(var1 + (var1 >>> 1) + 1);
this.sizeCtl = var5;
this.EMPTY = var3;
}
class="kw">public Double2ObjectConcurrentHashMap(Map<? class="kw">extends Double, ? class="kw">extends V> var1, double var2) {
this.sizeCtl = 16;
this.EMPTY = var2;
this.putAll(var1);
}
class="kw">public Double2ObjectConcurrentHashMap(Double2ObjectConcurrentHashMap<? class="kw">extends V> var1) {
this.sizeCtl = 16;
this.EMPTY = var1.EMPTY;
this.putAll(var1);
}
class="kw">public Double2ObjectConcurrentHashMap(Double2ObjectMap<V> var1) {
this.sizeCtl = 16;
this.EMPTY = -1.0;
this.putAll(var1);
}
class="kw">public Double2ObjectConcurrentHashMap(Double2ObjectMap<V> var1, double var2) {
this.sizeCtl = 16;
this.EMPTY = var2;
this.putAll(var1);
}
class="kw">public Double2ObjectConcurrentHashMap(int var1, float var2) {
this(var1, var2, 1, -1.0);
}
class="kw">public Double2ObjectConcurrentHashMap(int var1, float var2, int var3, double var4) {
if (var2 > 0.0F && var1 >= 0 && var3 > 0) {
if (var1 < var3) {
var1 = var3;
}
long var6 = (long)(1.0 + (float)var1 / var2);
int var8 = var6 >= 1073741824L ? 1073741824 : tableSizeFor((int)var6);
this.sizeCtl = var8;
this.EMPTY = var4;
} else {
throw new IllegalArgumentException();
}
}
class="kw">public int size() {
long var1 = this.sumCount();
class="kw">return var1 < 0L ? 0 : (var1 > 2147483647L ? Integer.MAX_VALUE : (int)var1);
}
class="kw">public boolean isEmpty() {
class="kw">return this.sumCount() <= 0L;
}
class="kw">public V get(double var1) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
int var10 = spread(Double.hashCode(var1));
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
Double2ObjectConcurrentHashMap.Node var4;
int var6;
if (this.table != null && (var6 = var3.length) > 0 && (var4 = tabAt(var3, var6 - 1 & var10)) != null) {
int var7 = var4.hash;
if (var4.hash == var10) {
double var8 = var4.key;
if (var4.key == var1 || var8 != this.EMPTY && var1 == var8) {
class="kw">return var4.val;
}
} else if (var7 < 0) {
Double2ObjectConcurrentHashMap.Node var5;
class="kw">return (var5 = var4.find(var10, var1)) != null ? var5.val : null;
}
while ((var4 = var4.next) != null) {
if (var4.hash == var10) {
double var11 = var4.key;
if (var4.key == var1 || var11 != this.EMPTY && var1 == var11) {
class="kw">return var4.val;
}
}
}
}
class="kw">return null;
}
class="kw">public boolean containsKey(double var1) {
class="kw">return this.get(var1) != null;
}
class="kw">public boolean containsValue(Object var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = var2;
Double2ObjectConcurrentHashMap.Node var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label85:
while (true) {
if (var11 != null) {
var4 = var11;
break;
}
if (var8 < var9) {
Double2ObjectConcurrentHashMap.Node[] var12 = var3;
if (var3 != null) {
int var14;
int var10000 = var14 = var12.length;
int var13 = var7;
if (var10000 > var7 && var13 >= 0) {
if ((var11 = tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var6;
if (var20 != null) {
var6 = var20.next;
} else {
var20 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var12;
var20.length = var14;
var20.index = var13;
var20.next = var5;
var5 = var20;
class="kw">continue;
}
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Double2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
class="kw">continue;
}
while (true) {
Double2ObjectConcurrentHashMap.TableStack var15 = var5;
if (var5 != null) {
int var16 = var15.length;
if ((var7 += var15.length) >= var14) {
var14 = var16;
var7 = var15.index;
var3 = var15.tab;
var15.tab = null;
Double2ObjectConcurrentHashMap.TableStack var17 = var15.next;
var15.next = var6;
var5 = var17;
var6 = var15;
class="kw">continue;
}
}
if (var15 == null && (var7 += var10) >= var14) {
var7 = ++var8;
}
class="kw">continue label85;
}
}
}
}
var4 = null;
break;
}
if (var11 == null) {
break;
}
Object var19 = var11.val;
if (var11.val == var1 || var19 != null && var1.equals(var19)) {
class="kw">return true;
}
}
}
class="kw">return false;
}
class="kw">public V put(double var1, V var3) {
class="kw">return this.putVal(var1, var3, false);
}
class="kw">protected class="kw">final V putVal(double var1, V var3, boolean var4) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var3 == null) {
throw new NullPointerException();
}
int var5 = spread(Double.hashCode(var1));
int var6 = 0;
Double2ObjectConcurrentHashMap.Node[] var7 = this.table;
while (true) {
int var9;
while (var7 == null || (var9 = var7.length) == 0) {
var7 = this.initTable();
}
Double2ObjectConcurrentHashMap.Node var8;
int var10;
if ((var8 = tabAt(var7, var10 = var9 - 1 & var5)) == null) {
if (casTabAt(var7, var10, null, new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var5, var1, var3, null))) {
break;
}
} else {
int var11 = var8.hash;
if (var8.hash == -1) {
var7 = this.helpTransfer(var7, var8);
} else {
Object var12 = null;
class="kw">synchronized (var8) {
if (tabAt(var7, var10) == var8) {
if (var11 < 0) {
if (var8 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var6 = 2;
Double2ObjectConcurrentHashMap.Node var20;
if ((var20 = ((Double2ObjectConcurrentHashMap.TreeBin)var8).putTreeVal(var5, var1, var3)) != null) {
var12 = var20.val;
if (!var4) {
var20.val = var3;
}
}
}
} else {
var6 = 1;
Double2ObjectConcurrentHashMap.Node var14 = var8;
while (true) {
if (var14.hash == var5) {
double var15 = var14.key;
if (var14.key == var1 || var15 != this.EMPTY && var1 == var15) {
var12 = var14.val;
if (!var4) {
var14.val = var3;
}
break;
}
}
Double2ObjectConcurrentHashMap.Node var17 = var14;
if ((var14 = var14.next) == null) {
var17.next = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var5, var1, var3, null);
break;
}
var6++;
}
}
}
}
if (var6 != 0) {
if (var6 >= 8) {
this.treeifyBin(var7, var10);
}
if (var12 != null) {
class="kw">return var12;
}
break;
}
}
}
}
this.addCount(1L, var6);
class="kw">return null;
}
class="kw">public void putAll(Map<? class="kw">extends Double, ? class="kw">extends V> var1) {
this.tryPresize(var1.size());
for (Map.Entry var3 : var1.entrySet()) {
this.putVal(var3.getKey(), (V)var3.getValue(), false);
}
}
class="kw">public void putAll(Double2ObjectConcurrentHashMap<? class="kw">extends V> var1) {
this.tryPresize(var1.size());
ObjectIterator var2 = var1.double2ObjectEntrySet().iterator();
while (var2.hasNext()) {
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var3 = (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<? class="kw">extends V>)var2.next();
this.putVal(var3.getDoubleKey(), (V)var3.getValue(), false);
}
}
class="kw">public void putAll(Double2ObjectMap<V> var1) {
this.tryPresize(var1.size());
ObjectIterator var2 = var1.double2ObjectEntrySet().iterator();
while (var2.hasNext()) {
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var3 = (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<? class="kw">extends V>)var2.next();
this.putVal(var3.getDoubleKey(), (V)var3.getValue(), false);
}
}
class="kw">public V remove(double var1) {
class="kw">return this.replaceNode(var1, null, null);
}
@Deprecated
class="kw">public V remove(Double var1) {
class="kw">return this.replaceNode(var1, null, null);
}
@Deprecated
class="kw">public V remove(Object var1) {
class="kw">return this.remove((Double)var1);
}
class="kw">protected class="kw">final V replaceNode(double var1, V var3, Object var4) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
int var5 = spread(Double.hashCode(var1));
Double2ObjectConcurrentHashMap.Node[] var6 = this.table;
Double2ObjectConcurrentHashMap.Node var7;
int var8;
int var9;
while (var6 != null && (var8 = var6.length) != 0 && (var7 = tabAt(var6, var9 = var8 - 1 & var5)) != null) {
int var10 = var7.hash;
if (var7.hash == -1) {
var6 = this.helpTransfer(var6, var7);
} else {
Object var11 = null;
boolean var12 = false;
class="kw">synchronized (var7) {
if (tabAt(var6, var9) == var7) {
if (var10 < 0) {
if (var7 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = true;
Double2ObjectConcurrentHashMap.TreeBin var21 = (Double2ObjectConcurrentHashMap.TreeBin<V>)var7;
Double2ObjectConcurrentHashMap.TreeNode var22 = var21.root;
Double2ObjectConcurrentHashMap.TreeNode var23;
if (var21.root != null && (var23 = var22.findTreeNode(var5, var1, null)) != null) {
Object var17 = var23.val;
if (var4 == null || var4 == var17 || var17 != null && var4.equals(var17)) {
var11 = var17;
if (var3 != null) {
var23.val = var3;
} else if (var21.removeTreeNode(var23)) {
setTabAt(var6, var9, this.untreeify(var21.first));
}
}
}
}
} else {
var12 = true;
Double2ObjectConcurrentHashMap.Node var14 = var7;
Double2ObjectConcurrentHashMap.Node var15 = null;
do {
if (var14.hash == var5) {
double var16 = var14.key;
if (var14.key == var1 || var16 != this.EMPTY && var1 == var16) {
Object var18 = var14.val;
if (var4 == null || var4 == var18 || var18 != null && var4.equals(var18)) {
var11 = var18;
if (var3 != null) {
var14.val = var3;
} else if (var15 != null) {
var15.next = var14.next;
} else {
setTabAt(var6, var9, var14.next);
}
}
break;
}
}
var15 = var14;
} while ((var14 = var14.next) != null);
}
}
}
if (var12) {
if (var11 != null) {
if (var3 == null) {
this.addCount(-1L, -1);
}
class="kw">return var11;
}
break;
}
}
}
class="kw">return null;
}
class="kw">public void clear() {
long var1 = 0L;
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
while (var4 != null && var3 < var4.length) {
Double2ObjectConcurrentHashMap.Node var6 = tabAt(var4, var3);
if (var6 == null) {
var3++;
} else {
int var5 = var6.hash;
if (var6.hash == -1) {
var4 = this.helpTransfer(var4, var6);
var3 = 0;
} else {
class="kw">synchronized (var6) {
if (tabAt(var4, var3) == var6) {
for (Double2ObjectConcurrentHashMap.Node var8 = var5 >= 0
? var6
: (var6 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin ? ((Double2ObjectConcurrentHashMap.TreeBin)var6).first : null);
var8 != null;
var8 = var8.next
) {
var1--;
}
setTabAt(var4, var3++, null);
}
}
}
}
}
if (var1 != 0L) {
this.addCount(var1, -1);
}
}
class="kw">public Double2ObjectConcurrentHashMap.KeySetView<V> keySet() {
Double2ObjectConcurrentHashMap.KeySetView var1 = this.keySet;
class="kw">return this.keySet != null ? var1 : (this.keySet = this.buildKeySetView());
}
class="kw">protected Double2ObjectConcurrentHashMap.KeySetView<V> buildKeySetView() {
class="kw">return new Double2ObjectConcurrentHashMap.KeySetView<>(this, null);
}
class="kw">public FastCollection<V> values() {
Double2ObjectConcurrentHashMap.ValuesView var1 = this.values;
class="kw">return this.values != null ? var1 : (this.values = this.buildValuesView());
}
class="kw">protected Double2ObjectConcurrentHashMap.ValuesView<V> buildValuesView() {
class="kw">return new Double2ObjectConcurrentHashMap.ValuesView<>(this);
}
class="kw">public ObjectSet<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> double2ObjectEntrySet() {
Double2ObjectConcurrentHashMap.EntrySetView var1 = this.entrySet;
class="kw">return this.entrySet != null ? var1 : (this.entrySet = this.buildEntrySetView());
}
@Deprecated
class="kw">public ObjectSet<Map.Entry<Double, V>> entrySet() {
class="kw">return this.double2ObjectEntrySet();
}
class="kw">protected Double2ObjectConcurrentHashMap.EntrySetView<V> buildEntrySetView() {
class="kw">return new Double2ObjectConcurrentHashMap.EntrySetView<>(this);
}
@Override
class="kw">public int hashCode() {
int var1 = 0;
Double2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = var2;
Double2ObjectConcurrentHashMap.Node var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label75: {
while (true) {
if (var11 != null) {
var4 = var11;
break label75;
}
if (var8 >= var9) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var12 = var3;
if (var3 == null) {
break;
}
int var14;
int var10000 = var14 = var12.length;
int var13 = var7;
if (var10000 <= var7 || var13 < 0) {
break;
}
if ((var11 = tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var6;
if (var19 != null) {
var6 = var19.next;
} else {
var19 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var12;
var19.length = var14;
var19.index = var13;
var19.next = var5;
var5 = var19;
class="kw">continue;
}
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Double2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var15 = var5;
if (var5 != null) {
int var16 = var15.length;
if ((var7 += var15.length) >= var14) {
var14 = var16;
var7 = var15.index;
var3 = var15.tab;
var15.tab = null;
Double2ObjectConcurrentHashMap.TableStack var17 = var15.next;
var15.next = var6;
var5 = var17;
var6 = var15;
class="kw">continue;
}
}
if (var15 == null && (var7 += var10) >= var14) {
var7 = ++var8;
}
break;
}
}
}
var4 = null;
}
if (var11 == null) {
break;
}
var1 += Double.hashCode(var11.key) ^ var11.val.hashCode();
}
}
class="kw">return var1;
}
@Override
class="kw">public String toString() {
Double2ObjectConcurrentHashMap.Node[] var1 = this.table;
int var2 = this.table == null ? 0 : var1.length;
Double2ObjectConcurrentHashMap.Traverser var3 = new Double2ObjectConcurrentHashMap.Traverser<>(var1, var2, 0, var2);
StringBuilder var4 = new StringBuilder();
var4.append('{');
Double2ObjectConcurrentHashMap.Node var5;
if ((var5 = var3.advance()) != null) {
while (true) {
double var6 = var5.key;
Object var8 = var5.val;
var4.append(var6);
var4.append('=');
var4.append(var8 == this ? "(this Map)" : var8);
if ((var5 = var3.advance()) == null) {
break;
}
var4.append(',').append(' ');
}
}
class="kw">return var4.append('}').toString();
}
@Override
class="kw">public boolean equals(Object var1) {
if (var1 != this) {
if (!(var1 class="kw">instanceof Double2ObjectConcurrentHashMap var2)) {
class="kw">return false;
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
int var4 = this.table == null ? 0 : var3.length;
Double2ObjectConcurrentHashMap.Traverser var5 = new Double2ObjectConcurrentHashMap.Traverser<>(var3, var4, 0, var4);
Double2ObjectConcurrentHashMap.Node var6;
while ((var6 = var5.advance()) != null) {
Object var7 = var6.val;
Object var8 = var2.get(var6.key);
if (var8 == null || var8 != var7 && !var8.equals(var7)) {
class="kw">return false;
}
}
ObjectIterator var12 = var2.double2ObjectEntrySet().iterator();
while (var12.hasNext()) {
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var13 = (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<?>)var12.next();
Object var10;
Object var11;
double var14;
if ((var14 = var13.getDoubleKey()) == var2.EMPTY
|| (var10 = var13.getValue()) == null
|| (var11 = this.get(var14)) == null
|| var10 != var11 && !var10.equals(var11)) {
class="kw">return false;
}
}
}
class="kw">return true;
}
class="kw">public V putIfAbsent(double var1, V var3) {
class="kw">return this.putVal(var1, var3, true);
}
class="kw">public boolean remove(double var1, Object var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else {
class="kw">return var3 != null && this.replaceNode(var1, null, var3) != null;
}
}
class="kw">public boolean replace(double var1, V var3, V var4) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else if (var3 != null && var4 != null) {
class="kw">return this.replaceNode(var1, var4, var3) != null;
} else {
throw new NullPointerException();
}
}
class="kw">public V replace(double var1, V var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return this.replaceNode(var1, var3, null);
}
}
class="kw">public V getOrDefault(double var1, V var3) {
Object var4;
class="kw">return (var4 = this.get(var1)) == null ? var3 : var4;
}
class="kw">public int forEach(Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
int var2 = 0;
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label78: {
while (true) {
if (var12 != null) {
var5 = var12;
break label78;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
var1.accept(var12.key, var12.val);
var2++;
}
}
class="kw">return var2;
}
class="kw">public <X> int forEach(Double2ObjectConcurrentHashMap.DoubleBiObjConsumer<? super V, X> var1, X var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.key, var13.val, var2);
var3++;
}
}
class="kw">return var3;
}
class="kw">public <X, Y> int forEach(Double2ObjectConcurrentHashMap.DoubleTriObjConsumer<? super V, X, Y> var1, X var2, Y var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2, var3);
var4++;
}
}
class="kw">return var4;
}
class="kw">public int forEachWithByte(Double2ObjectConcurrentHashMap.DoubleObjByteConsumer<? super V> var1, byte var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.key, var13.val, var2);
var3++;
}
}
class="kw">return var3;
}
class="kw">public int forEachWithShort(Double2ObjectConcurrentHashMap.DoubleObjShortConsumer<? super V> var1, short var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.key, var13.val, var2);
var3++;
}
}
class="kw">return var3;
}
class="kw">public int forEachWithInt(Double2ObjectConcurrentHashMap.DoubleObjIntConsumer<? super V> var1, int var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.key, var13.val, var2);
var3++;
}
}
class="kw">return var3;
}
class="kw">public int forEachWithLong(Double2ObjectConcurrentHashMap.DoubleObjLongConsumer<? super V> var1, long var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2);
var4++;
}
}
class="kw">return var4;
}
class="kw">public int forEachWithFloat(Double2ObjectConcurrentHashMap.DoubleObjFloatConsumer<? super V> var1, float var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.key, var13.val, var2);
var3++;
}
}
class="kw">return var3;
}
class="kw">public int forEachWithDouble(Double2ObjectConcurrentHashMap.DoubleObjDoubleConsumer<? super V> var1, double var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2);
var4++;
}
}
class="kw">return var4;
}
class="kw">public <X> int forEachWithByte(Double2ObjectConcurrentHashMap.DoubleBiObjByteConsumer<? super V, X> var1, byte var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2, var3);
var4++;
}
}
class="kw">return var4;
}
class="kw">public <X> int forEachWithShort(Double2ObjectConcurrentHashMap.DoubleBiObjShortConsumer<? super V, X> var1, short var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2, var3);
var4++;
}
}
class="kw">return var4;
}
class="kw">public <X> int forEachWithInt(Double2ObjectConcurrentHashMap.DoubleBiObjIntConsumer<? super V, X> var1, int var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2, var3);
var4++;
}
}
class="kw">return var4;
}
class="kw">public <X> int forEachWithLong(Double2ObjectConcurrentHashMap.DoubleBiObjLongConsumer<? super V, X> var1, long var2, X var4) {
if (var1 == null) {
throw new NullPointerException();
}
int var5 = 0;
Double2ObjectConcurrentHashMap.Node[] var6 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var7 = var6;
Double2ObjectConcurrentHashMap.Node var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
Double2ObjectConcurrentHashMap.TableStack var10 = null;
int var11 = 0;
int var12 = 0;
int var13 = var6.length;
int var14 = var6.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var15 = null;
var15 = var8;
if (var8 != null) {
var15 = var15.next;
}
label78: {
while (true) {
if (var15 != null) {
var8 = var15;
break label78;
}
if (var12 >= var13) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var16 = var7;
if (var7 == null) {
break;
}
int var18;
int var10000 = var18 = var16.length;
int var17 = var11;
if (var10000 <= var11 || var17 < 0) {
break;
}
if ((var15 = tabAt(var16, var17)) != null && var15.hash < 0) {
if (var15 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var7 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var15).nextTable;
var15 = null;
Double2ObjectConcurrentHashMap.TableStack var23 = var10;
if (var23 != null) {
var10 = var23.next;
} else {
var23 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var23.tab = var16;
var23.length = var18;
var23.index = var17;
var23.next = var9;
var9 = var23;
class="kw">continue;
}
if (var15 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var15 = ((Double2ObjectConcurrentHashMap.TreeBin)var15).first;
} else {
var15 = null;
}
}
if (var9 == null) {
if ((var11 = var17 + var14) >= var18) {
var11 = ++var12;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var19 = var9;
if (var9 != null) {
int var20 = var19.length;
if ((var11 += var19.length) >= var18) {
var18 = var20;
var11 = var19.index;
var7 = var19.tab;
var19.tab = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var19.next;
var19.next = var10;
var9 = var21;
var10 = var19;
class="kw">continue;
}
}
if (var19 == null && (var11 += var14) >= var18) {
var11 = ++var12;
}
break;
}
}
}
var8 = null;
}
if (var15 == null) {
break;
}
var1.accept(var15.key, var15.val, var2, var4);
var5++;
}
}
class="kw">return var5;
}
class="kw">public <X> int forEachWithFloat(Double2ObjectConcurrentHashMap.DoubleBiObjFloatConsumer<? super V, X> var1, float var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Double2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var6 = var5;
Double2ObjectConcurrentHashMap.Node var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var14 = null;
var14 = var7;
if (var7 != null) {
var14 = var14.next;
}
label78: {
while (true) {
if (var14 != null) {
var7 = var14;
break label78;
}
if (var11 >= var12) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = var6;
if (var6 == null) {
break;
}
int var17;
int var10000 = var17 = var15.length;
int var16 = var10;
if (var10000 <= var10 || var16 < 0) {
break;
}
if ((var14 = tabAt(var15, var16)) != null && var14.hash < 0) {
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Double2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var18 = var8;
if (var8 != null) {
int var19 = var18.length;
if ((var10 += var18.length) >= var17) {
var17 = var19;
var10 = var18.index;
var6 = var18.tab;
var18.tab = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var18.next;
var18.next = var9;
var8 = var20;
var9 = var18;
class="kw">continue;
}
}
if (var18 == null && (var10 += var13) >= var17) {
var10 = ++var11;
}
break;
}
}
}
var7 = null;
}
if (var14 == null) {
break;
}
var1.accept(var14.key, var14.val, var2, var3);
var4++;
}
}
class="kw">return var4;
}
class="kw">public <X> int forEachWithDouble(Double2ObjectConcurrentHashMap.DoubleBiObjDoubleConsumer<? super V, X> var1, double var2, X var4) {
if (var1 == null) {
throw new NullPointerException();
}
int var5 = 0;
Double2ObjectConcurrentHashMap.Node[] var6 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var7 = var6;
Double2ObjectConcurrentHashMap.Node var8 = null;
Double2ObjectConcurrentHashMap.TableStack var9 = null;
Double2ObjectConcurrentHashMap.TableStack var10 = null;
int var11 = 0;
int var12 = 0;
int var13 = var6.length;
int var14 = var6.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var15 = null;
var15 = var8;
if (var8 != null) {
var15 = var15.next;
}
label78: {
while (true) {
if (var15 != null) {
var8 = var15;
break label78;
}
if (var12 >= var13) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var16 = var7;
if (var7 == null) {
break;
}
int var18;
int var10000 = var18 = var16.length;
int var17 = var11;
if (var10000 <= var11 || var17 < 0) {
break;
}
if ((var15 = tabAt(var16, var17)) != null && var15.hash < 0) {
if (var15 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var7 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var15).nextTable;
var15 = null;
Double2ObjectConcurrentHashMap.TableStack var23 = var10;
if (var23 != null) {
var10 = var23.next;
} else {
var23 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var23.tab = var16;
var23.length = var18;
var23.index = var17;
var23.next = var9;
var9 = var23;
class="kw">continue;
}
if (var15 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var15 = ((Double2ObjectConcurrentHashMap.TreeBin)var15).first;
} else {
var15 = null;
}
}
if (var9 == null) {
if ((var11 = var17 + var14) >= var18) {
var11 = ++var12;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var19 = var9;
if (var9 != null) {
int var20 = var19.length;
if ((var11 += var19.length) >= var18) {
var18 = var20;
var11 = var19.index;
var7 = var19.tab;
var19.tab = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var19.next;
var19.next = var10;
var9 = var21;
var10 = var19;
class="kw">continue;
}
}
if (var19 == null && (var11 += var14) >= var18) {
var11 = ++var12;
}
break;
}
}
}
var8 = null;
}
if (var15 == null) {
break;
}
var1.accept(var15.key, var15.val, var2, var4);
var5++;
}
}
class="kw">return var5;
}
class="kw">public void replaceAll(Double2ObjectOperator<V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = var2;
Double2ObjectConcurrentHashMap.Node var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label86: {
while (true) {
if (var11 != null) {
var4 = var11;
break label86;
}
if (var8 >= var9) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var12 = var3;
if (var3 == null) {
break;
}
int var14;
int var10000 = var14 = var12.length;
int var13 = var7;
if (var10000 <= var7 || var13 < 0) {
break;
}
if ((var11 = tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var6;
if (var21 != null) {
var6 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var12;
var21.length = var14;
var21.index = var13;
var21.next = var5;
var5 = var21;
class="kw">continue;
}
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Double2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var15 = var5;
if (var5 != null) {
int var16 = var15.length;
if ((var7 += var15.length) >= var14) {
var14 = var16;
var7 = var15.index;
var3 = var15.tab;
var15.tab = null;
Double2ObjectConcurrentHashMap.TableStack var17 = var15.next;
var15.next = var6;
var5 = var17;
var6 = var15;
class="kw">continue;
}
}
if (var15 == null && (var7 += var10) >= var14) {
var7 = ++var8;
}
break;
}
}
}
var4 = null;
}
if (var11 == null) {
break;
}
Object var19 = var11.val;
double var20 = var11.key;
Object var22;
do {
var22 = var1.apply(var20, var19);
if (var22 == null) {
throw new NullPointerException();
}
} while (this.replaceNode(var20, var22, var19) == null && (var19 = this.get(var20)) != null);
}
}
}
class="kw">public V computeIfAbsent(double var1, Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends V> var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var3 == null) {
throw new NullPointerException();
}
int var4 = spread(Double.hashCode(var1));
Object var5 = null;
int var6 = 0;
Double2ObjectConcurrentHashMap.Node[] var7 = this.table;
while (true) {
int var9;
while (var7 == null || (var9 = var7.length) == 0) {
var7 = this.initTable();
}
Double2ObjectConcurrentHashMap.Node var8;
int var10;
if ((var8 = tabAt(var7, var10 = var9 - 1 & var4)) == null) {
Double2ObjectConcurrentHashMap.Node var26 = new Double2ObjectConcurrentHashMap.ReservationNode<>(this.EMPTY);
class="kw">synchronized (var26) {
if (casTabAt(var7, var10, null, var26)) {
var6 = 1;
Double2ObjectConcurrentHashMap.Node var28 = null;
try {
if ((var5 = (V)var3.apply(var1)) != null) {
var28 = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var5, null);
}
} class="kw">finally {
setTabAt(var7, var10, var28);
}
}
}
if (var6 != 0) {
break;
}
} else {
int var11 = var8.hash;
if (var8.hash == -1) {
var7 = this.helpTransfer(var7, var8);
} else {
boolean var12 = false;
class="kw">synchronized (var8) {
if (tabAt(var7, var10) == var8) {
if (var11 < 0) {
if (var8 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var6 = 2;
Double2ObjectConcurrentHashMap.TreeBin var27 = (Double2ObjectConcurrentHashMap.TreeBin<V>)var8;
Double2ObjectConcurrentHashMap.TreeNode var29 = var27.root;
Double2ObjectConcurrentHashMap.TreeNode var16;
if (var27.root != null && (var16 = var29.findTreeNode(var4, var1, null)) != null) {
var5 = var16.val;
} else if ((var5 = (V)var3.apply(var1)) != null) {
var12 = true;
var27.putTreeVal(var4, var1, var5);
}
}
} else {
var6 = 1;
Double2ObjectConcurrentHashMap.Node var14 = var8;
while (true) {
if (var14.hash == var4) {
double var15 = var14.key;
if (var14.key == var1 || var15 != this.EMPTY && var1 == var15) {
var5 = var14.val;
break;
}
}
Double2ObjectConcurrentHashMap.Node var18 = var14;
if ((var14 = var14.next) == null) {
if ((var5 = (V)var3.apply(var1)) != null) {
var12 = true;
var18.next = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var5, null);
}
break;
}
var6++;
}
}
}
}
if (var6 != 0) {
if (var6 >= 8) {
this.treeifyBin(var7, var10);
}
if (!var12) {
class="kw">return var5;
}
break;
}
}
}
}
if (var5 != null) {
this.addCount(1L, var6);
}
class="kw">return var5;
}
class="kw">public V computeIfPresent(double var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends V> var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var3 == null) {
throw new NullPointerException();
}
int var4 = spread(Double.hashCode(var1));
Object var5 = null;
int var6 = 0;
int var7 = 0;
Double2ObjectConcurrentHashMap.Node[] var8 = this.table;
while (true) {
int var10;
while (var8 == null || (var10 = var8.length) == 0) {
var8 = this.initTable();
}
Double2ObjectConcurrentHashMap.Node var9;
int var11;
if ((var9 = tabAt(var8, var11 = var10 - 1 & var4)) == null) {
break;
}
int var12 = var9.hash;
if (var9.hash == -1) {
var8 = this.helpTransfer(var8, var9);
} else {
class="kw">synchronized (var9) {
if (tabAt(var8, var11) == var9) {
if (var12 < 0) {
if (var9 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var7 = 2;
Double2ObjectConcurrentHashMap.TreeBin var21 = (Double2ObjectConcurrentHashMap.TreeBin<V>)var9;
Double2ObjectConcurrentHashMap.TreeNode var22 = var21.root;
Double2ObjectConcurrentHashMap.TreeNode var23;
if (var21.root != null && (var23 = var22.findTreeNode(var4, var1, null)) != null) {
var5 = (V)var3.apply(var1, var23.val);
if (var5 != null) {
var23.val = var5;
} else {
var6 = -1;
if (var21.removeTreeNode(var23)) {
setTabAt(var8, var11, this.untreeify(var21.first));
}
}
}
}
} else {
var7 = 1;
Double2ObjectConcurrentHashMap.Node var14 = var9;
Double2ObjectConcurrentHashMap.Node var15 = null;
while (true) {
if (var14.hash == var4) {
double var16 = var14.key;
if (var14.key == var1 || var16 != this.EMPTY && var1 == var16) {
var5 = (V)var3.apply(var1, var14.val);
if (var5 != null) {
var14.val = var5;
} else {
var6 = -1;
Double2ObjectConcurrentHashMap.Node var18 = var14.next;
if (var15 != null) {
var15.next = var18;
} else {
setTabAt(var8, var11, var18);
}
}
break;
}
}
var15 = var14;
if ((var14 = var14.next) == null) {
break;
}
var7++;
}
}
}
}
if (var7 != 0) {
break;
}
}
}
if (var6 != 0) {
this.addCount(var6, var7);
}
class="kw">return var5;
}
class="kw">public V compute(double var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends V> var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var3 == null) {
throw new NullPointerException();
}
int var4 = spread(Double.hashCode(var1));
Object var5 = null;
int var6 = 0;
int var7 = 0;
Double2ObjectConcurrentHashMap.Node[] var8 = this.table;
while (true) {
int var10;
while (var8 == null || (var10 = var8.length) == 0) {
var8 = this.initTable();
}
Double2ObjectConcurrentHashMap.Node var9;
int var11;
if ((var9 = tabAt(var8, var11 = var10 - 1 & var4)) == null) {
Double2ObjectConcurrentHashMap.Node var13 = new Double2ObjectConcurrentHashMap.ReservationNode<>(this.EMPTY);
class="kw">synchronized (var13) {
if (casTabAt(var8, var11, null, var13)) {
var7 = 1;
Double2ObjectConcurrentHashMap.Node var28 = null;
try {
if ((var5 = (V)var3.apply(var1, null)) != null) {
var6 = 1;
var28 = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var5, null);
}
} class="kw">finally {
setTabAt(var8, var11, var28);
}
}
}
if (var7 != 0) {
break;
}
} else {
int var12 = var9.hash;
if (var9.hash == -1) {
var8 = this.helpTransfer(var8, var9);
} else {
class="kw">synchronized (var9) {
if (tabAt(var8, var11) == var9) {
if (var12 < 0) {
if (var9 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var7 = 1;
Double2ObjectConcurrentHashMap.TreeBin var26 = (Double2ObjectConcurrentHashMap.TreeBin<V>)var9;
Double2ObjectConcurrentHashMap.TreeNode var27 = var26.root;
Double2ObjectConcurrentHashMap.TreeNode var29;
if (var26.root != null) {
var29 = var27.findTreeNode(var4, var1, null);
} else {
var29 = null;
}
Object var17 = var29 == null ? null : var29.val;
var5 = (V)var3.apply(var1, var17);
if (var5 != null) {
if (var29 != null) {
var29.val = var5;
} else {
var6 = 1;
var26.putTreeVal(var4, var1, var5);
}
} else if (var29 != null) {
var6 = -1;
if (var26.removeTreeNode(var29)) {
setTabAt(var8, var11, this.untreeify(var26.first));
}
}
}
} else {
var7 = 1;
Double2ObjectConcurrentHashMap.Node var14 = var9;
Double2ObjectConcurrentHashMap.Node var15 = null;
while (true) {
if (var14.hash == var4) {
double var16 = var14.key;
if (var14.key == var1 || var16 != this.EMPTY && var1 == var16) {
var5 = (V)var3.apply(var1, var14.val);
if (var5 != null) {
var14.val = var5;
} else {
var6 = -1;
Double2ObjectConcurrentHashMap.Node var18 = var14.next;
if (var15 != null) {
var15.next = var18;
} else {
setTabAt(var8, var11, var18);
}
}
break;
}
}
var15 = var14;
if ((var14 = var14.next) == null) {
var5 = (V)var3.apply(var1, null);
if (var5 != null) {
var6 = 1;
var15.next = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var5, null);
}
break;
}
var7++;
}
}
}
}
if (var7 != 0) {
if (var7 >= 8) {
this.treeifyBin(var8, var11);
}
break;
}
}
}
}
if (var6 != 0) {
this.addCount(var6, var7);
}
class="kw">return var5;
}
class="kw">public V merge(double var1, V var3, BiFunction<? super V, ? super V, ? class="kw">extends V> var4) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var3 != null && var4 != null) {
int var5 = spread(Double.hashCode(var1));
Object var6 = null;
int var7 = 0;
int var8 = 0;
Double2ObjectConcurrentHashMap.Node[] var9 = this.table;
while (true) {
int var11;
while (var9 == null || (var11 = var9.length) == 0) {
var9 = this.initTable();
}
Double2ObjectConcurrentHashMap.Node var10;
int var12;
if ((var10 = tabAt(var9, var12 = var11 - 1 & var5)) == null) {
if (casTabAt(var9, var12, null, new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var5, var1, var3, null))) {
var7 = 1;
var6 = var3;
break;
}
} else {
int var13 = var10.hash;
if (var10.hash == -1) {
var9 = this.helpTransfer(var9, var10);
} else {
class="kw">synchronized (var10) {
if (tabAt(var9, var12) == var10) {
if (var13 < 0) {
if (var10 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var8 = 2;
Double2ObjectConcurrentHashMap.TreeBin var22 = (Double2ObjectConcurrentHashMap.TreeBin<V>)var10;
Double2ObjectConcurrentHashMap.TreeNode var23 = var22.root;
Double2ObjectConcurrentHashMap.TreeNode var24 = var23 == null ? null : var23.findTreeNode(var5, var1, null);
var6 = var24 == null ? var3 : var4.apply(var24.val, var3);
if (var6 != null) {
if (var24 != null) {
var24.val = var6;
} else {
var7 = 1;
var22.putTreeVal(var5, var1, var6);
}
} else if (var24 != null) {
var7 = -1;
if (var22.removeTreeNode(var24)) {
setTabAt(var9, var12, this.untreeify(var22.first));
}
}
}
} else {
var8 = 1;
Double2ObjectConcurrentHashMap.Node var15 = var10;
Double2ObjectConcurrentHashMap.Node var16 = null;
while (true) {
if (var15.hash == var5) {
double var17 = var15.key;
if (var15.key == var1 || var17 != this.EMPTY && var1 == var17) {
var6 = (V)var4.apply(var15.val, var3);
if (var6 != null) {
var15.val = var6;
} else {
var7 = -1;
Double2ObjectConcurrentHashMap.Node var19 = var15.next;
if (var16 != null) {
var16.next = var19;
} else {
setTabAt(var9, var12, var19);
}
}
break;
}
}
var16 = var15;
if ((var15 = var15.next) == null) {
var7 = 1;
var6 = var3;
var16.next = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var5, var1, var6, null);
break;
}
var8++;
}
}
}
}
if (var8 != 0) {
if (var8 >= 8) {
this.treeifyBin(var9, var12);
}
break;
}
}
}
}
if (var7 != 0) {
this.addCount(var7, var8);
}
class="kw">return var6;
} else {
throw new NullPointerException();
}
}
class="kw">public long mappingCount() {
long var1 = this.sumCount();
class="kw">return var1 < 0L ? 0L : var1;
}
class="kw">public class="kw">static DoubleSet newKeySet() {
class="kw">return new Double2ObjectConcurrentHashMap.KeySetView<>(new Double2ObjectConcurrentHashMap<>(), Boolean.TRUE);
}
class="kw">public class="kw">static Double2ObjectConcurrentHashMap.KeySetView<Boolean> newKeySet(int var0) {
class="kw">return new Double2ObjectConcurrentHashMap.KeySetView<>(new Double2ObjectConcurrentHashMap<>(var0), Boolean.TRUE);
}
class="kw">public Double2ObjectConcurrentHashMap.KeySetView<V> keySet(V var1) {
if (var1 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.KeySetView<>(this, var1);
}
}
class="kw">protected class="kw">static class="kw">final int resizeStamp(int var0) {
class="kw">return Integer.numberOfLeadingZeros(var0) | 1 << RESIZE_STAMP_BITS - 1;
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V>[] initTable() {
Double2ObjectConcurrentHashMap.Node[] var1;
while (true) {
var1 = this.table;
if (this.table != null && var1.length != 0) {
break;
}
int var2 = this.sizeCtl;
if (this.sizeCtl < 0) {
Thread.yield();
} else if (U.compareAndSwapInt(this, SIZECTL, var2, -1)) {
try {
var1 = this.table;
if (this.table == null || var1.length == 0) {
int var3 = var2 > 0 ? var2 : 16;
Double2ObjectConcurrentHashMap.Node[] var4 = new Double2ObjectConcurrentHashMap.Node[var3];
var1 = var4;
this.table = var4;
var2 = var3 - (var3 >>> 2);
}
break;
} class="kw">finally {
this.sizeCtl = var2;
}
}
}
class="kw">return var1;
}
class="kw">protected class="kw">final void addCount(long var1, int var3) {
int var13;
label77: {
long var7;
label74: {
Double2ObjectConcurrentHashMap.CounterCell[] var4 = this.counterCells;
if (this.counterCells == null) {
long var5 = this.baseCount;
if (U.compareAndSwapLong(this, BASECOUNT, this.baseCount, var7 = var5 + var1)) {
break label74;
}
}
var13 = (boolean)1;
Double2ObjectConcurrentHashMap.CounterCell var9;
int var12;
if (var4 == null || (var12 = var4.length - 1) < 0 || (var9 = var4[TLRUtil.getProbe() & var12]) == null) {
break label77;
}
long var10 = var9.value;
if (!(var13 = U.compareAndSwapLong(var9, CELLVALUE, var9.value, var10 + var1))) {
break label77;
}
if (var3 <= 1) {
class="kw">return;
}
var7 = this.sumCount();
}
if (var3 >= 0) {
while (true) {
int var16 = this.sizeCtl;
if (var7 < this.sizeCtl) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = this.table;
int var11;
if (this.table == null || (var11 = var14.length) >= 1073741824) {
break;
}
var13 = (boolean)resizeStamp(var11);
if (var16 < 0) {
if (var16 >>> RESIZE_STAMP_SHIFT != var13 || var16 == var13 + 1 || var16 == var13 + MAX_RESIZERS) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var15 = this.nextTable;
if (this.nextTable == null || this.transferIndex <= 0) {
break;
}
if (U.compareAndSwapInt(this, SIZECTL, var16, var16 + 1)) {
this.transfer(var14, var15);
}
} else if (U.compareAndSwapInt(this, SIZECTL, var16, (var13 << RESIZE_STAMP_SHIFT) + 2)) {
this.transfer(var14, null);
}
var7 = this.sumCount();
}
}
class="kw">return;
}
this.fullAddCount(var1, var13);
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V>[] helpTransfer(
Double2ObjectConcurrentHashMap.Node<V>[] var1, Double2ObjectConcurrentHashMap.Node<V> var2
) {
if (var1 != null && var2 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
Double2ObjectConcurrentHashMap.Node[] var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var2).nextTable;
if (((Double2ObjectConcurrentHashMap.ForwardingNode)var2).nextTable != null) {
int var5 = resizeStamp(var1.length);
while (var3 == this.nextTable && this.table == var1) {
int var4 = this.sizeCtl;
if (this.sizeCtl >= 0 || var4 >>> RESIZE_STAMP_SHIFT != var5 || var4 == var5 + 1 || var4 == var5 + MAX_RESIZERS || this.transferIndex <= 0) {
break;
}
if (U.compareAndSwapInt(this, SIZECTL, var4, var4 + 1)) {
this.transfer(var1, var3);
break;
}
}
class="kw">return var3;
}
}
class="kw">return this.table;
}
class="kw">protected class="kw">final void tryPresize(int var1) {
int var2 = var1 >= 536870912 ? 1073741824 : tableSizeFor(var1 + (var1 >>> 1) + 1);
while (true) {
int var3 = this.sizeCtl;
if (this.sizeCtl < 0) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
int var5;
if (var4 != null && (var5 = var4.length) != 0) {
if (var2 <= var3 || var5 >= 1073741824) {
break;
}
if (var4 == this.table) {
int var11 = resizeStamp(var5);
if (var3 < 0) {
if (var3 >>> RESIZE_STAMP_SHIFT != var11 || var3 == var11 + 1 || var3 == var11 + MAX_RESIZERS) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var7 = this.nextTable;
if (this.nextTable == null || this.transferIndex <= 0) {
break;
}
if (U.compareAndSwapInt(this, SIZECTL, var3, var3 + 1)) {
this.transfer(var4, var7);
}
} else if (U.compareAndSwapInt(this, SIZECTL, var3, (var11 << RESIZE_STAMP_SHIFT) + 2)) {
this.transfer(var4, null);
}
}
} else {
var5 = var3 > var2 ? var3 : var2;
if (U.compareAndSwapInt(this, SIZECTL, var3, -1)) {
try {
if (this.table == var4) {
Double2ObjectConcurrentHashMap.Node[] var6 = new Double2ObjectConcurrentHashMap.Node[var5];
this.table = var6;
var3 = var5 - (var5 >>> 2);
}
} class="kw">finally {
this.sizeCtl = var3;
}
}
}
}
}
class="kw">protected class="kw">final void transfer(Double2ObjectConcurrentHashMap.Node<V>[] var1, Double2ObjectConcurrentHashMap.Node<V>[] var2) {
int var3 = var1.length;
int var4;
if ((var4 = NCPU > 1 ? (var3 >>> 3) / NCPU : var3) < 16) {
var4 = 16;
}
if (var2 == null) {
try {
Double2ObjectConcurrentHashMap.Node[] var5 = new Double2ObjectConcurrentHashMap.Node[var3 << 1];
var2 = var5;
} catch (Throwable var27) {
this.sizeCtl = Integer.MAX_VALUE;
class="kw">return;
}
this.nextTable = var2;
this.transferIndex = var3;
}
int var29 = var2.length;
Double2ObjectConcurrentHashMap.ForwardingNode var6 = new Double2ObjectConcurrentHashMap.ForwardingNode<>(this.EMPTY, var2);
boolean var7 = true;
boolean var8 = false;
int var9 = 0;
int var10 = 0;
while (true) {
while (!var7) {
if (var9 >= 0 && var9 < var3 && var9 + var3 < var29) {
Double2ObjectConcurrentHashMap.Node var11;
if ((var11 = tabAt(var1, var9)) == null) {
var7 = casTabAt(var1, var9, null, var6);
} else {
int var12 = var11.hash;
if (var11.hash == -1) {
var7 = true;
} else {
class="kw">synchronized (var11) {
if (tabAt(var1, var9) == var11) {
if (var12 >= 0) {
int var16 = var12 & var3;
Double2ObjectConcurrentHashMap.Node var17 = var11;
for (Double2ObjectConcurrentHashMap.Node var18 = var11.next; var18 != null; var18 = var18.next) {
int var19 = var18.hash & var3;
if (var19 != var16) {
var16 = var19;
var17 = var18;
}
}
Double2ObjectConcurrentHashMap.Node var14;
Double2ObjectConcurrentHashMap.Node var15;
if (var16 == 0) {
var14 = var17;
var15 = null;
} else {
var15 = var17;
var14 = null;
}
for (Double2ObjectConcurrentHashMap.Node var36 = var11; var36 != var17; var36 = var36.next) {
int var38 = var36.hash;
double var20 = var36.key;
Object var22 = var36.val;
if ((var38 & var3) == 0) {
var14 = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var38, var20, var22, var14);
} else {
var15 = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var38, var20, var22, var15);
}
}
setTabAt(var2, var9, var14);
setTabAt(var2, var9 + var3, var15);
setTabAt(var1, var9, var6);
var7 = true;
} else if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin var34) {
Double2ObjectConcurrentHashMap.TreeNode var35 = null;
Double2ObjectConcurrentHashMap.TreeNode var37 = null;
Double2ObjectConcurrentHashMap.TreeNode var39 = null;
Double2ObjectConcurrentHashMap.TreeNode var40 = null;
int var21 = 0;
int var41 = 0;
for (Double2ObjectConcurrentHashMap.Node var23 = var34.first; var23 != null; var23 = var23.next) {
int var24 = var23.hash;
Double2ObjectConcurrentHashMap.TreeNode var25 = new Double2ObjectConcurrentHashMap.TreeNode<>(
this.EMPTY, var24, var23.key, var23.val, null, null
);
if ((var24 & var3) == 0) {
if ((var25.prev = var37) == null) {
var35 = var25;
} else {
var37.next = var25;
}
var37 = var25;
var21++;
} else {
if ((var25.prev = var40) == null) {
var39 = var25;
} else {
var40.next = var25;
}
var40 = var25;
var41++;
}
}
Double2ObjectConcurrentHashMap.Node var31 = var21 <= 6
? this.untreeify(var35)
: (var41 != 0 ? new Double2ObjectConcurrentHashMap.TreeBin<>(this.EMPTY, var35) : var34);
Double2ObjectConcurrentHashMap.Node var33 = var41 <= 6
? this.untreeify(var39)
: (var21 != 0 ? new Double2ObjectConcurrentHashMap.TreeBin<>(this.EMPTY, var39) : var34);
setTabAt(var2, var9, var31);
setTabAt(var2, var9 + var3, var33);
setTabAt(var1, var9, var6);
var7 = true;
}
}
}
}
}
} else {
if (var8) {
this.nextTable = null;
this.table = var2;
this.sizeCtl = (var3 << 1) - (var3 >>> 1);
class="kw">return;
}
int var13 = this.sizeCtl;
if (U.compareAndSwapInt(this, SIZECTL, this.sizeCtl, var13 - 1)) {
if (var13 - 2 != resizeStamp(var3) << RESIZE_STAMP_SHIFT) {
class="kw">return;
}
var7 = true;
var8 = true;
var9 = var3;
}
}
}
if (--var9 < var10 && !var8) {
int var30 = this.transferIndex;
if (this.transferIndex <= 0) {
var9 = -1;
var7 = false;
} else {
int var32;
if (U.compareAndSwapInt(this, TRANSFERINDEX, var30, var32 = var30 > var4 ? var30 - var4 : 0)) {
var10 = var32;
var9 = var30 - 1;
var7 = false;
}
}
} else {
var7 = false;
}
}
}
class="kw">protected class="kw">final long sumCount() {
Double2ObjectConcurrentHashMap.CounterCell[] var1 = this.counterCells;
long var3 = this.baseCount;
if (var1 != null) {
for (int var5 = 0; var5 < var1.length; var5++) {
Double2ObjectConcurrentHashMap.CounterCell var2;
if ((var2 = var1[var5]) != null) {
var3 += var2.value;
}
}
}
class="kw">return var3;
}
class="kw">protected class="kw">final void fullAddCount(long var1, boolean var3) {
int var4;
if ((var4 = TLRUtil.getProbe()) == 0) {
TLRUtil.localInit();
var4 = TLRUtil.getProbe();
var3 = true;
}
boolean var5 = false;
while (true) {
Double2ObjectConcurrentHashMap.CounterCell[] var6 = this.counterCells;
int var8;
if (this.counterCells != null && (var8 = var6.length) > 0) {
Double2ObjectConcurrentHashMap.CounterCell var7;
if ((var7 = var6[var8 - 1 & var4]) == null) {
if (this.cellsBusy == 0) {
Double2ObjectConcurrentHashMap.CounterCell var32 = new Double2ObjectConcurrentHashMap.CounterCell(var1);
if (this.cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean var34 = false;
try {
Double2ObjectConcurrentHashMap.CounterCell[] var13 = this.counterCells;
int var14;
int var15;
if (this.counterCells != null && (var14 = var13.length) > 0 && var13[var15 = var14 - 1 & var4] == null) {
var13[var15] = var32;
var34 = true;
}
} class="kw">finally {
this.cellsBusy = 0;
}
if (var34) {
break;
}
class="kw">continue;
}
}
var5 = false;
} else if (!var3) {
var3 = true;
} else {
long var31 = var7.value;
if (U.compareAndSwapLong(var7, CELLVALUE, var7.value, var31 + var1)) {
break;
}
if (this.counterCells != var6 || var8 >= NCPU) {
var5 = false;
} else if (!var5) {
var5 = true;
} else if (this.cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (this.counterCells == var6) {
Double2ObjectConcurrentHashMap.CounterCell[] var33 = new Double2ObjectConcurrentHashMap.CounterCell[var8 << 1];
for (int var35 = 0; var35 < var8; var35++) {
var33[var35] = var6[var35];
}
this.counterCells = var33;
}
} class="kw">finally {
this.cellsBusy = 0;
}
var5 = false;
class="kw">continue;
}
}
var4 = TLRUtil.advanceProbe(var4);
} else if (this.cellsBusy == 0 && this.counterCells == var6 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean var11 = false;
try {
if (this.counterCells == var6) {
Double2ObjectConcurrentHashMap.CounterCell[] var12 = new Double2ObjectConcurrentHashMap.CounterCell[2];
var12[var4 & 1] = new Double2ObjectConcurrentHashMap.CounterCell(var1);
this.counterCells = var12;
var11 = true;
}
} class="kw">finally {
this.cellsBusy = 0;
}
if (var11) {
break;
}
} else {
long var9 = this.baseCount;
if (U.compareAndSwapLong(this, BASECOUNT, this.baseCount, var9 + var1)) {
break;
}
}
}
}
class="kw">protected class="kw">final void treeifyBin(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2) {
if (var1 != null) {
int var4;
if ((var4 = var1.length) < 64) {
this.tryPresize(var4 << 1);
} else {
Double2ObjectConcurrentHashMap.Node var3;
if ((var3 = tabAt(var1, var2)) != null && var3.hash >= 0) {
class="kw">synchronized (var3) {
if (tabAt(var1, var2) == var3) {
Double2ObjectConcurrentHashMap.TreeNode var7 = null;
Double2ObjectConcurrentHashMap.TreeNode var8 = null;
for (Double2ObjectConcurrentHashMap.Node var9 = var3; var9 != null; var9 = var9.next) {
Double2ObjectConcurrentHashMap.TreeNode var10 = new Double2ObjectConcurrentHashMap.TreeNode<>(
this.EMPTY, var9.hash, var9.key, var9.val, null, null
);
if ((var10.prev = var8) == null) {
var7 = var10;
} else {
var8.next = var10;
}
var8 = var10;
}
setTabAt(var1, var2, new Double2ObjectConcurrentHashMap.TreeBin<>(this.EMPTY, var7));
}
}
}
}
}
}
class="kw">protected <V> Double2ObjectConcurrentHashMap.Node<V> untreeify(Double2ObjectConcurrentHashMap.Node<V> var1) {
Double2ObjectConcurrentHashMap.Node var2 = null;
Double2ObjectConcurrentHashMap.Node var3 = null;
for (Double2ObjectConcurrentHashMap.Node var4 = var1; var4 != null; var4 = var4.next) {
Double2ObjectConcurrentHashMap.Node var5 = new Double2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4.hash, var4.key, var4.val, null);
if (var3 == null) {
var2 = var5;
} else {
var3.next = var5;
}
var3 = var5;
}
class="kw">return var2;
}
class="kw">protected class="kw">final int batchFor(long var1) {
long var3;
if (var1 != Long.MAX_VALUE && (var3 = this.sumCount()) > 1L && var3 >= var1) {
int var5 = ForkJoinPool.getCommonPoolParallelism() << 2;
long var6;
class="kw">return var1 > 0L && (var6 = var3 / var1) < var5 ? (int)var6 : var5;
} else {
class="kw">return 0;
}
}
class="kw">public void forEach(long var1, Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Double2ObjectConcurrentHashMap.ForEachMappingTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEach(long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Double2ObjectConcurrentHashMap.ForEachTransformedMappingTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U search(long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.SearchMappingsTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public <U> U search(Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = var2;
Double2ObjectConcurrentHashMap.Node var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label81: {
while (true) {
if (var11 != null) {
var4 = var11;
break label81;
}
if (var8 >= var9) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var12 = var3;
if (var3 == null) {
break;
}
int var14;
int var10000 = var14 = var12.length;
int var13 = var7;
if (var10000 <= var7 || var13 < 0) {
break;
}
if ((var11 = tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var6;
if (var20 != null) {
var6 = var20.next;
} else {
var20 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var12;
var20.length = var14;
var20.index = var13;
var20.next = var5;
var5 = var20;
class="kw">continue;
}
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Double2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var15 = var5;
if (var5 != null) {
int var16 = var15.length;
if ((var7 += var15.length) >= var14) {
var14 = var16;
var7 = var15.index;
var3 = var15.tab;
var15.tab = null;
Double2ObjectConcurrentHashMap.TableStack var17 = var15.next;
var15.next = var6;
var5 = var17;
var6 = var15;
class="kw">continue;
}
}
if (var15 == null && (var7 += var10) >= var14) {
var7 = ++var8;
}
break;
}
}
}
var4 = null;
}
if (var11 == null) {
break;
}
Object var19 = (U)var1.apply(var11.key, var11.val);
if (var19 != null) {
class="kw">return var19;
}
}
}
class="kw">return null;
}
class="kw">public <U, X> U search(Double2ObjectConcurrentHashMap.DoubleBiObjFunction<? super V, X, ? class="kw">extends U> var1, X var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label81: {
while (true) {
if (var12 != null) {
var5 = var12;
break label81;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
Object var20 = (U)var1.apply(var12.key, var12.val, var2);
if (var20 != null) {
class="kw">return var20;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithByte(Double2ObjectConcurrentHashMap.DoubleObjByteFunction<? super V, ? class="kw">extends U> var1, byte var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label81: {
while (true) {
if (var12 != null) {
var5 = var12;
break label81;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
Object var20 = (U)var1.apply(var12.key, var12.val, var2);
if (var20 != null) {
class="kw">return var20;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithShort(Double2ObjectConcurrentHashMap.DoubleObjShortFunction<? super V, ? class="kw">extends U> var1, short var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label81: {
while (true) {
if (var12 != null) {
var5 = var12;
break label81;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
Object var20 = (U)var1.apply(var12.key, var12.val, var2);
if (var20 != null) {
class="kw">return var20;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithInt(Double2ObjectConcurrentHashMap.DoubleObjIntFunction<? super V, ? class="kw">extends U> var1, int var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label81: {
while (true) {
if (var12 != null) {
var5 = var12;
break label81;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
Object var20 = (U)var1.apply(var12.key, var12.val, var2);
if (var20 != null) {
class="kw">return var20;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithLong(Double2ObjectConcurrentHashMap.DoubleObjLongFunction<? super V, ? class="kw">extends U> var1, long var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label81: {
while (true) {
if (var13 != null) {
var6 = var13;
break label81;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var8;
if (var22 != null) {
var8 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var7;
var7 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
Object var21 = (U)var1.apply(var13.key, var13.val, var2);
if (var21 != null) {
class="kw">return var21;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithFloat(Double2ObjectConcurrentHashMap.DoubleObjFloatFunction<? super V, ? class="kw">extends U> var1, float var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label81: {
while (true) {
if (var12 != null) {
var5 = var12;
break label81;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
Object var20 = (U)var1.apply(var12.key, var12.val, var2);
if (var20 != null) {
class="kw">return var20;
}
}
}
class="kw">return null;
}
class="kw">public <U> U searchWithDouble(Double2ObjectConcurrentHashMap.DoubleObjDoubleFunction<? super V, ? class="kw">extends U> var1, double var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label81: {
while (true) {
if (var13 != null) {
var6 = var13;
break label81;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var8;
if (var22 != null) {
var8 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var7;
var7 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
Object var21 = (U)var1.apply(var13.key, var13.val, var2);
if (var21 != null) {
class="kw">return var21;
}
}
}
class="kw">return null;
}
class="kw">public <U> U reduce(
long var1, Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var3, BiFunction<? super U, ? super U, ? class="kw">extends U> var4
) {
if (var3 != null && var4 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceMappingsTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U reduce(Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var1, BiFunction<? super U, ? super U, ? class="kw">extends U> var2) {
if (var1 != null && var2 != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table == null) {
class="kw">return null;
}
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
Object var12 = null;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var5;
if (var5 != null) {
var13 = var13.next;
}
label88: {
while (true) {
if (var13 != null) {
var5 = var13;
break label88;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var4;
if (var4 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var8;
if (var10000 <= var8 || var15 < 0) {
break;
}
if ((var13 = tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = var7;
if (var22 != null) {
var7 = var22.next;
} else {
var22 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var6;
var6 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var6 == null) {
if ((var8 = var15 + var11) >= var16) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var6;
if (var6 != null) {
int var18 = var17.length;
if ((var8 += var17.length) >= var16) {
var16 = var18;
var8 = var17.index;
var4 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var7;
var6 = var19;
var7 = var17;
class="kw">continue;
}
}
if (var17 == null && (var8 += var11) >= var16) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var13 == null) {
class="kw">return var12;
}
Object var21;
if ((var21 = (U)var1.apply(var13.key, var13.val)) != null) {
var12 = var12 == null ? var21 : var2.apply(var12, var21);
}
}
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceToDouble(long var1, Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction<? super V> var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6)
.invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public long reduceToLong(long var1, Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction<? super V> var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public int reduceToInt(long var1, Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction<? super V> var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var5).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public void forEachKey(long var1, DoubleConsumer var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Double2ObjectConcurrentHashMap.ForEachKeyTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEachKey(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Double2ObjectConcurrentHashMap.ForEachTransformedKeyTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U searchKeys(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.SearchKeysTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public double reduceKeys(long var1, Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.ReduceKeysTask<>(this.EMPTY, null, this.batchFor(var1), 0, 0, this.table, null, var3).invoke0();
}
}
class="kw">public <U> U reduceKeys(long var1, Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var3, BiFunction<? super U, ? super U, ? class="kw">extends U> var4) {
if (var3 != null && var4 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceKeysTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceKeysToDouble(long var1, Double2ObjectConcurrentHashMap.DoubleToDoubleFunction var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public long reduceKeysToLong(long var1, Double2ObjectConcurrentHashMap.DoubleToLongFunction var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public int reduceKeysToInt(long var1, Double2ObjectConcurrentHashMap.DoubleToIntFunction var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var5).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public void forEachValue(long var1, Consumer<? super V> var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Double2ObjectConcurrentHashMap.ForEachValueTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEachValue(long var1, Function<? super V, ? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Double2ObjectConcurrentHashMap.ForEachTransformedValueTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U searchValues(long var1, Function<? super V, ? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.SearchValuesTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public V reduceValues(long var1, BiFunction<? super V, ? super V, ? class="kw">extends V> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.ReduceValuesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3).invoke();
}
}
class="kw">public <U> U reduceValues(long var1, Function<? super V, ? class="kw">extends U> var3, BiFunction<? super U, ? super U, ? class="kw">extends U> var4) {
if (var3 != null && var4 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceValuesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceValuesToDouble(long var1, Double2ObjectConcurrentHashMap.ToDoubleFunction<? super V> var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public long reduceValuesToLong(long var1, ToLongFunction<? super V> var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public int reduceValuesToInt(long var1, ToIntFunction<? super V> var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var5).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public void forEachEntry(long var1, Consumer<? super Double2ObjectConcurrentHashMap.Entry<V>> var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Double2ObjectConcurrentHashMap.ForEachEntryTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEachEntry(long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Double2ObjectConcurrentHashMap.ForEachTransformedEntryTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U searchEntries(long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.SearchEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public Double2ObjectConcurrentHashMap.Entry<V> reduceEntries(
long var1,
BiFunction<Double2ObjectConcurrentHashMap.Entry<V>, Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Double2ObjectConcurrentHashMap.Entry<V>> var3
) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Double2ObjectConcurrentHashMap.ReduceEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3).invoke();
}
}
class="kw">public <U> U reduceEntries(
long var1, Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var3, BiFunction<? super U, ? super U, ? class="kw">extends U> var4
) {
if (var3 != null && var4 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceEntriesToDouble(
long var1, Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, double var4, DoubleBinaryOperator var6
) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6)
.invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public long reduceEntriesToLong(long var1, ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var6).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public int reduceEntriesToInt(long var1, ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4, var5).invoke0();
} else {
throw new NullPointerException();
}
}
class="kw">public V valueMatching(Predicate<V> var1) {
Double2ObjectConcurrentHashMap.Node var3 = null;
Double2ObjectConcurrentHashMap.TableStack var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
int var6 = 0;
int var7 = 0;
Double2ObjectConcurrentHashMap.Node[] var2 = this.table;
int var8 = this.table == null ? 0 : var2.length;
int var9 = var8;
int var10 = var8;
boolean var11 = false;
label80:
while (var3 != null || !var11) {
var11 |= true;
Double2ObjectConcurrentHashMap.Node var12 = var3;
if (var3 != null) {
var12 = var12.next;
}
label76:
while (var12 == null) {
if (var7 < var9) {
Double2ObjectConcurrentHashMap.Node[] var13 = var2;
if (var2 != null) {
int var15;
int var10000 = var15 = var13.length;
int var14 = var6;
if (var10000 > var6 && var14 >= 0) {
if ((var12 = tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var2 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var5;
if (var19 != null) {
var5 = var19.next;
} else {
var19 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var13;
var19.length = var15;
var19.index = var14;
var19.next = var4;
var4 = var19;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var4 == null) {
if ((var6 = var14 + var10) >= var15) {
var6 = ++var7;
}
class="kw">continue;
}
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var4;
if (var4 != null) {
int var17 = var16.length;
if ((var6 += var16.length) >= var15) {
var15 = var17;
var6 = var16.index;
var2 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var5;
var4 = var18;
var5 = var16;
class="kw">continue;
}
}
if (var16 == null && (var6 += var10) >= var15) {
var6 = ++var7;
}
class="kw">continue label76;
}
}
}
}
var3 = null;
class="kw">continue label80;
}
var3 = var12;
Double2ObjectConcurrentHashMap.Node var20 = var12;
if (var1.test(var20.val)) {
class="kw">return var12.val;
}
}
class="kw">return null;
}
class="kw">static {
try {
Field var0 = Unsafe.class.getDeclaredField("theUnsafe");
var0.setAccessible(true);
U = (Unsafe)var0.get(null);
Class var1 = Double2ObjectConcurrentHashMap.class;
SIZECTL = U.objectFieldOffset(var1.getDeclaredField("sizeCtl"));
TRANSFERINDEX = U.objectFieldOffset(var1.getDeclaredField("transferIndex"));
BASECOUNT = U.objectFieldOffset(var1.getDeclaredField("baseCount"));
CELLSBUSY = U.objectFieldOffset(var1.getDeclaredField("cellsBusy"));
Class var2 = Double2ObjectConcurrentHashMap.CounterCell.class;
CELLVALUE = U.objectFieldOffset(var2.getDeclaredField("value"));
Class var3 = Double2ObjectConcurrentHashMap.Node[].class;
ABASE = U.arrayBaseOffset(var3);
int var4 = U.arrayIndexScale(var3);
if ((var4 & var4 - 1) != 0) {
throw new Error("data type scale not a power of two");
}
ASHIFT = 31 - Integer.numberOfLeadingZeros(var4);
} catch (Exception var5) {
throw new Error(var5);
}
}
class="kw">protected class="kw">static class BaseIterator<V> class="kw">extends Double2ObjectConcurrentHashMap.Traverser<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<V> map;
class="kw">public Double2ObjectConcurrentHashMap.Node<V> lastReturned;
class="kw">public BaseIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) {
super(var1, var2, var3, var4);
this.map = var5;
this.advance();
}
class="kw">public class="kw">final boolean hasNext() {
class="kw">return this.next != null;
}
class="kw">public class="kw">final boolean hasMoreElements() {
class="kw">return this.next != null;
}
class="kw">public class="kw">final void remove() {
Double2ObjectConcurrentHashMap.Node var1 = this.lastReturned;
if (this.lastReturned == null) {
throw new IllegalStateException();
}
this.lastReturned = null;
this.map.replaceNode(var1.key, null, null);
}
}
class="kw">protected class="kw">abstract class="kw">static class BulkTask<V, R> class="kw">extends CountedCompleter<R> {
class="kw">public Double2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Double2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> spare;
class="kw">public int index;
class="kw">public int baseIndex;
class="kw">public int baseLimit;
class="kw">public class="kw">final int baseSize;
class="kw">public int batch;
class="kw">protected BulkTask(Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5) {
super(var1);
this.batch = var2;
this.index = this.baseIndex = var3;
if ((this.tab = var5) == null) {
this.baseSize = this.baseLimit = 0;
} else if (var1 == null) {
this.baseSize = this.baseLimit = var5.length;
} else {
this.baseLimit = var4;
this.baseSize = var1.baseSize;
}
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V> advance() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next != null) {
var1 = var1.next;
}
while (true) {
if (var1 != null) {
class="kw">return this.next = var1;
}
if (this.baseIndex >= this.baseLimit) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.tab;
if (this.tab == null) {
break;
}
int var4;
int var10000 = var4 = var2.length;
int var3 = this.index;
if (var10000 <= this.index || var3 < 0) {
break;
}
if ((var1 = Double2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Double2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Double2ObjectConcurrentHashMap.TreeBin)var1).first;
} else {
var1 = null;
}
}
if (this.stack != null) {
this.recoverState(var4);
} else if ((this.index = var3 + this.baseSize) >= var4) {
this.index = ++this.baseIndex;
}
}
class="kw">return this.next = null;
}
class="kw">protected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Double2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var4.tab = var1;
var4.length = var3;
var4.index = var2;
var4.next = this.stack;
this.stack = var4;
}
class="kw">protected void recoverState(int var1) {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var2 = this.stack;
if (this.stack != null) {
int var3 = var2.length;
if ((this.index = this.index + var2.length) >= var1) {
var1 = var3;
this.index = var2.index;
this.tab = var2.tab;
var2.tab = null;
Double2ObjectConcurrentHashMap.TableStack var4 = var2.next;
var2.next = this.spare;
this.stack = var4;
this.spare = var2;
class="kw">continue;
}
}
if (var2 == null && (this.index = this.index + this.baseSize) >= var1) {
this.index = ++this.baseIndex;
}
class="kw">return;
}
}
}
class="kw">protected class="kw">abstract class="kw">static class CollectionView<K, E> class="kw">implements ObjectCollection<E>, Serializable {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 7249069246763182397L;
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<K> map;
class="kw">protected class="kw">static class="kw">final String oomeMsg = "Required array size too large";
class="kw">public CollectionView(Double2ObjectConcurrentHashMap<K> var1) {
this.map = var1;
}
class="kw">public Double2ObjectConcurrentHashMap<K> getMap() {
class="kw">return this.map;
}
class="kw">public class="kw">final void clear() {
this.map.clear();
}
class="kw">public class="kw">final int size() {
class="kw">return this.map.size();
}
class="kw">public class="kw">final boolean isEmpty() {
class="kw">return this.map.isEmpty();
}
class="kw">public class="kw">abstract ObjectIterator<E> iterator();
class="kw">public class="kw">abstract boolean contains(Object var1);
class="kw">public class="kw">abstract boolean remove(Object var1);
class="kw">public class="kw">final Object[] toArray() {
long var1 = this.map.mappingCount();
if (var1 > 2147483639L) {
throw new OutOfMemoryError("Required array size too large");
}
int var3 = (int)var1;
Object[] var4 = new Object[var3];
int var5 = 0;
ObjectIterator var6 = this.iterator();
while (var6.hasNext()) {
Object var7 = (E)var6.next();
if (var5 == var3) {
if (var3 >= 2147483639) {
throw new OutOfMemoryError("Required array size too large");
}
if (var3 >= 1073741819) {
var3 = 2147483639;
} else {
var3 += (var3 >>> 1) + 1;
}
var4 = Arrays.copyOf(var4, var3);
}
var4[var5++] = var7;
}
class="kw">return var5 == var3 ? var4 : Arrays.copyOf(var4, var5);
}
class="kw">public class="kw">final <T> T[] toArray(T[] var1) {
long var2 = this.map.mappingCount();
if (var2 > 2147483639L) {
throw new OutOfMemoryError("Required array size too large");
}
int var4 = (int)var2;
Object[] var5 = (T[])(var1.length >= var4 ? var1 : (Object[])Array.newInstance(var1.getClass().getComponentType(), var4));
int var6 = var5.length;
int var7 = 0;
ObjectIterator var8 = this.iterator();
while (var8.hasNext()) {
Object var9 = (E)var8.next();
if (var7 == var6) {
if (var6 >= 2147483639) {
throw new OutOfMemoryError("Required array size too large");
}
if (var6 >= 1073741819) {
var6 = 2147483639;
} else {
var6 += (var6 >>> 1) + 1;
}
var5 = (T[])Arrays.copyOf(var5, var6);
}
var5[var7++] = (T)var9;
}
if (var1 == var5 && var7 < var6) {
var5[var7] = null;
class="kw">return var5;
} else {
class="kw">return (T[])(var7 == var6 ? var5 : Arrays.copyOf(var5, var7));
}
}
@Override
class="kw">public class="kw">final String toString() {
StringBuilder var1 = new StringBuilder();
var1.append('[');
Iterator var2 = this.iterator();
if (var2.hasNext()) {
while (true) {
Object var3 = var2.next();
var1.append(var3 == this ? "(this Collection)" : var3);
if (!var2.hasNext()) {
break;
}
var1.append(',').append(' ');
}
}
class="kw">return var1.append(']').toString();
}
class="kw">public class="kw">final boolean containsAll(Collection<?> var1) {
if (var1 != this) {
for (Object var3 : var1) {
if (var3 == null || !this.contains(var3)) {
class="kw">return false;
}
}
}
class="kw">return true;
}
class="kw">public class="kw">final boolean removeAll(Collection<?> var1) {
if (var1 == null) {
throw new NullPointerException();
}
boolean var2 = false;
Iterator var3 = this.iterator();
while (var3.hasNext()) {
if (var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public class="kw">final boolean retainAll(Collection<?> var1) {
if (var1 == null) {
throw new NullPointerException();
}
boolean var2 = false;
Iterator var3 = this.iterator();
while (var3.hasNext()) {
if (!var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
}
class="kw">protected class="kw">static class="kw">final class CounterCell {
class="kw">public class="kw">volatile long value;
class="kw">public CounterCell(long var1) {
this.value = var1;
}
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjByteConsumer<V, X> {
void accept(double var1, V var3, byte var4, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjConsumer<V, X> {
void accept(double var1, V var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjDoubleConsumer<V, X> {
void accept(double var1, V var3, double var4, X var6);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjFloatConsumer<V, X> {
void accept(double var1, V var3, float var4, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjFunction<V, X, J> {
J apply(double var1, V var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjIntConsumer<V, X> {
void accept(double var1, V var3, int var4, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjLongConsumer<V, X> {
void accept(double var1, V var3, long var4, X var6);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleBiObjShortConsumer<V, X> {
void accept(double var1, V var3, short var4, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleFunction<R> {
R apply(double var1);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjByteConsumer<V> {
void accept(double var1, V var3, byte var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjByteFunction<V, J> {
J apply(double var1, V var3, byte var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjConsumer<V> {
void accept(double var1, V var3);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjDoubleConsumer<V> {
void accept(double var1, V var3, double var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjDoubleFunction<V, J> {
J apply(double var1, V var3, double var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjFloatConsumer<V> {
void accept(double var1, V var3, float var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjFloatFunction<V, J> {
J apply(double var1, V var3, float var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjFunction<V, J> {
J apply(double var1, V var3);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjIntConsumer<V> {
void accept(double var1, V var3, int var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjIntFunction<V, J> {
J apply(double var1, V var3, int var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjLongConsumer<V> {
void accept(double var1, V var3, long var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjLongFunction<V, J> {
J apply(double var1, V var3, long var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjShortConsumer<V> {
void accept(double var1, V var3, short var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleObjShortFunction<V, J> {
J apply(double var1, V var3, short var4);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleReduceTaskOperator {
double reduce(double var1, double var3, double var5);
}
class="kw">protected class="kw">abstract class="kw">static class DoubleReturningBulkTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Double> {
class="kw">public double result;
class="kw">public DoubleReturningBulkTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5
) {
super(var1, var2, var3, var4, var5);
}
class="kw">protected double invoke0() {
this.quietlyInvoke();
Throwable var2 = this.getException();
if (var2 != null) {
throw SneakyThrow.sneakyThrow(var2);
} else {
class="kw">return this.result;
}
}
}
class="kw">protected class="kw">abstract class="kw">static class DoubleReturningBulkTask2<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Double> {
class="kw">public double result;
class="kw">public DoubleReturningBulkTask2(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5
) {
super(var1, var2, var3, var4, var5);
}
class="kw">protected double invoke0() {
this.quietlyInvoke();
Throwable var2 = this.getException();
if (var2 != null) {
throw SneakyThrow.sneakyThrow(var2);
} else {
class="kw">return this.result;
}
}
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleToDoubleFunction {
double applyAsDouble(double var1);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleToIntFunction {
int applyAsInt(double var1);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleToLongFunction {
long applyAsLong(double var1);
}
@FunctionalInterface
class="kw">public class="kw">interface DoubleTriObjConsumer<V, X, Y> {
void accept(double var1, V var3, X var4, Y var5);
}
class="kw">public class="kw">interface Entry<V> class="kw">extends it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V> {
boolean isEmpty();
@Deprecated
Double getKey();
double getDoubleKey();
V getValue();
@Override
int hashCode();
@Override
String toString();
@Override
boolean equals(Object var1);
V setValue(V var1);
}
class="kw">protected class="kw">static class="kw">final class EntryIterator<V>
class="kw">extends Double2ObjectConcurrentHashMap.BaseIterator<V>
class="kw">implements ObjectIterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> {
class="kw">public EntryIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) {
super(var1, var2, var3, var4, var5);
}
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.Entry<V> next() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next == null) {
throw new NoSuchElementException();
}
double var2 = var1.key;
Object var4 = var1.val;
this.lastReturned = var1;
this.advance();
class="kw">return new Double2ObjectConcurrentHashMap.MapEntry<>(var1.isEmpty(), var2, var4, this.map);
}
}
class="kw">protected class="kw">static class="kw">final class EntrySetView<V>
class="kw">extends Double2ObjectConcurrentHashMap.CollectionView<V, it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>>
class="kw">implements ObjectSet<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>>,
Serializable {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 2249069246763182397L;
class="kw">public EntrySetView(Double2ObjectConcurrentHashMap<V> var1) {
super(var1);
}
@Override
class="kw">public boolean contains(Object var1) {
if (var1 class="kw">instanceof it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry) {
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var6;
double var2 = (var6 = (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<?>)var1).getDoubleKey();
if (!((Double2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
Object var4;
Object var5;
class="kw">return (var5 = this.map.get(var2)) != null && (var4 = var6.getValue()) != null && (var4 == var5 || var4.equals(var5));
}
}
class="kw">return false;
}
@Override
class="kw">public boolean remove(Object var1) {
if (var1 class="kw">instanceof it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry) {
it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var5;
double var2 = (var5 = (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<?>)var1).getDoubleKey();
if (!((Double2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
Object var4;
class="kw">return (var4 = var5.getValue()) != null && this.map.remove(var2, var4);
}
}
class="kw">return false;
}
@Override
class="kw">public ObjectIterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> iterator() {
Double2ObjectConcurrentHashMap var1 = this.map;
Double2ObjectConcurrentHashMap.Node[] var2 = var1.table;
int var3 = var1.table == null ? 0 : var2.length;
class="kw">return new Double2ObjectConcurrentHashMap.EntryIterator<>(var2, var3, 0, var3, var1);
}
class="kw">public boolean add(it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V> var1) {
class="kw">return this.map.putVal(var1.getDoubleKey(), (V)var1.getValue(), false) == null;
}
class="kw">public boolean addAll(Collection<? class="kw">extends it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) {
boolean var2 = false;
for (it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry var4 : var1) {
if (this.add(var4)) {
var2 = true;
}
}
class="kw">return var2;
}
@Override
class="kw">public class="kw">final int hashCode() {
int var1 = 0;
Double2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Traverser var3 = new Double2ObjectConcurrentHashMap.Traverser<>(var2, var2.length, 0, var2.length);
Double2ObjectConcurrentHashMap.Node var4;
while ((var4 = var3.advance()) != null) {
var1 += var4.hashCode();
}
}
class="kw">return var1;
}
@Override
class="kw">public class="kw">final boolean equals(Object var1) {
Set var2;
class="kw">return var1 class="kw">instanceof Set && ((var2 = (Set<?>)var1) == this || this.containsAll(var2) && var2.containsAll(this));
}
class="kw">public ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> spliterator() {
Double2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Double2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Double2ObjectConcurrentHashMap.EntrySpliterator<>(var1, var5, 0, var5, var3 < 0L ? 0L : var3, var2);
}
class="kw">public void forEach(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Traverser var3 = new Double2ObjectConcurrentHashMap.Traverser<>(var2, var2.length, 0, var2.length);
Double2ObjectConcurrentHashMap.Node var4;
while ((var4 = var3.advance()) != null) {
var1.accept(new Double2ObjectConcurrentHashMap.MapEntry<>(var4.isEmpty(), var4.key, var4.val, this.map));
}
}
}
}
class="kw">protected class="kw">static class="kw">final class EntrySpliterator<V>
class="kw">extends Double2ObjectConcurrentHashMap.Traverser<V>
class="kw">implements ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<V> map;
class="kw">public long est;
class="kw">public EntrySpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5, Double2ObjectConcurrentHashMap<V> var7) {
super(var1, var2, var3, var4);
this.map = var7;
this.est = var5;
}
class="kw">public ObjectSpliterator<it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> trySplit() {
int var1 = this.baseIndex;
int var2 = this.baseLimit;
int var3;
class="kw">return (var3 = this.baseIndex + this.baseLimit >>> 1) <= var1
? null
: new Double2ObjectConcurrentHashMap.EntrySpliterator<>(this.tab, this.baseSize, this.baseLimit = var3, var2, this.est >>>= 1, this.map);
}
class="kw">public void forEachRemaining(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
while ((var2 = this.advance()) != null) {
var1.accept(new Double2ObjectConcurrentHashMap.MapEntry<>(var2.isEmpty(), var2.key, var2.val, this.map));
}
}
class="kw">public boolean tryAdvance(Consumer<? super it.unimi.dsi.fastutil.doubles.Double2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
if ((var2 = this.advance()) == null) {
class="kw">return false;
}
var1.accept(new Double2ObjectConcurrentHashMap.MapEntry<>(var2.isEmpty(), var2.key, var2.val, this.map));
class="kw">return true;
}
class="kw">public long estimateSize() {
class="kw">return this.est;
}
class="kw">public int characteristics() {
class="kw">return 4353;
}
}
class="kw">protected class="kw">static class="kw">final class ForEachEntryTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Consumer<? super Double2ObjectConcurrentHashMap.Entry<V>> action;
class="kw">public ForEachEntryTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super Double2ObjectConcurrentHashMap.Entry<V>> var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
Consumer var1 = this.action;
if (this.action != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachEntryTask<>(this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, var1).fork();
}
while ((var5 = this.advance()) != null) {
var1.accept(var5);
}
this.propagateCompletion();
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachKeyTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final DoubleConsumer action;
class="kw">public ForEachKeyTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5, DoubleConsumer var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
DoubleConsumer var1 = this.action;
if (this.action != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachKeyTask<>(this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, var1).fork();
}
while ((var5 = this.advance()) != null) {
var1.accept(var5.key);
}
this.propagateCompletion();
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachMappingTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> action;
class="kw">public ForEachMappingTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjConsumer<? super V> var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleObjConsumer var1 = this.action;
if (this.action != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachMappingTask<>(this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, var1).fork();
}
while ((var5 = this.advance()) != null) {
var1.accept(var5.key, var5.val);
}
this.propagateCompletion();
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachTransformedEntryTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedEntryTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var6,
Consumer<? super U> var7
) {
super(var1, var2, var3, var4, var5);
this.transformer = var6;
this.action = var7;
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.transformer;
if (this.transformer != null) {
Consumer var2 = this.action;
if (this.action != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachTransformedEntryTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2)
.fork();
}
while ((var6 = this.advance()) != null) {
Object var7;
if ((var7 = (U)var1.apply(var6)) != null) {
var2.accept(var7);
}
}
this.propagateCompletion();
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachTransformedKeyTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedKeyTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var6,
Consumer<? super U> var7
) {
super(var1, var2, var3, var4, var5);
this.transformer = var6;
this.action = var7;
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleFunction var1 = this.transformer;
if (this.transformer != null) {
Consumer var2 = this.action;
if (this.action != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachTransformedKeyTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2)
.fork();
}
while ((var6 = this.advance()) != null) {
Object var7;
if ((var7 = (U)var1.apply(var6.key)) != null) {
var2.accept(var7);
}
}
this.propagateCompletion();
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachTransformedMappingTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedMappingTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var6,
Consumer<? super U> var7
) {
super(var1, var2, var3, var4, var5);
this.transformer = var6;
this.action = var7;
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleObjFunction var1 = this.transformer;
if (this.transformer != null) {
Consumer var2 = this.action;
if (this.action != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachTransformedMappingTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2)
.fork();
}
while ((var6 = this.advance()) != null) {
Object var7;
if ((var7 = (U)var1.apply(var6.key, var6.val)) != null) {
var2.accept(var7);
}
}
this.propagateCompletion();
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachTransformedValueTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Function<? super V, ? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedValueTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? class="kw">extends U> var6,
Consumer<? super U> var7
) {
super(var1, var2, var3, var4, var5);
this.transformer = var6;
this.action = var7;
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.transformer;
if (this.transformer != null) {
Consumer var2 = this.action;
if (this.action != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachTransformedValueTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2)
.fork();
}
while ((var6 = this.advance()) != null) {
Object var7;
if ((var7 = (U)var1.apply(var6.val)) != null) {
var2.accept(var7);
}
}
this.propagateCompletion();
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ForEachValueTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Consumer<? super V> action;
class="kw">public ForEachValueTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super V> var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
Consumer var1 = this.action;
if (this.action != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.ForEachValueTask<>(this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, var1).fork();
}
while ((var5 = this.advance()) != null) {
var1.accept(var5.val);
}
this.propagateCompletion();
}
}
}
class="kw">protected class="kw">static class="kw">final class ForwardingNode<V> class="kw">extends Double2ObjectConcurrentHashMap.Node<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.Node<V>[] nextTable;
class="kw">public ForwardingNode(double var1, Double2ObjectConcurrentHashMap.Node<V>[] var3) {
super(var1, -1, var1, null, null);
this.nextTable = var3;
}
@Override
class="kw">protected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) {
Double2ObjectConcurrentHashMap.Node[] var4 = this.nextTable;
Double2ObjectConcurrentHashMap.Node var5;
int var6;
label41:
while (var2 != this.EMPTY && var4 != null && (var6 = var4.length) != 0 && (var5 = Double2ObjectConcurrentHashMap.tabAt(var4, var6 - 1 & var1)) != null) {
do {
int var7 = var5.hash;
if (var5.hash == var1) {
double var8 = var5.key;
if (var5.key == var2 || var8 != this.EMPTY && var2 == var8) {
class="kw">return var5;
}
}
if (var7 < 0) {
if (!(var5 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode)) {
class="kw">return var5.find(var1, var2);
}
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var5).nextTable;
class="kw">continue label41;
}
} while ((var5 = var5.next) != null);
class="kw">return null;
}
class="kw">return null;
}
}
class="kw">protected class="kw">abstract class="kw">static class IntReturningBulkTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Integer> {
class="kw">public int result;
class="kw">public IntReturningBulkTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5
) {
super(var1, var2, var3, var4, var5);
}
class="kw">protected int invoke0() {
this.quietlyInvoke();
Throwable var2 = this.getException();
if (var2 != null) {
throw SneakyThrow.sneakyThrow(var2);
} else {
class="kw">return this.result;
}
}
}
class="kw">protected class="kw">static class="kw">final class KeyIterator<V> class="kw">implements DoubleIterator {
class="kw">public Double2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Double2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> spare;
class="kw">public int index;
class="kw">public int baseIndex;
class="kw">public int baseLimit;
class="kw">public class="kw">final int baseSize;
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<V> map;
class="kw">public Double2ObjectConcurrentHashMap.Node<V> lastReturned;
class="kw">public KeyIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) {
this.tab = var1;
this.baseSize = var2;
this.baseIndex = this.index = var3;
this.baseLimit = var4;
this.next = null;
this.map = var5;
this.advance();
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V> advance() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next != null) {
var1 = var1.next;
}
while (true) {
if (var1 != null) {
class="kw">return this.next = var1;
}
if (this.baseIndex >= this.baseLimit) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.tab;
if (this.tab == null) {
break;
}
int var4;
int var10000 = var4 = var2.length;
int var3 = this.index;
if (var10000 <= this.index || var3 < 0) {
break;
}
if ((var1 = Double2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Double2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Double2ObjectConcurrentHashMap.TreeBin)var1).first;
} else {
var1 = null;
}
}
if (this.stack != null) {
this.recoverState(var4);
} else if ((this.index = var3 + this.baseSize) >= var4) {
this.index = ++this.baseIndex;
}
}
class="kw">return this.next = null;
}
class="kw">protected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Double2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var4.tab = var1;
var4.length = var3;
var4.index = var2;
var4.next = this.stack;
this.stack = var4;
}
class="kw">protected void recoverState(int var1) {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var2 = this.stack;
if (this.stack != null) {
int var3 = var2.length;
if ((this.index = this.index + var2.length) >= var1) {
var1 = var3;
this.index = var2.index;
this.tab = var2.tab;
var2.tab = null;
Double2ObjectConcurrentHashMap.TableStack var4 = var2.next;
var2.next = this.spare;
this.stack = var4;
this.spare = var2;
class="kw">continue;
}
}
if (var2 == null && (this.index = this.index + this.baseSize) >= var1) {
this.index = ++this.baseIndex;
}
class="kw">return;
}
}
class="kw">public class="kw">final boolean hasNext() {
class="kw">return this.next != null;
}
class="kw">public class="kw">final boolean hasMoreElements() {
class="kw">return this.next != null;
}
class="kw">public class="kw">final void remove() {
Double2ObjectConcurrentHashMap.Node var1 = this.lastReturned;
if (this.lastReturned == null) {
throw new IllegalStateException();
}
this.lastReturned = null;
this.map.replaceNode(var1.key, null, null);
}
class="kw">public class="kw">final double nextDouble() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next == null) {
throw new NoSuchElementException();
}
double var2 = var1.key;
this.lastReturned = var1;
this.advance();
class="kw">return var2;
}
}
class="kw">public class="kw">static class KeySetView<V> class="kw">implements DoubleSet {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 7249069246763182397L;
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<V> map;
class="kw">public class="kw">final V value;
class="kw">public KeySetView(Double2ObjectConcurrentHashMap<V> var1, V var2) {
this.map = var1;
this.value = var2;
}
class="kw">public V getMappedValue() {
class="kw">return this.value;
}
class="kw">public boolean contains(double var1) {
class="kw">return this.map.containsKey(var1);
}
class="kw">public boolean remove(double var1) {
class="kw">return this.map.remove(var1) != null;
}
class="kw">public DoubleIterator iterator() {
Double2ObjectConcurrentHashMap var2 = this.map;
Double2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var3 = var2.table == null ? 0 : var1.length;
class="kw">return new Double2ObjectConcurrentHashMap.KeyIterator<>(var1, var3, 0, var3, var2);
}
class="kw">public boolean add(double var1) {
Object var3 = this.value;
if (this.value == null) {
throw new UnsupportedOperationException();
} else {
class="kw">return this.map.putVal(var1, var3, true) == null;
}
}
class="kw">public boolean addAll(DoubleCollection var1) {
boolean var2 = false;
Object var3 = this.value;
if (this.value == null) {
throw new UnsupportedOperationException();
}
DoubleIterator var4 = var1.iterator();
while (var4.hasNext()) {
double var5 = var4.nextDouble();
if (this.map.putVal(var5, var3, true) == null) {
var2 = true;
}
}
class="kw">return var2;
}
@Override
class="kw">public int hashCode() {
int var1 = 0;
DoubleIterator var2 = this.iterator();
while (var2.hasNext()) {
var1 += Double.hashCode(var2.nextDouble());
}
class="kw">return var1;
}
@Override
class="kw">public boolean equals(Object var1) {
DoubleSet var2;
class="kw">return var1 class="kw">instanceof DoubleSet && ((var2 = (DoubleSet)var1) == this || this.containsAll(var2) && var2.containsAll(this));
}
class="kw">public double getNoEntryValue() {
class="kw">return this.map.EMPTY;
}
class="kw">public int size() {
class="kw">return this.map.size();
}
class="kw">public boolean isEmpty() {
class="kw">return this.map.isEmpty();
}
class="kw">public Object[] toArray() {
Object[] var1 = new Double[this.size()];
DoubleIterator var2 = this.iterator();
int var3;
for (var3 = 0; var3 < var1.length && var2.hasNext(); var3++) {
var1[var3] = var2.nextDouble();
}
if (var1.length > var3 + 1) {
var1[var3] = this.map.EMPTY;
}
class="kw">return var1;
}
class="kw">public Object[] toArray(Object[] var1) {
DoubleIterator var2 = this.iterator();
int var3;
for (var3 = 0; var3 < var1.length && var2.hasNext() && var3 <= var1.length; var3++) {
var1[var3] = var2.next();
}
if (var1.length > var3 + 1) {
var1[var3] = this.map.EMPTY;
}
class="kw">return var1;
}
class="kw">public double[] toDoubleArray() {
double[] var1 = new double[this.size()];
DoubleIterator var2 = this.iterator();
int var3;
for (var3 = 0; var3 < var1.length && var2.hasNext(); var3++) {
var1[var3] = var2.next();
}
if (var1.length > var3 + 1) {
var1[var3] = this.map.EMPTY;
}
class="kw">return var1;
}
class="kw">public double[] toArray(double[] var1) {
DoubleIterator var2 = this.iterator();
int var3;
for (var3 = 0; var3 < var1.length && var2.hasNext() && var3 <= var1.length; var3++) {
var1[var3] = var2.next();
}
if (var1.length > var3 + 1) {
var1[var3] = this.map.EMPTY;
}
class="kw">return var1;
}
class="kw">public double[] toDoubleArray(double[] var1) {
class="kw">return this.toArray(var1);
}
class="kw">public boolean containsAll(Collection<?> var1) {
for (Object var3 : var1) {
if (!(var3 class="kw">instanceof Long)) {
class="kw">return false;
}
double var4 = (Double)var3;
if (!this.contains(var4)) {
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">public boolean containsAll(DoubleCollection var1) {
DoubleIterator var2 = var1.iterator();
while (var2.hasNext()) {
double var3 = var2.next();
if (!this.contains(var3)) {
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">public boolean containsAll(double[] var1) {
int var2 = var1.length;
while (var2-- > 0) {
if (!this.contains(var1[var2])) {
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">public boolean addAll(Collection<? class="kw">extends Double> var1) {
boolean var2 = false;
for (Double var4 : var1) {
double var5 = var4;
if (this.add(var5)) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean addAll(double[] var1) {
boolean var2 = false;
int var3 = var1.length;
while (var3-- > 0) {
if (this.add(var1[var3])) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean retainAll(Collection<?> var1) {
boolean var2 = false;
DoubleIterator var3 = this.iterator();
while (var3.hasNext()) {
if (!var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean retainAll(DoubleCollection var1) {
if (this == var1) {
class="kw">return false;
}
boolean var2 = false;
DoubleIterator var3 = this.iterator();
while (var3.hasNext()) {
if (!var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean retainAll(double[] var1) {
boolean var2 = false;
DoubleIterator var3 = this.iterator();
while (var3.hasNext()) {
if (Arrays.binarySearch(var1, var3.next().doubleValue()) < 0) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean removeAll(Collection<?> var1) {
boolean var2 = false;
for (Object var4 : var1) {
if (var4 class="kw">instanceof Double) {
double var5 = (Double)var4;
if (this.remove(var5)) {
var2 = true;
}
}
}
class="kw">return var2;
}
class="kw">public boolean removeAll(DoubleCollection var1) {
boolean var2 = false;
DoubleIterator var3 = var1.iterator();
while (var3.hasNext()) {
double var4 = var3.next();
if (this.remove(var4)) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean removeAll(double[] var1) {
boolean var2 = false;
int var3 = var1.length;
while (var3-- > 0) {
if (this.remove(var1[var3])) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public void clear() {
this.map.clear();
}
class="kw">public DoubleSpliterator spliterator() {
Double2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Double2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Double2ObjectConcurrentHashMap.KeySpliterator<>(var1, var5, 0, var5, var3 < 0L ? 0L : var3);
}
}
class="kw">protected class="kw">static class="kw">final class KeySpliterator<V> class="kw">extends Double2ObjectConcurrentHashMap.Traverser<V> class="kw">implements DoubleSpliterator {
class="kw">public long est;
class="kw">public KeySpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) {
super(var1, var2, var3, var4);
this.est = var5;
}
class="kw">public DoubleSpliterator trySplit() {
int var1 = this.baseIndex;
int var2 = this.baseLimit;
int var3;
class="kw">return (var3 = this.baseIndex + this.baseLimit >>> 1) <= var1
? null
: new Double2ObjectConcurrentHashMap.KeySpliterator<>(this.tab, this.baseSize, this.baseLimit = var3, var2, this.est >>>= 1);
}
class="kw">public boolean tryAdvance(Consumer<? super Double> var1) {
class="kw">return var1 class="kw">instanceof DoubleConsumer ? this.tryAdvance((DoubleConsumer)var1) : this.tryAdvance(var1x -> var1.accept(var1x));
}
class="kw">public void forEachRemaining(DoubleConsumer var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
while ((var2 = this.advance()) != null) {
var1.accept(var2.key);
}
}
class="kw">public boolean tryAdvance(DoubleConsumer var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
if ((var2 = this.advance()) == null) {
class="kw">return false;
}
var1.accept(var2.key);
class="kw">return true;
}
class="kw">public long estimateSize() {
class="kw">return this.est;
}
class="kw">public int characteristics() {
class="kw">return 4353;
}
}
class="kw">protected class="kw">abstract class="kw">static class LongReturningBulkTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Long> {
class="kw">public long result;
class="kw">public LongReturningBulkTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap.Node<V>[] var5
) {
super(var1, var2, var3, var4, var5);
}
class="kw">protected long invoke0() {
this.quietlyInvoke();
Throwable var2 = this.getException();
if (var2 != null) {
throw SneakyThrow.sneakyThrow(var2);
} else {
class="kw">return this.result;
}
}
}
class="kw">protected class="kw">static class="kw">final class MapEntry<V> class="kw">implements Double2ObjectConcurrentHashMap.Entry<V> {
class="kw">public class="kw">final boolean empty;
class="kw">public class="kw">final double key;
class="kw">public V val;
class="kw">public class="kw">final Double2ObjectConcurrentHashMap<V> map;
class="kw">public MapEntry(boolean var1, double var2, V var4, Double2ObjectConcurrentHashMap<V> var5) {
this.empty = var1;
this.key = var2;
this.val = var4;
this.map = var5;
}
@Override
class="kw">public boolean isEmpty() {
class="kw">return this.empty;
}
@Override
class="kw">public Double getKey() {
class="kw">return this.key;
}
@Override
class="kw">public double getDoubleKey() {
class="kw">return this.key;
}
@Override
class="kw">public V getValue() {
class="kw">return this.val;
}
@Override
class="kw">public String toString() {
class="kw">return this.empty ? "EMPTY=" + this.val : this.key + "=" + this.val;
}
@Override
class="kw">public boolean equals(Object var1) {
if (this == var1) {
class="kw">return true;
}
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.Entry) {
if (this.empty != ((Double2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
class="kw">return false;
} else {
class="kw">return !this.empty && this.key != ((Double2ObjectConcurrentHashMap.Entry)var1).getDoubleKey()
? false
: this.val.equals(((Double2ObjectConcurrentHashMap.Entry)var1).getValue());
}
} else {
class="kw">return false;
}
}
@Override
class="kw">public int hashCode() {
int var1 = this.empty ? 1 : 0;
var1 = 31 * var1 + Double.hashCode(this.key);
class="kw">return 31 * var1 + this.val.hashCode();
}
@Override
class="kw">public V setValue(V var1) {
if (var1 == null) {
throw new NullPointerException();
}
Object var2 = this.val;
this.val = var1;
this.map.put(this.key, var1);
class="kw">return var2;
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceEntriesTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> transformer;
class="kw">public class="kw">final BiFunction<? super U, ? super U, ? class="kw">extends U> reducer;
class="kw">public U result;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> nextRight;
class="kw">public MapReduceEntriesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> var6,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var7,
BiFunction<? super U, ? super U, ? class="kw">extends U> var8
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.reducer = var8;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.transformer;
if (this.transformer != null) {
BiFunction var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceEntriesTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Double2ObjectConcurrentHashMap.Node var10;
while ((var10 = this.advance()) != null) {
Object var12;
if ((var12 = (U)var1.apply(var10)) != null) {
var9 = var9 == null ? var12 : var2.apply(var9, var12);
}
}
this.result = var9;
for (CountedCompleter var11 = this.firstComplete(); var11 != null; var11 = var11.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceEntriesTask var13 = (Double2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U>)var11;
for (Double2ObjectConcurrentHashMap.MapReduceEntriesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) {
Object var8 = var6.result;
if (var6.result != null) {
Object var7 = var13.result;
var13.result = var13.result == null ? var8 : var2.apply(var7, var8);
}
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceEntriesToDoubleTask<V> class="kw">extends Double2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> nextRight;
class="kw">public MapReduceEntriesToDoubleTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
double var8,
DoubleBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Double getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.ToDoubleFunction var1 = this.transformer;
if (this.transformer != null) {
DoubleBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
double var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsDouble(var3, var1.applyAsDouble(var8));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask var10 = (Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsDouble(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceEntriesToIntTask<V> class="kw">extends Double2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> nextRight;
class="kw">public MapReduceEntriesToIntTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> var6,
ToIntFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
int var8,
IntBinaryOperator var9
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var9;
}
class="kw">public class="kw">final Integer getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
ToIntFunction var1 = this.transformer;
if (this.transformer != null) {
IntBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.basis;
int var4 = this.baseIndex;
while (this.batch > 0) {
int var5 = this.baseLimit;
int var6;
if ((var6 = this.baseLimit + var4 >>> 1) <= var4) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<>(
this, this.batch >>>= 1, this.baseLimit = var6, var5, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var7 = this.advance()) != null) {
var3 = var2.applyAsInt(var3, var1.applyAsInt(var7));
}
this.result = var3;
for (CountedCompleter var8 = this.firstComplete(); var8 != null; var8 = var8.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask var9 = (Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V>)var8;
for (Double2ObjectConcurrentHashMap.MapReduceEntriesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) {
var9.result = var2.applyAsInt(var9.result, var10.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceEntriesToLongTask<V> class="kw">extends Double2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> nextRight;
class="kw">public MapReduceEntriesToLongTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> var6,
ToLongFunction<Double2ObjectConcurrentHashMap.Entry<V>> var7,
long var8,
LongBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Long getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
ToLongFunction var1 = this.transformer;
if (this.transformer != null) {
LongBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
long var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsLong(var3, var1.applyAsLong(var8));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask var10 = (Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceEntriesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsLong(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceKeysTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> transformer;
class="kw">public class="kw">final BiFunction<? super U, ? super U, ? class="kw">extends U> reducer;
class="kw">public U result;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> nextRight;
class="kw">public MapReduceKeysTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> var6,
Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var7,
BiFunction<? super U, ? super U, ? class="kw">extends U> var8
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.reducer = var8;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleFunction var1 = this.transformer;
if (this.transformer != null) {
BiFunction var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceKeysTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Double2ObjectConcurrentHashMap.Node var10;
while ((var10 = this.advance()) != null) {
Object var12;
if ((var12 = (U)var1.apply(var10.key)) != null) {
var9 = var9 == null ? var12 : var2.apply(var9, var12);
}
}
this.result = var9;
for (CountedCompleter var11 = this.firstComplete(); var11 != null; var11 = var11.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceKeysTask var13 = (Double2ObjectConcurrentHashMap.MapReduceKeysTask<V, U>)var11;
for (Double2ObjectConcurrentHashMap.MapReduceKeysTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) {
Object var8 = var6.result;
if (var6.result != null) {
Object var7 = var13.result;
var13.result = var13.result == null ? var8 : var2.apply(var7, var8);
}
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceKeysToDoubleTask<V> class="kw">extends Double2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleToDoubleFunction transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> nextRight;
class="kw">public MapReduceKeysToDoubleTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToDoubleFunction var7,
double var8,
DoubleBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Double getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleToDoubleFunction var1 = this.transformer;
if (this.transformer != null) {
DoubleBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
double var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsDouble(var3, var1.applyAsDouble(var8.key));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask var10 = (Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsDouble(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceKeysToIntTask<V> class="kw">extends Double2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleToIntFunction transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> nextRight;
class="kw">public MapReduceKeysToIntTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToIntFunction var7,
int var8,
IntBinaryOperator var9
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var9;
}
class="kw">public class="kw">final Integer getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleToIntFunction var1 = this.transformer;
if (this.transformer != null) {
IntBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.basis;
int var4 = this.baseIndex;
while (this.batch > 0) {
int var5 = this.baseLimit;
int var6;
if ((var6 = this.baseLimit + var4 >>> 1) <= var4) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<>(
this, this.batch >>>= 1, this.baseLimit = var6, var5, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var7 = this.advance()) != null) {
var3 = var2.applyAsInt(var3, var1.applyAsInt(var7.key));
}
this.result = var3;
for (CountedCompleter var8 = this.firstComplete(); var8 != null; var8 = var8.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask var9 = (Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V>)var8;
for (Double2ObjectConcurrentHashMap.MapReduceKeysToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) {
var9.result = var2.applyAsInt(var9.result, var10.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceKeysToLongTask<V> class="kw">extends Double2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleToLongFunction transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> nextRight;
class="kw">public MapReduceKeysToLongTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> var6,
Double2ObjectConcurrentHashMap.DoubleToLongFunction var7,
long var8,
LongBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Long getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleToLongFunction var1 = this.transformer;
if (this.transformer != null) {
LongBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
long var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsLong(var3, var1.applyAsLong(var8.key));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask var10 = (Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceKeysToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsLong(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceMappingsTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> transformer;
class="kw">public class="kw">final BiFunction<? super U, ? super U, ? class="kw">extends U> reducer;
class="kw">public U result;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> nextRight;
class="kw">public MapReduceMappingsTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> var6,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var7,
BiFunction<? super U, ? super U, ? class="kw">extends U> var8
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.reducer = var8;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleObjFunction var1 = this.transformer;
if (this.transformer != null) {
BiFunction var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceMappingsTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Double2ObjectConcurrentHashMap.Node var10;
while ((var10 = this.advance()) != null) {
Object var12;
if ((var12 = (U)var1.apply(var10.key, var10.val)) != null) {
var9 = var9 == null ? var12 : var2.apply(var9, var12);
}
}
this.result = var9;
for (CountedCompleter var11 = this.firstComplete(); var11 != null; var11 = var11.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceMappingsTask var13 = (Double2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U>)var11;
for (Double2ObjectConcurrentHashMap.MapReduceMappingsTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) {
Object var8 = var6.result;
if (var6.result != null) {
Object var7 = var13.result;
var13.result = var13.result == null ? var8 : var2.apply(var7, var8);
}
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceMappingsToDoubleTask<V> class="kw">extends Double2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction<? super V> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> nextRight;
class="kw">public MapReduceMappingsToDoubleTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Double getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.ToDoubleDoubleObjFunction var1 = this.transformer;
if (this.transformer != null) {
DoubleBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
double var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsDouble(var3, var1.applyAsDouble(var8.key, var8.val));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask var10 = (Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsDouble(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceMappingsToIntTask<V> class="kw">extends Double2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction<? super V> transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> nextRight;
class="kw">public MapReduceMappingsToIntTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> var6,
Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction<? super V> var7,
int var8,
IntBinaryOperator var9
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var9;
}
class="kw">public class="kw">final Integer getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.ToIntDoubleObjFunction var1 = this.transformer;
if (this.transformer != null) {
IntBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.basis;
int var4 = this.baseIndex;
while (this.batch > 0) {
int var5 = this.baseLimit;
int var6;
if ((var6 = this.baseLimit + var4 >>> 1) <= var4) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<>(
this, this.batch >>>= 1, this.baseLimit = var6, var5, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var7 = this.advance()) != null) {
var3 = var2.applyAsInt(var3, var1.applyAsInt(var7.key, var7.val));
}
this.result = var3;
for (CountedCompleter var8 = this.firstComplete(); var8 != null; var8 = var8.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask var9 = (Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V>)var8;
for (Double2ObjectConcurrentHashMap.MapReduceMappingsToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) {
var9.result = var2.applyAsInt(var9.result, var10.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceMappingsToLongTask<V> class="kw">extends Double2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction<? super V> transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> nextRight;
class="kw">public MapReduceMappingsToLongTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> var6,
Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction<? super V> var7,
long var8,
LongBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Long getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.ToLongDoubleObjFunction var1 = this.transformer;
if (this.transformer != null) {
LongBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
long var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsLong(var3, var1.applyAsLong(var8.key, var8.val));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask var10 = (Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceMappingsToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsLong(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceValuesTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<? super V, ? class="kw">extends U> transformer;
class="kw">public class="kw">final BiFunction<? super U, ? super U, ? class="kw">extends U> reducer;
class="kw">public U result;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> nextRight;
class="kw">public MapReduceValuesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> var6,
Function<? super V, ? class="kw">extends U> var7,
BiFunction<? super U, ? super U, ? class="kw">extends U> var8
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.reducer = var8;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.transformer;
if (this.transformer != null) {
BiFunction var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceValuesTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Double2ObjectConcurrentHashMap.Node var10;
while ((var10 = this.advance()) != null) {
Object var12;
if ((var12 = (U)var1.apply(var10.val)) != null) {
var9 = var9 == null ? var12 : var2.apply(var9, var12);
}
}
this.result = var9;
for (CountedCompleter var11 = this.firstComplete(); var11 != null; var11 = var11.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceValuesTask var13 = (Double2ObjectConcurrentHashMap.MapReduceValuesTask<V, U>)var11;
for (Double2ObjectConcurrentHashMap.MapReduceValuesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) {
Object var8 = var6.result;
if (var6.result != null) {
Object var7 = var13.result;
var13.result = var13.result == null ? var8 : var2.apply(var7, var8);
}
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceValuesToDoubleTask<V> class="kw">extends Double2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.ToDoubleFunction<? super V> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> nextRight;
class="kw">public MapReduceValuesToDoubleTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> var6,
Double2ObjectConcurrentHashMap.ToDoubleFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Double getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.ToDoubleFunction var1 = this.transformer;
if (this.transformer != null) {
DoubleBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
double var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsDouble(var3, var1.applyAsDouble(var8.val));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask var10 = (Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsDouble(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceValuesToIntTask<V> class="kw">extends Double2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final ToIntFunction<? super V> transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> nextRight;
class="kw">public MapReduceValuesToIntTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> var6,
ToIntFunction<? super V> var7,
int var8,
IntBinaryOperator var9
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var9;
}
class="kw">public class="kw">final Integer getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
ToIntFunction var1 = this.transformer;
if (this.transformer != null) {
IntBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
int var3 = this.basis;
int var4 = this.baseIndex;
while (this.batch > 0) {
int var5 = this.baseLimit;
int var6;
if ((var6 = this.baseLimit + var4 >>> 1) <= var4) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<>(
this, this.batch >>>= 1, this.baseLimit = var6, var5, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var7 = this.advance()) != null) {
var3 = var2.applyAsInt(var3, var1.applyAsInt(var7.val));
}
this.result = var3;
for (CountedCompleter var8 = this.firstComplete(); var8 != null; var8 = var8.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask var9 = (Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V>)var8;
for (Double2ObjectConcurrentHashMap.MapReduceValuesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) {
var9.result = var2.applyAsInt(var9.result, var10.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class MapReduceValuesToLongTask<V> class="kw">extends Double2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final ToLongFunction<? super V> transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> nextRight;
class="kw">public MapReduceValuesToLongTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> var6,
ToLongFunction<? super V> var7,
long var8,
LongBinaryOperator var10
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.transformer = var7;
this.basis = var8;
this.reducer = var10;
}
class="kw">public class="kw">final Long getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
ToLongFunction var1 = this.transformer;
if (this.transformer != null) {
LongBinaryOperator var2 = this.reducer;
if (this.reducer != null) {
long var3 = this.basis;
int var5 = this.baseIndex;
while (this.batch > 0) {
int var6 = this.baseLimit;
int var7;
if ((var7 = this.baseLimit + var5 >>> 1) <= var5) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<>(
this, this.batch >>>= 1, this.baseLimit = var7, var6, this.tab, this.rights, var1, var3, var2
))
.fork();
}
while ((var8 = this.advance()) != null) {
var3 = var2.applyAsLong(var3, var1.applyAsLong(var8.val));
}
this.result = var3;
for (CountedCompleter var9 = this.firstComplete(); var9 != null; var9 = var9.nextComplete()) {
Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask var10 = (Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V>)var9;
for (Double2ObjectConcurrentHashMap.MapReduceValuesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) {
var10.result = var2.applyAsLong(var10.result, var11.result);
}
}
}
}
}
}
class="kw">protected class="kw">static class Node<V> class="kw">implements Double2ObjectConcurrentHashMap.Entry<V> {
class="kw">public class="kw">final double EMPTY;
class="kw">public class="kw">final int hash;
class="kw">public class="kw">final double key;
class="kw">public class="kw">volatile V val;
class="kw">public class="kw">volatile Double2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Node(double var1, int var3, double var4, V var6, Double2ObjectConcurrentHashMap.Node<V> var7) {
this.EMPTY = var1;
this.hash = var3;
this.key = var4;
this.val = var6;
this.next = var7;
}
@Override
class="kw">public class="kw">final boolean isEmpty() {
class="kw">return this.key == this.EMPTY;
}
@Override
class="kw">public class="kw">final Double getKey() {
class="kw">return this.key;
}
@Override
class="kw">public class="kw">final double getDoubleKey() {
class="kw">return this.key;
}
@Override
class="kw">public class="kw">final V getValue() {
class="kw">return this.val;
}
@Override
class="kw">public class="kw">final int hashCode() {
class="kw">return Double.hashCode(this.key) ^ this.val.hashCode();
}
@Override
class="kw">public class="kw">final String toString() {
class="kw">return this.isEmpty() ? "EMPTY=" + this.val : this.key + "=" + this.val;
}
@Override
class="kw">public class="kw">final V setValue(V var1) {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final boolean equals(Object var1) {
boolean var2 = this.isEmpty();
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.Entry) {
if (var2 != ((Double2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
class="kw">return false;
} else {
class="kw">return !var2 && this.key != ((Double2ObjectConcurrentHashMap.Entry)var1).getDoubleKey()
? false
: this.val.equals(((Double2ObjectConcurrentHashMap.Entry)var1).getValue());
}
} else {
class="kw">return false;
}
}
class="kw">protected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) {
Double2ObjectConcurrentHashMap.Node var4 = this;
if (var2 != this.EMPTY) {
do {
if (var4.hash == var1) {
double var5 = var4.key;
if (var4.key == var2 || var5 != this.EMPTY && var2 == var5) {
class="kw">return var4;
}
}
} while ((var4 = var4.next) != null);
}
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class ReduceEntriesTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, Double2ObjectConcurrentHashMap.Entry<V>> {
class="kw">public class="kw">final BiFunction<Double2ObjectConcurrentHashMap.Entry<V>, Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Double2ObjectConcurrentHashMap.Entry<V>> reducer;
class="kw">public Double2ObjectConcurrentHashMap.Entry<V> result;
class="kw">public Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> nextRight;
class="kw">public ReduceEntriesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.ReduceEntriesTask<V> var6,
BiFunction<Double2ObjectConcurrentHashMap.Entry<V>, Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Double2ObjectConcurrentHashMap.Entry<V>> var7
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.reducer = var7;
}
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.Entry<V> getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
BiFunction var1 = this.reducer;
if (this.reducer != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.ReduceEntriesTask<>(
this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
Double2ObjectConcurrentHashMap.Entry var8 = null;
Double2ObjectConcurrentHashMap.Node var9;
while ((var9 = this.advance()) != null) {
var8 = var8 == null ? var9 : var1.apply(var8, var9);
}
this.result = var8;
for (CountedCompleter var10 = this.firstComplete(); var10 != null; var10 = var10.nextComplete()) {
Double2ObjectConcurrentHashMap.ReduceEntriesTask var11 = (Double2ObjectConcurrentHashMap.ReduceEntriesTask<V>)var10;
for (Double2ObjectConcurrentHashMap.ReduceEntriesTask var5 = var11.rights; var5 != null; var5 = var11.rights = var5.nextRight) {
Double2ObjectConcurrentHashMap.Entry var7 = var5.result;
if (var5.result != null) {
Double2ObjectConcurrentHashMap.Entry var6 = var11.result;
var11.result = var11.result == null ? var7 : var1.apply(var6, var7);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ReduceKeysTask<V> class="kw">extends Double2ObjectConcurrentHashMap.DoubleReturningBulkTask2<V> {
class="kw">public class="kw">final double EMPTY;
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator reducer;
class="kw">public Double2ObjectConcurrentHashMap.ReduceKeysTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.ReduceKeysTask<V> nextRight;
class="kw">public ReduceKeysTask(
double var1,
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var3,
int var4,
int var5,
int var6,
Double2ObjectConcurrentHashMap.Node<V>[] var7,
Double2ObjectConcurrentHashMap.ReduceKeysTask<V> var8,
Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator var9
) {
super(var3, var4, var5, var6, var7);
this.nextRight = var8;
this.EMPTY = var1;
this.reducer = var9;
}
class="kw">public class="kw">final Double getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleReduceTaskOperator var1 = this.reducer;
if (this.reducer != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.ReduceKeysTask<>(
this.EMPTY, this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
boolean var12 = false;
double var13 = this.EMPTY;
Double2ObjectConcurrentHashMap.Node var5;
while ((var5 = this.advance()) != null) {
double var6 = var5.key;
if (!var12) {
var12 = true;
var13 = var6;
} else if (!var5.isEmpty()) {
var12 = true;
var13 = var1.reduce(this.EMPTY, var13, var6);
}
}
this.result = var13;
for (CountedCompleter var14 = this.firstComplete(); var14 != null; var14 = var14.nextComplete()) {
Double2ObjectConcurrentHashMap.ReduceKeysTask var15 = (Double2ObjectConcurrentHashMap.ReduceKeysTask<V>)var14;
for (Double2ObjectConcurrentHashMap.ReduceKeysTask var7 = var15.rights; var7 != null; var7 = var15.rights = var7.nextRight) {
double var10 = var7.result;
if (var7.result != this.EMPTY) {
double var8 = var15.result;
var15.result = var15.result == this.EMPTY ? var10 : var1.reduce(this.EMPTY, var8, var10);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ReduceValuesTask<V> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, V> {
class="kw">public class="kw">final BiFunction<? super V, ? super V, ? class="kw">extends V> reducer;
class="kw">public V result;
class="kw">public Double2ObjectConcurrentHashMap.ReduceValuesTask<V> rights;
class="kw">public Double2ObjectConcurrentHashMap.ReduceValuesTask<V> nextRight;
class="kw">public ReduceValuesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.ReduceValuesTask<V> var6,
BiFunction<? super V, ? super V, ? class="kw">extends V> var7
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.reducer = var7;
}
@Override
class="kw">public class="kw">final V getRawResult() {
class="kw">return this.result;
}
@Override
class="kw">public class="kw">final void compute() {
BiFunction var1 = this.reducer;
if (this.reducer != null) {
int var2 = this.baseIndex;
while (this.batch > 0) {
int var3 = this.baseLimit;
int var4;
if ((var4 = this.baseLimit + var2 >>> 1) <= var2) {
break;
}
this.addToPendingCount(1);
(this.rights = new Double2ObjectConcurrentHashMap.ReduceValuesTask<>(
this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
Object var8 = null;
Double2ObjectConcurrentHashMap.Node var9;
while ((var9 = this.advance()) != null) {
Object var11 = var9.val;
var8 = var8 == null ? var11 : var1.apply(var8, var11);
}
this.result = var8;
for (CountedCompleter var10 = this.firstComplete(); var10 != null; var10 = var10.nextComplete()) {
Double2ObjectConcurrentHashMap.ReduceValuesTask var12 = (Double2ObjectConcurrentHashMap.ReduceValuesTask<V>)var10;
for (Double2ObjectConcurrentHashMap.ReduceValuesTask var5 = var12.rights; var5 != null; var5 = var12.rights = var5.nextRight) {
Object var7 = var5.result;
if (var5.result != null) {
Object var6 = var12.result;
var12.result = var12.result == null ? var7 : var1.apply(var6, var7);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ReservationNode<V> class="kw">extends Double2ObjectConcurrentHashMap.Node<V> {
class="kw">public ReservationNode(double var1) {
super(var1, -3, var1, null, null);
}
@Override
class="kw">protected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) {
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class SearchEntriesTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchEntriesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Double2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var6,
AtomicReference<U> var7
) {
super(var1, var2, var3, var4, var5);
this.searchFunction = var6;
this.result = var7;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result.get();
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.searchFunction;
if (this.searchFunction != null) {
AtomicReference var2 = this.result;
if (this.result != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
if (var2.get() != null) {
class="kw">return;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.SearchEntriesTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Double2ObjectConcurrentHashMap.Node var7;
if ((var7 = this.advance()) == null) {
this.propagateCompletion();
break;
}
Object var6;
if ((var6 = (U)var1.apply(var7)) != null) {
if (var2.compareAndSet(null, var6)) {
this.quietlyCompleteRoot();
}
class="kw">return;
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class SearchKeysTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchKeysTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleFunction<? class="kw">extends U> var6,
AtomicReference<U> var7
) {
super(var1, var2, var3, var4, var5);
this.searchFunction = var6;
this.result = var7;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result.get();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleFunction var1 = this.searchFunction;
if (this.searchFunction != null) {
AtomicReference var2 = this.result;
if (this.result != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
if (var2.get() != null) {
class="kw">return;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.SearchKeysTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Double2ObjectConcurrentHashMap.Node var7;
if ((var7 = this.advance()) == null) {
this.propagateCompletion();
break;
}
Object var6;
if ((var6 = (U)var1.apply(var7.key)) != null) {
if (var2.compareAndSet(null, var6)) {
this.quietlyCompleteRoot();
}
break;
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class SearchMappingsTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchMappingsTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Double2ObjectConcurrentHashMap.DoubleObjFunction<? super V, ? class="kw">extends U> var6,
AtomicReference<U> var7
) {
super(var1, var2, var3, var4, var5);
this.searchFunction = var6;
this.result = var7;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result.get();
}
@Override
class="kw">public class="kw">final void compute() {
Double2ObjectConcurrentHashMap.DoubleObjFunction var1 = this.searchFunction;
if (this.searchFunction != null) {
AtomicReference var2 = this.result;
if (this.result != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
if (var2.get() != null) {
class="kw">return;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.SearchMappingsTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Double2ObjectConcurrentHashMap.Node var7;
if ((var7 = this.advance()) == null) {
this.propagateCompletion();
break;
}
Object var6;
if ((var6 = (U)var1.apply(var7.key, var7.val)) != null) {
if (var2.compareAndSet(null, var6)) {
this.quietlyCompleteRoot();
}
break;
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class SearchValuesTask<V, U> class="kw">extends Double2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<? super V, ? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchValuesTask(
Double2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Double2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? class="kw">extends U> var6,
AtomicReference<U> var7
) {
super(var1, var2, var3, var4, var5);
this.searchFunction = var6;
this.result = var7;
}
@Override
class="kw">public class="kw">final U getRawResult() {
class="kw">return this.result.get();
}
@Override
class="kw">public class="kw">final void compute() {
Function var1 = this.searchFunction;
if (this.searchFunction != null) {
AtomicReference var2 = this.result;
if (this.result != null) {
int var3 = this.baseIndex;
while (this.batch > 0) {
int var4 = this.baseLimit;
int var5;
if ((var5 = this.baseLimit + var3 >>> 1) <= var3) {
break;
}
if (var2.get() != null) {
class="kw">return;
}
this.addToPendingCount(1);
new Double2ObjectConcurrentHashMap.SearchValuesTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Double2ObjectConcurrentHashMap.Node var7;
if ((var7 = this.advance()) == null) {
this.propagateCompletion();
break;
}
Object var6;
if ((var6 = (U)var1.apply(var7.val)) != null) {
if (var2.compareAndSet(null, var6)) {
this.quietlyCompleteRoot();
}
break;
}
}
}
}
}
}
class="kw">protected class="kw">static class Segment<V> class="kw">extends ReentrantLock class="kw">implements Serializable {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 2249069246763182397L;
class="kw">public class="kw">final float loadFactor;
class="kw">public Segment(float var1) {
this.loadFactor = var1;
}
}
class="kw">protected class="kw">static class="kw">final class TableStack<V> {
class="kw">public int length;
class="kw">public int index;
class="kw">public Double2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> next;
class="kw">public TableStack() {
}
}
@FunctionalInterface
class="kw">public class="kw">interface ToDoubleDoubleObjFunction<V> {
double applyAsDouble(double var1, V var3);
}
@FunctionalInterface
class="kw">public class="kw">interface ToDoubleFunction<T> {
double applyAsDouble(T var1);
}
@FunctionalInterface
class="kw">public class="kw">interface ToIntDoubleObjFunction<V> {
int applyAsInt(double var1, V var3);
}
@FunctionalInterface
class="kw">public class="kw">interface ToLongDoubleObjFunction<V> {
long applyAsLong(double var1, V var3);
}
class="kw">protected class="kw">static class Traverser<V> {
class="kw">public Double2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Double2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Double2ObjectConcurrentHashMap.TableStack<V> spare;
class="kw">public int index;
class="kw">public int baseIndex;
class="kw">public int baseLimit;
class="kw">public class="kw">final int baseSize;
class="kw">public Traverser(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4) {
this.tab = var1;
this.baseSize = var2;
this.baseIndex = this.index = var3;
this.baseLimit = var4;
this.next = null;
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V> advance() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next != null) {
var1 = var1.next;
}
while (true) {
if (var1 != null) {
class="kw">return this.next = var1;
}
if (this.baseIndex >= this.baseLimit) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.tab;
if (this.tab == null) {
break;
}
int var4;
int var10000 = var4 = var2.length;
int var3 = this.index;
if (var10000 <= this.index || var3 < 0) {
break;
}
if ((var1 = Double2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Double2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Double2ObjectConcurrentHashMap.TreeBin)var1).first;
} else {
var1 = null;
}
}
if (this.stack != null) {
this.recoverState(var4);
} else if ((this.index = var3 + this.baseSize) >= var4) {
this.index = ++this.baseIndex;
}
}
class="kw">return this.next = null;
}
class="kw">protected void pushState(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Double2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var4.tab = var1;
var4.length = var3;
var4.index = var2;
var4.next = this.stack;
this.stack = var4;
}
class="kw">protected void recoverState(int var1) {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var2 = this.stack;
if (this.stack != null) {
int var3 = var2.length;
if ((this.index = this.index + var2.length) >= var1) {
var1 = var3;
this.index = var2.index;
this.tab = var2.tab;
var2.tab = null;
Double2ObjectConcurrentHashMap.TableStack var4 = var2.next;
var2.next = this.spare;
this.stack = var4;
this.spare = var2;
class="kw">continue;
}
}
if (var2 == null && (this.index = this.index + this.baseSize) >= var1) {
this.index = ++this.baseIndex;
}
class="kw">return;
}
}
}
class="kw">protected class="kw">static class="kw">final class TreeBin<V> class="kw">extends Double2ObjectConcurrentHashMap.Node<V> {
class="kw">public Double2ObjectConcurrentHashMap.TreeNode<V> root;
class="kw">public class="kw">volatile Double2ObjectConcurrentHashMap.TreeNode<V> first;
class="kw">public class="kw">volatile Thread waiter;
class="kw">public class="kw">volatile int lockState;
class="kw">public class="kw">static class="kw">final int WRITER = 1;
class="kw">public class="kw">static class="kw">final int WAITER = 2;
class="kw">public class="kw">static class="kw">final int READER = 4;
class="kw">protected class="kw">static class="kw">final Unsafe U;
class="kw">protected class="kw">static class="kw">final long LOCKSTATE;
class="kw">protected int tieBreakOrder(double var1, double var3) {
int var5 = Double.compare(var1, var3);
class="kw">return var5 > 0 ? 1 : -1;
}
class="kw">public TreeBin(double var1, Double2ObjectConcurrentHashMap.TreeNode<V> var3) {
super(var1, -2, var1, null, null);
this.first = var3;
Double2ObjectConcurrentHashMap.TreeNode var4 = null;
Double2ObjectConcurrentHashMap.TreeNode var5 = var3;
while (var5 != null) {
Double2ObjectConcurrentHashMap.TreeNode var6 = (Double2ObjectConcurrentHashMap.TreeNode<V>)var5.next;
var5.left = var5.right = null;
if (var4 == null) {
var5.parent = null;
var5.red = false;
var4 = var5;
} else {
double var7 = var5.key;
int var9 = var5.hash;
Class var10 = null;
Double2ObjectConcurrentHashMap.TreeNode var11 = var4;
int var12;
Double2ObjectConcurrentHashMap.TreeNode var16;
do {
double var14 = var11.key;
int var13 = var11.hash;
if (var11.hash > var9) {
var12 = -1;
} else if (var13 < var9) {
var12 = 1;
} else if ((var12 = Double.compare(var7, var14)) == 0) {
var12 = this.tieBreakOrder(var7, var14);
}
var16 = var11;
} while ((var11 = var12 <= 0 ? var11.left : var11.right) != null);
var5.parent = var16;
if (var12 <= 0) {
var16.left = var5;
} else {
var16.right = var5;
}
var4 = this.balanceInsertion(var4, var5);
}
var5 = var6;
}
this.root = var4;
assert this.checkInvariants(this.root);
}
class="kw">protected class="kw">final void lockRoot() {
if (!U.compareAndSwapInt(this, LOCKSTATE, 0, 1)) {
this.contendedLock();
}
}
class="kw">protected class="kw">final void unlockRoot() {
this.lockState = 0;
}
class="kw">protected class="kw">final void contendedLock() {
boolean var1 = false;
while (true) {
int var2 = this.lockState;
if ((this.lockState & -3) == 0) {
if (U.compareAndSwapInt(this, LOCKSTATE, var2, 1)) {
if (var1) {
this.waiter = null;
}
class="kw">return;
}
} else if ((var2 & 2) == 0) {
if (U.compareAndSwapInt(this, LOCKSTATE, var2, var2 | 2)) {
var1 = true;
this.waiter = Thread.currentThread();
}
} else if (var1) {
LockSupport.park(this);
}
}
}
@Override
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) {
if (var2 != this.EMPTY) {
Double2ObjectConcurrentHashMap.Node var4 = this.first;
while (var4 != null) {
int var5 = this.lockState;
if ((this.lockState & 3) != 0) {
if (var4.hash == var1) {
double var6 = var4.key;
if (var4.key == var2 || var6 != this.EMPTY && var2 == var6) {
class="kw">return var4;
}
}
var4 = var4.next;
} else if (U.compareAndSwapInt(this, LOCKSTATE, var5, var5 + 4)) {
Double2ObjectConcurrentHashMap.TreeNode var9;
try {
Double2ObjectConcurrentHashMap.TreeNode var8 = this.root;
var9 = this.root == null ? null : var8.findTreeNode(var1, var2, null);
} class="kw">finally {
if (U.getAndAddInt(this, LOCKSTATE, -4) == 6) {
Thread var12 = this.waiter;
if (this.waiter != null) {
LockSupport.unpark(var12);
}
}
}
class="kw">return var9;
}
}
}
class="kw">return null;
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.TreeNode<V> putTreeVal(int var1, double var2, V var4) {
Class var5 = null;
boolean var6 = false;
Double2ObjectConcurrentHashMap.TreeNode var7 = this.root;
while (true) {
if (var7 == null) {
this.first = this.root = new Double2ObjectConcurrentHashMap.TreeNode<>(this.EMPTY, var1, var2, var4, null, null);
} else {
int var9 = var7.hash;
int var8;
if (var7.hash > var1) {
var8 = -1;
} else if (var9 < var1) {
var8 = 1;
} else {
double var10 = var7.key;
if (var7.key == var2 || var10 != this.EMPTY && var2 == var10) {
class="kw">return var7;
}
if ((var8 = Double.compare(var2, var10)) == 0) {
if (!var6) {
var6 = true;
Double2ObjectConcurrentHashMap.TreeNode var13 = var7.left;
Double2ObjectConcurrentHashMap.TreeNode var12;
if (var7.left != null && (var12 = var13.findTreeNode(var1, var2, var5)) != null) {
class="kw">return var12;
}
var13 = var7.right;
if (var7.right != null && (var12 = var13.findTreeNode(var1, var2, var5)) != null) {
class="kw">return var12;
}
}
var8 = this.tieBreakOrder(var2, var10);
}
}
Double2ObjectConcurrentHashMap.TreeNode var18 = var7;
if ((var7 = var8 <= 0 ? var7.left : var7.right) != null) {
class="kw">continue;
}
Double2ObjectConcurrentHashMap.TreeNode var14 = this.first;
Double2ObjectConcurrentHashMap.TreeNode var20;
this.first = var20 = new Double2ObjectConcurrentHashMap.TreeNode<>(this.EMPTY, var1, var2, var4, var14, var18);
if (var14 != null) {
var14.prev = var20;
}
if (var8 <= 0) {
var18.left = var20;
} else {
var18.right = var20;
}
if (!var18.red) {
var20.red = true;
} else {
this.lockRoot();
try {
this.root = this.balanceInsertion(this.root, var20);
} class="kw">finally {
this.unlockRoot();
}
}
}
assert this.checkInvariants(this.root);
class="kw">return null;
}
}
class="kw">protected class="kw">final boolean removeTreeNode(Double2ObjectConcurrentHashMap.TreeNode<V> var1) {
Double2ObjectConcurrentHashMap.TreeNode var2 = (Double2ObjectConcurrentHashMap.TreeNode<V>)var1.next;
Double2ObjectConcurrentHashMap.TreeNode var3 = var1.prev;
if (var3 == null) {
this.first = var2;
} else {
var3.next = var2;
}
if (var2 != null) {
var2.prev = var3;
}
if (this.first == null) {
this.root = null;
class="kw">return true;
}
Double2ObjectConcurrentHashMap.TreeNode var4 = this.root;
if (this.root != null && var4.right != null) {
Double2ObjectConcurrentHashMap.TreeNode var5 = var4.left;
if (var4.left != null && var5.left != null) {
this.lockRoot();
try {
Double2ObjectConcurrentHashMap.TreeNode var7 = var1.left;
Double2ObjectConcurrentHashMap.TreeNode var8 = var1.right;
Double2ObjectConcurrentHashMap.TreeNode var6;
if (var7 != null && var8 != null) {
Double2ObjectConcurrentHashMap.TreeNode var9 = var8;
while (true) {
Double2ObjectConcurrentHashMap.TreeNode var10 = var9.left;
if (var9.left == null) {
boolean var11 = var9.red;
var9.red = var1.red;
var1.red = var11;
Double2ObjectConcurrentHashMap.TreeNode var12 = var9.right;
Double2ObjectConcurrentHashMap.TreeNode var13 = var1.parent;
if (var9 == var8) {
var1.parent = var9;
var9.right = var1;
} else {
Double2ObjectConcurrentHashMap.TreeNode var14 = var9.parent;
if ((var1.parent = var14) != null) {
if (var9 == var14.left) {
var14.left = var1;
} else {
var14.right = var1;
}
}
if ((var9.right = var8) != null) {
var8.parent = var9;
}
}
var1.left = null;
if ((var1.right = var12) != null) {
var12.parent = var1;
}
if ((var9.left = var7) != null) {
var7.parent = var9;
}
if ((var9.parent = var13) == null) {
var4 = var9;
} else if (var1 == var13.left) {
var13.left = var9;
} else {
var13.right = var9;
}
if (var12 != null) {
var6 = var12;
} else {
var6 = var1;
}
break;
}
var9 = var10;
}
} else if (var7 != null) {
var6 = var7;
} else if (var8 != null) {
var6 = var8;
} else {
var6 = var1;
}
if (var6 != var1) {
Double2ObjectConcurrentHashMap.TreeNode var18 = var6.parent = var1.parent;
if (var18 == null) {
var4 = var6;
} else if (var1 == var18.left) {
var18.left = var6;
} else {
var18.right = var6;
}
var1.left = var1.right = var1.parent = null;
}
this.root = var1.red ? var4 : this.balanceDeletion(var4, var6);
if (var1 == var6) {
Double2ObjectConcurrentHashMap.TreeNode var19 = var1.parent;
if (var1.parent != null) {
if (var1 == var19.left) {
var19.left = null;
} else if (var1 == var19.right) {
var19.right = null;
}
var1.parent = null;
}
}
} class="kw">finally {
this.unlockRoot();
}
assert this.checkInvariants(this.root);
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> rotateLeft(
Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2
) {
if (var2 != null) {
Double2ObjectConcurrentHashMap.TreeNode var3 = var2.right;
if (var2.right != null) {
Double2ObjectConcurrentHashMap.TreeNode var5;
if ((var5 = var2.right = var3.left) != null) {
var5.parent = var2;
}
Double2ObjectConcurrentHashMap.TreeNode var4;
if ((var4 = var3.parent = var2.parent) == null) {
var1 = var3;
var3.red = false;
} else if (var4.left == var2) {
var4.left = var3;
} else {
var4.right = var3;
}
var3.left = var2;
var2.parent = var3;
}
}
class="kw">return var1;
}
class="kw">protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> rotateRight(
Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2
) {
if (var2 != null) {
Double2ObjectConcurrentHashMap.TreeNode var3 = var2.left;
if (var2.left != null) {
Double2ObjectConcurrentHashMap.TreeNode var5;
if ((var5 = var2.left = var3.right) != null) {
var5.parent = var2;
}
Double2ObjectConcurrentHashMap.TreeNode var4;
if ((var4 = var3.parent = var2.parent) == null) {
var1 = var3;
var3.red = false;
} else if (var4.right == var2) {
var4.right = var3;
} else {
var4.left = var3;
}
var3.right = var2;
var2.parent = var3;
}
}
class="kw">return var1;
}
class="kw">protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> balanceInsertion(
Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2
) {
var2.red = true;
while (true) {
Double2ObjectConcurrentHashMap.TreeNode var3 = var2.parent;
if (var2.parent == null) {
var2.red = false;
class="kw">return var2;
}
if (!var3.red) {
break;
}
Double2ObjectConcurrentHashMap.TreeNode var4 = var3.parent;
if (var3.parent == null) {
break;
}
Double2ObjectConcurrentHashMap.TreeNode var5 = var4.left;
if (var3 == var4.left) {
Double2ObjectConcurrentHashMap.TreeNode var6 = var4.right;
if (var4.right != null && var6.red) {
var6.red = false;
var3.red = false;
var4.red = true;
var2 = var4;
} else {
if (var2 == var3.right) {
var2 = var3;
var1 = this.rotateLeft(var1, var3);
var3 = var2.parent;
var4 = var2.parent == null ? null : var3.parent;
}
if (var3 != null) {
var3.red = false;
if (var4 != null) {
var4.red = true;
var1 = this.rotateRight(var1, var4);
}
}
}
} else if (var5 != null && var5.red) {
var5.red = false;
var3.red = false;
var4.red = true;
var2 = var4;
} else {
if (var2 == var3.left) {
var2 = var3;
var1 = this.rotateRight(var1, var3);
var3 = var2.parent;
var4 = var2.parent == null ? null : var3.parent;
}
if (var3 != null) {
var3.red = false;
if (var4 != null) {
var4.red = true;
var1 = this.rotateLeft(var1, var4);
}
}
}
}
class="kw">return var1;
}
class="kw">protected <V> Double2ObjectConcurrentHashMap.TreeNode<V> balanceDeletion(
Double2ObjectConcurrentHashMap.TreeNode<V> var1, Double2ObjectConcurrentHashMap.TreeNode<V> var2
) {
while (var2 != null && var2 != var1) {
Double2ObjectConcurrentHashMap.TreeNode var3 = var2.parent;
if (var2.parent == null) {
var2.red = false;
class="kw">return var2;
}
if (var2.red) {
var2.red = false;
class="kw">return var1;
}
Double2ObjectConcurrentHashMap.TreeNode var4 = var3.left;
if (var3.left == var2) {
Double2ObjectConcurrentHashMap.TreeNode var5 = var3.right;
if (var3.right != null && var5.red) {
var5.red = false;
var3.red = true;
var1 = this.rotateLeft(var1, var3);
var3 = var2.parent;
var5 = var2.parent == null ? null : var3.right;
}
if (var5 == null) {
var2 = var3;
} else {
Double2ObjectConcurrentHashMap.TreeNode var9 = var5.left;
Double2ObjectConcurrentHashMap.TreeNode var10 = var5.right;
if (var10 != null && var10.red || var9 != null && var9.red) {
if (var10 == null || !var10.red) {
if (var9 != null) {
var9.red = false;
}
var5.red = true;
var1 = this.rotateRight(var1, var5);
var3 = var2.parent;
var5 = var2.parent == null ? null : var3.right;
}
if (var5 != null) {
var5.red = var3 == null ? false : var3.red;
var10 = var5.right;
if (var5.right != null) {
var10.red = false;
}
}
if (var3 != null) {
var3.red = false;
var1 = this.rotateLeft(var1, var3);
}
var2 = var1;
} else {
var5.red = true;
var2 = var3;
}
}
} else {
if (var4 != null && var4.red) {
var4.red = false;
var3.red = true;
var1 = this.rotateRight(var1, var3);
var3 = var2.parent;
var4 = var2.parent == null ? null : var3.left;
}
if (var4 == null) {
var2 = var3;
} else {
Double2ObjectConcurrentHashMap.TreeNode var6 = var4.left;
Double2ObjectConcurrentHashMap.TreeNode var7 = var4.right;
if (var6 != null && var6.red || var7 != null && var7.red) {
if (var6 == null || !var6.red) {
if (var7 != null) {
var7.red = false;
}
var4.red = true;
var1 = this.rotateLeft(var1, var4);
var3 = var2.parent;
var4 = var2.parent == null ? null : var3.left;
}
if (var4 != null) {
var4.red = var3 == null ? false : var3.red;
var6 = var4.left;
if (var4.left != null) {
var6.red = false;
}
}
if (var3 != null) {
var3.red = false;
var1 = this.rotateRight(var1, var3);
}
var2 = var1;
} else {
var4.red = true;
var2 = var3;
}
}
}
}
class="kw">return var1;
}
class="kw">protected <V> boolean checkInvariants(Double2ObjectConcurrentHashMap.TreeNode<V> var1) {
Double2ObjectConcurrentHashMap.TreeNode var2 = var1.parent;
Double2ObjectConcurrentHashMap.TreeNode var3 = var1.left;
Double2ObjectConcurrentHashMap.TreeNode var4 = var1.right;
Double2ObjectConcurrentHashMap.TreeNode var5 = var1.prev;
Double2ObjectConcurrentHashMap.TreeNode var6 = (Double2ObjectConcurrentHashMap.TreeNode<V>)var1.next;
if (var5 != null && var5.next != var1) {
class="kw">return false;
}
if (var6 != null && var6.prev != var1) {
class="kw">return false;
}
if (var2 != null && var1 != var2.left && var1 != var2.right) {
class="kw">return false;
}
if (var3 == null || var3.parent == var1 && var3.hash <= var1.hash) {
if (var4 == null || var4.parent == var1 && var4.hash >= var1.hash) {
if (var1.red && var3 != null && var3.red && var4 != null && var4.red) {
class="kw">return false;
} else {
class="kw">return var3 != null && !this.checkInvariants(var3) ? false : var4 == null || this.checkInvariants(var4);
}
} else {
class="kw">return false;
}
} else {
class="kw">return false;
}
}
class="kw">static {
try {
Field var0 = Unsafe.class.getDeclaredField("theUnsafe");
var0.setAccessible(true);
U = (Unsafe)var0.get(null);
Class var1 = Double2ObjectConcurrentHashMap.TreeBin.class;
LOCKSTATE = U.objectFieldOffset(var1.getDeclaredField("lockState"));
} catch (Exception var2) {
throw new Error(var2);
}
}
}
class="kw">protected class="kw">static class="kw">final class TreeNode<V> class="kw">extends Double2ObjectConcurrentHashMap.Node<V> {
class="kw">public Double2ObjectConcurrentHashMap.TreeNode<V> parent;
class="kw">public Double2ObjectConcurrentHashMap.TreeNode<V> left;
class="kw">public Double2ObjectConcurrentHashMap.TreeNode<V> right;
class="kw">public Double2ObjectConcurrentHashMap.TreeNode<V> prev;
class="kw">public boolean red;
class="kw">public TreeNode(double var1, int var3, double var4, V var6, Double2ObjectConcurrentHashMap.Node<V> var7, Double2ObjectConcurrentHashMap.TreeNode<V> var8) {
super(var1, var3, var4, var6, var7);
this.parent = var8;
}
@Override
class="kw">protected Double2ObjectConcurrentHashMap.Node<V> find(int var1, double var2) {
class="kw">return this.findTreeNode(var1, var2, null);
}
class="kw">protected class="kw">final Double2ObjectConcurrentHashMap.TreeNode<V> findTreeNode(int var1, double var2, Class<?> var4) {
if (var2 != this.EMPTY) {
Double2ObjectConcurrentHashMap.TreeNode var5 = this;
do {
Double2ObjectConcurrentHashMap.TreeNode var11 = var5.left;
Double2ObjectConcurrentHashMap.TreeNode var12 = var5.right;
int var6 = var5.hash;
if (var5.hash > var1) {
var5 = var11;
} else if (var6 < var1) {
var5 = var12;
} else {
double var8 = var5.key;
if (var5.key == var2 || var8 != this.EMPTY && var2 == var8) {
class="kw">return var5;
}
if (var11 == null) {
var5 = var12;
} else if (var12 == null) {
var5 = var11;
} else {
int var7;
if ((var7 = Double.compare(var2, var8)) != 0) {
var5 = var7 < 0 ? var11 : var12;
} else {
Double2ObjectConcurrentHashMap.TreeNode var10;
if ((var10 = var12.findTreeNode(var1, var2, var4)) != null) {
class="kw">return var10;
}
var5 = var11;
}
}
}
} while (var5 != null);
}
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class ValueIterator<V> class="kw">extends Double2ObjectConcurrentHashMap.BaseIterator<V> class="kw">implements ObjectIterator<V>, Enumeration<V> {
class="kw">public ValueIterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Double2ObjectConcurrentHashMap<V> var5) {
super(var1, var2, var3, var4, var5);
}
class="kw">public class="kw">final V next() {
Double2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next == null) {
throw new NoSuchElementException();
}
Object var2 = var1.val;
this.lastReturned = var1;
this.advance();
class="kw">return var2;
}
@Override
class="kw">public class="kw">final V nextElement() {
class="kw">return this.next();
}
}
class="kw">protected class="kw">static class="kw">final class ValueSpliterator<V> class="kw">extends Double2ObjectConcurrentHashMap.Traverser<V> class="kw">implements ObjectSpliterator<V> {
class="kw">public long est;
class="kw">public ValueSpliterator(Double2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) {
super(var1, var2, var3, var4);
this.est = var5;
}
class="kw">public ObjectSpliterator<V> trySplit() {
int var1 = this.baseIndex;
int var2 = this.baseLimit;
int var3;
class="kw">return (var3 = this.baseIndex + this.baseLimit >>> 1) <= var1
? null
: new Double2ObjectConcurrentHashMap.ValueSpliterator<>(this.tab, this.baseSize, this.baseLimit = var3, var2, this.est >>>= 1);
}
class="kw">public void forEachRemaining(Consumer<? super V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
while ((var2 = this.advance()) != null) {
var1.accept(var2.val);
}
}
class="kw">public boolean tryAdvance(Consumer<? super V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node var2;
if ((var2 = this.advance()) == null) {
class="kw">return false;
}
var1.accept(var2.val);
class="kw">return true;
}
class="kw">public long estimateSize() {
class="kw">return this.est;
}
class="kw">public int characteristics() {
class="kw">return 4352;
}
}
class="kw">protected class="kw">static class="kw">final class ValuesView<V> class="kw">extends Double2ObjectConcurrentHashMap.CollectionView<V, V> class="kw">implements FastCollection<V>, Serializable {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 2249069246763182397L;
class="kw">public ValuesView(Double2ObjectConcurrentHashMap<V> var1) {
super(var1);
}
@Override
class="kw">public class="kw">final boolean contains(Object var1) {
class="kw">return this.map.containsValue(var1);
}
@Override
class="kw">public class="kw">final boolean remove(Object var1) {
if (var1 != null) {
Iterator var2 = this.iterator();
while (var2.hasNext()) {
if (var1.equals(var2.next())) {
var2.remove();
class="kw">return true;
}
}
}
class="kw">return false;
}
@Override
class="kw">public class="kw">final ObjectIterator<V> iterator() {
Double2ObjectConcurrentHashMap var1 = this.map;
Double2ObjectConcurrentHashMap.Node[] var2 = var1.table;
int var3 = var1.table == null ? 0 : var2.length;
class="kw">return new Double2ObjectConcurrentHashMap.ValueIterator<>(var2, var3, 0, var3, var1);
}
@Override
class="kw">public class="kw">final boolean add(V var1) {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final boolean addAll(Collection<? class="kw">extends V> var1) {
throw new UnsupportedOperationException();
}
class="kw">public ObjectSpliterator<V> spliterator() {
Double2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Double2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Double2ObjectConcurrentHashMap.ValueSpliterator<>(var1, var5, 0, var5, var3 < 0L ? 0L : var3);
}
@Override
class="kw">public void forEach(Consumer<? super V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var3 = var2;
Double2ObjectConcurrentHashMap.Node var4 = null;
Double2ObjectConcurrentHashMap.TableStack var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label78: {
while (true) {
if (var11 != null) {
var4 = var11;
break label78;
}
if (var8 >= var9) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var12 = var3;
if (var3 == null) {
break;
}
int var14;
int var10000 = var14 = var12.length;
int var13 = var7;
if (var10000 <= var7 || var13 < 0) {
break;
}
if ((var11 = Double2ObjectConcurrentHashMap.tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var6;
if (var19 != null) {
var6 = var19.next;
} else {
var19 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var12;
var19.length = var14;
var19.index = var13;
var19.next = var5;
var5 = var19;
class="kw">continue;
}
if (var11 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Double2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var15 = var5;
if (var5 != null) {
int var16 = var15.length;
if ((var7 += var15.length) >= var14) {
var14 = var16;
var7 = var15.index;
var3 = var15.tab;
var15.tab = null;
Double2ObjectConcurrentHashMap.TableStack var17 = var15.next;
var15.next = var6;
var5 = var17;
var6 = var15;
class="kw">continue;
}
}
if (var15 == null && (var7 += var10) >= var14) {
var7 = ++var8;
}
break;
}
}
}
var4 = null;
}
if (var11 == null) {
break;
}
var1.accept(var11.val);
}
}
}
@Override
class="kw">public <A, B, C, D> void forEach(
FastCollection.FastConsumerD9<? super V, A, B, C, D> var1,
A var2,
double var3,
double var5,
double var7,
double var9,
double var11,
double var13,
double var15,
double var17,
double var19,
B var21,
C var22,
D var23
) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var24 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var25 = var24;
Double2ObjectConcurrentHashMap.Node var26 = null;
Double2ObjectConcurrentHashMap.TableStack var27 = null;
Double2ObjectConcurrentHashMap.TableStack var28 = null;
int var29 = 0;
int var30 = 0;
int var31 = var24.length;
int var32 = var24.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var33 = null;
var33 = var26;
if (var26 != null) {
var33 = var33.next;
}
label78: {
while (true) {
if (var33 != null) {
var26 = var33;
break label78;
}
if (var30 >= var31) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var34 = var25;
if (var25 == null) {
break;
}
int var36;
int var10000 = var36 = var34.length;
int var35 = var29;
if (var10000 <= var29 || var35 < 0) {
break;
}
if ((var33 = Double2ObjectConcurrentHashMap.tabAt(var34, var35)) != null && var33.hash < 0) {
if (var33 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var25 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var33).nextTable;
var33 = null;
Double2ObjectConcurrentHashMap.TableStack var41 = var28;
if (var41 != null) {
var28 = var41.next;
} else {
var41 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var41.tab = var34;
var41.length = var36;
var41.index = var35;
var41.next = var27;
var27 = var41;
class="kw">continue;
}
if (var33 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var33 = ((Double2ObjectConcurrentHashMap.TreeBin)var33).first;
} else {
var33 = null;
}
}
if (var27 == null) {
if ((var29 = var35 + var32) >= var36) {
var29 = ++var30;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var37 = var27;
if (var27 != null) {
int var38 = var37.length;
if ((var29 += var37.length) >= var36) {
var36 = var38;
var29 = var37.index;
var25 = var37.tab;
var37.tab = null;
Double2ObjectConcurrentHashMap.TableStack var39 = var37.next;
var37.next = var28;
var27 = var39;
var28 = var37;
class="kw">continue;
}
}
if (var37 == null && (var29 += var32) >= var36) {
var29 = ++var30;
}
break;
}
}
}
var26 = null;
}
if (var33 == null) {
break;
}
var1.accept(var33.val, var2, var3, var5, var7, var9, var11, var13, var15, var17, var19, var21, var22, var23);
}
}
}
@Override
class="kw">public <A, B, C, D> void forEach(
FastCollection.FastConsumerD6<? super V, A, B, C, D> var1,
A var2,
double var3,
double var5,
double var7,
double var9,
double var11,
double var13,
B var15,
C var16,
D var17
) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var18 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var19 = var18;
Double2ObjectConcurrentHashMap.Node var20 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = null;
Double2ObjectConcurrentHashMap.TableStack var22 = null;
int var23 = 0;
int var24 = 0;
int var25 = var18.length;
int var26 = var18.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var27 = null;
var27 = var20;
if (var20 != null) {
var27 = var27.next;
}
label78: {
while (true) {
if (var27 != null) {
var20 = var27;
break label78;
}
if (var24 >= var25) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var28 = var19;
if (var19 == null) {
break;
}
int var30;
int var10000 = var30 = var28.length;
int var29 = var23;
if (var10000 <= var23 || var29 < 0) {
break;
}
if ((var27 = Double2ObjectConcurrentHashMap.tabAt(var28, var29)) != null && var27.hash < 0) {
if (var27 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var19 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var27).nextTable;
var27 = null;
Double2ObjectConcurrentHashMap.TableStack var35 = var22;
if (var35 != null) {
var22 = var35.next;
} else {
var35 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var35.tab = var28;
var35.length = var30;
var35.index = var29;
var35.next = var21;
var21 = var35;
class="kw">continue;
}
if (var27 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var27 = ((Double2ObjectConcurrentHashMap.TreeBin)var27).first;
} else {
var27 = null;
}
}
if (var21 == null) {
if ((var23 = var29 + var26) >= var30) {
var23 = ++var24;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var31 = var21;
if (var21 != null) {
int var32 = var31.length;
if ((var23 += var31.length) >= var30) {
var30 = var32;
var23 = var31.index;
var19 = var31.tab;
var31.tab = null;
Double2ObjectConcurrentHashMap.TableStack var33 = var31.next;
var31.next = var22;
var21 = var33;
var22 = var31;
class="kw">continue;
}
}
if (var31 == null && (var23 += var26) >= var30) {
var23 = ++var24;
}
break;
}
}
}
var20 = null;
}
if (var27 == null) {
break;
}
var1.accept(var27.val, var2, var3, var5, var7, var9, var11, var13, var15, var16, var17);
}
}
}
@Override
class="kw">public void forEachWithFloat(FastCollection.FastConsumerF<? super V> var1, float var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label78: {
while (true) {
if (var12 != null) {
var5 = var12;
break label78;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = Double2ObjectConcurrentHashMap.tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
var1.accept(var12.val, var2);
}
}
}
@Override
class="kw">public void forEachWithInt(FastCollection.FastConsumerI<? super V> var1, int var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var3 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var4 = var3;
Double2ObjectConcurrentHashMap.Node var5 = null;
Double2ObjectConcurrentHashMap.TableStack var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var12 = null;
var12 = var5;
if (var5 != null) {
var12 = var12.next;
}
label78: {
while (true) {
if (var12 != null) {
var5 = var12;
break label78;
}
if (var9 >= var10) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var13 = var4;
if (var4 == null) {
break;
}
int var15;
int var10000 = var15 = var13.length;
int var14 = var8;
if (var10000 <= var8 || var14 < 0) {
break;
}
if ((var12 = Double2ObjectConcurrentHashMap.tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Double2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Double2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var16 = var6;
if (var6 != null) {
int var17 = var16.length;
if ((var8 += var16.length) >= var15) {
var15 = var17;
var8 = var16.index;
var4 = var16.tab;
var16.tab = null;
Double2ObjectConcurrentHashMap.TableStack var18 = var16.next;
var16.next = var7;
var6 = var18;
var7 = var16;
class="kw">continue;
}
}
if (var16 == null && (var8 += var11) >= var15) {
var8 = ++var9;
}
break;
}
}
}
var5 = null;
}
if (var12 == null) {
break;
}
var1.accept(var12.val, var2);
}
}
}
@Override
class="kw">public void forEachWithLong(FastCollection.FastConsumerL<? super V> var1, long var2) {
if (var1 == null) {
throw new NullPointerException();
}
Double2ObjectConcurrentHashMap.Node[] var4 = this.map.table;
if (this.map.table != null) {
Double2ObjectConcurrentHashMap.Node[] var5 = var4;
Double2ObjectConcurrentHashMap.Node var6 = null;
Double2ObjectConcurrentHashMap.TableStack var7 = null;
Double2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Double2ObjectConcurrentHashMap.Node var13 = null;
var13 = var6;
if (var6 != null) {
var13 = var13.next;
}
label78: {
while (true) {
if (var13 != null) {
var6 = var13;
break label78;
}
if (var10 >= var11) {
break;
}
Double2ObjectConcurrentHashMap.Node[] var14 = var5;
if (var5 == null) {
break;
}
int var16;
int var10000 = var16 = var14.length;
int var15 = var9;
if (var10000 <= var9 || var15 < 0) {
break;
}
if ((var13 = Double2ObjectConcurrentHashMap.tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Double2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Double2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Double2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Double2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Double2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Double2ObjectConcurrentHashMap.TableStack var17 = var7;
if (var7 != null) {
int var18 = var17.length;
if ((var9 += var17.length) >= var16) {
var16 = var18;
var9 = var17.index;
var5 = var17.tab;
var17.tab = null;
Double2ObjectConcurrentHashMap.TableStack var19 = var17.next;
var17.next = var8;
var7 = var19;
var8 = var17;
class="kw">continue;
}
}
if (var17 == null && (var9 += var12) >= var16) {
var9 = ++var10;
}
break;
}
}
}
var6 = null;
}
if (var13 == null) {
break;
}
var1.accept(var13.val, var2);
}
}
}
}
}