Float2ObjectConcurrentHashMap class
Пакет: com.hypixel.fastutil.floats
Файл: com/hypixel/fastutil/floats/Float2ObjectConcurrentHashMap.java
Поля (2707)
| Модификаторы | Тип | Имя |
|---|---|---|
|
|
ABASE |
|
|
ASHIFT |
|
|
BASECOUNT |
|
|
CELLSBUSY |
|
|
CELLVALUE |
|
public final float |
EMPTY |
|
public final float |
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 FloatConsumer |
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 Float2ObjectConcurrentHashMap.TreeNode<V> |
first |
|
public final int |
hash |
|
public int |
index |
|
public int |
index |
|
public int |
index |
|
public int |
index |
|
public final float |
key |
|
public final float |
key |
|
public Float2ObjectConcurrentHashMap.Node<V> |
lastReturned |
|
public Float2ObjectConcurrentHashMap.Node<V> |
lastReturned |
|
public Float2ObjectConcurrentHashMap.TreeNode<V> |
left |
|
public int |
length |
|
public final float |
loadFactor |
|
public volatile int |
lockState |
|
public final Float2ObjectConcurrentHashMap<V> |
map |
|
public final Float2ObjectConcurrentHashMap<K> |
map |
|
public final Float2ObjectConcurrentHashMap<V> |
map |
|
public final Float2ObjectConcurrentHashMap<V> |
map |
|
public final Float2ObjectConcurrentHashMap<V> |
map |
|
public final Float2ObjectConcurrentHashMap<V> |
map |
|
public Float2ObjectConcurrentHashMap.Node<V> |
next |
|
public Float2ObjectConcurrentHashMap.Node<V> |
next |
|
public volatile Float2ObjectConcurrentHashMap.Node<V> |
next |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
next |
|
public Float2ObjectConcurrentHashMap.Node<V> |
next |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.ReduceKeysTask<V> |
nextRight |
|
public Float2ObjectConcurrentHashMap.ReduceValuesTask<V> |
nextRight |
|
public final Float2ObjectConcurrentHashMap.Node<V>[] |
nextTable |
|
protected static final String |
oomeMsg |
|
public Float2ObjectConcurrentHashMap.TreeNode<V> |
parent |
|
public Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.FloatReduceTaskOperator |
reducer |
|
public double |
result |
|
public float |
result |
|
public int |
result |
|
public long |
result |
|
public U |
result |
|
public U |
result |
|
public U |
result |
|
public U |
result |
|
public Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.TreeNode<V> |
right |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.ReduceKeysTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.ReduceValuesTask<V> |
rights |
|
public Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
spare |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Float2ObjectConcurrentHashMap.TableStack<V> |
stack |
|
public Float2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Float2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Float2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public Float2ObjectConcurrentHashMap.Node<V>[] |
tab |
|
public final ToDoubleFunction<Float2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final ToIntFunction<Float2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final ToLongFunction<Float2ObjectConcurrentHashMap.Entry<V>> |
transformer |
|
public final Float2ObjectConcurrentHashMap.FloatToDoubleFunction |
transformer |
|
public final Float2ObjectConcurrentHashMap.FloatToIntFunction |
transformer |
|
public final Float2ObjectConcurrentHashMap.FloatToLongFunction |
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 |
|
Float2ObjectConcurrentHashMap.KeySetView |
var1 |
|
Float2ObjectConcurrentHashMap.ValuesView |
var1 |
|
Float2ObjectConcurrentHashMap.EntrySetView |
var1 |
|
int |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
long |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var1 |
|
Class |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
long |
var1 |
|
StringBuilder |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
Float2ObjectConcurrentHashMap |
var1 |
|
int |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
Consumer |
var1 |
|
FloatConsumer |
var1 |
|
Float2ObjectConcurrentHashMap.FloatObjConsumer |
var1 |
|
Function |
var1 |
|
Float2ObjectConcurrentHashMap.FloatFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatObjFunction |
var1 |
|
Function |
var1 |
|
Consumer |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
Object[] |
var1 |
|
float[] |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var1 |
|
int |
var1 |
|
|
var1 |
|
Function |
var1 |
|
ToDoubleFunction |
var1 |
|
ToIntFunction |
var1 |
|
ToLongFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatToDoubleFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatToIntFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatToLongFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatObjFunction |
var1 |
|
Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction |
var1 |
|
Float2ObjectConcurrentHashMap.ToIntFloatObjFunction |
var1 |
|
Float2ObjectConcurrentHashMap.ToLongFloatObjFunction |
var1 |
|
Function |
var1 |
|
ToDoubleFunction |
var1 |
|
ToIntFunction |
var1 |
|
ToLongFunction |
var1 |
|
BiFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatReduceTaskOperator |
var1 |
|
BiFunction |
var1 |
|
Function |
var1 |
|
Float2ObjectConcurrentHashMap.FloatFunction |
var1 |
|
Float2ObjectConcurrentHashMap.FloatObjFunction |
var1 |
|
Function |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
boolean |
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
|
var1 |
|
Class |
var1 |
|
Float2ObjectConcurrentHashMap.Node |
var1 |
|
int |
var1 |
|
Float2ObjectConcurrentHashMap |
var1 |
|
Float2ObjectConcurrentHashMap.Node[] |
var1 |
|
int |
var10 |
|
int |
var10 |
|
Object |
var10 |
|
|
var10 |
|
|
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 |
|
Float2ObjectConcurrentHashMap.TableStack |
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
Float2ObjectConcurrentHashMap.TableStack |
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
long |
var10 |
|
int |
var10 |
|
|
var10 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
int |
var10 |
|
Float2ObjectConcurrentHashMap.Node |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask |
var10 |
|
Float2ObjectConcurrentHashMap.Node |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask |
var10 |
|
Float2ObjectConcurrentHashMap.Node |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask |
var10 |
|
Float2ObjectConcurrentHashMap.Node |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask |
var10 |
|
Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask |
var10 |
|
float |
var10 |
|
|
var10 |
|
|
var10 |
|
int |
var10 |
|
|
var10 |
|
|
var10 |
|
|
var10 |
|
Thread |
var10 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var10 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var10 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var10 |
|
|
var10 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
Object |
var11 |
|
|
var11 |
|
|
var11 |
|
boolean |
var11 |
|
|
var11 |
|
|
var11 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
ObjectIterator |
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 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
boolean |
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
boolean |
var11 |
|
|
var11 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.ReduceEntriesTask |
var11 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
Object |
var11 |
|
int |
var11 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var11 |
|
|
var11 |
|
boolean |
var11 |
|
Float2ObjectConcurrentHashMap.Node |
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
|
var11 |
|
int |
var11 |
|
int |
var11 |
|
int |
var11 |
|
Float2ObjectConcurrentHashMap.Node[] |
var12 |
|
Float2ObjectConcurrentHashMap.Node[] |
var12 |
|
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry |
var12 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.Node[] |
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
int |
var12 |
|
int |
var12 |
|
int |
var12 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var12 |
|
Float2ObjectConcurrentHashMap.Node[] |
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
Object |
var12 |
|
|
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
Object |
var12 |
|
Float2ObjectConcurrentHashMap.ReduceValuesTask |
var12 |
|
float |
var12 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var12 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var12 |
|
Float2ObjectConcurrentHashMap.Node[] |
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
Float2ObjectConcurrentHashMap.Node |
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
|
var12 |
|
int |
var12 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
int |
var13 |
|
float |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
int |
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.MapReduceEntriesTask |
var13 |
|
Float2ObjectConcurrentHashMap.MapReduceKeysTask |
var13 |
|
Float2ObjectConcurrentHashMap.MapReduceMappingsTask |
var13 |
|
Float2ObjectConcurrentHashMap.MapReduceValuesTask |
var13 |
|
Float2ObjectConcurrentHashMap.ReduceKeysTask |
var13 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var13 |
|
|
var13 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var13 |
|
int |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node[] |
var13 |
|
Float2ObjectConcurrentHashMap.Node |
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
|
var13 |
|
int |
var14 |
|
|
var14 |
|
float |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
int |
var14 |
|
|
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
|
var14 |
|
float |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node |
var14 |
|
|
var14 |
|
|
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
int |
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var14 |
|
int |
var14 |
|
|
var14 |
|
int |
var14 |
|
int |
var14 |
|
Float2ObjectConcurrentHashMap.Node[] |
var14 |
|
Float2ObjectConcurrentHashMap.TableStack |
var15 |
|
Float2ObjectConcurrentHashMap.Node |
var15 |
|
float |
var15 |
|
Float2ObjectConcurrentHashMap.TableStack |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
int |
var15 |
|
int |
var15 |
|
int |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
int |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
Float2ObjectConcurrentHashMap.TableStack |
var15 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var15 |
|
float |
var15 |
|
float |
var15 |
|
Float2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
Float2ObjectConcurrentHashMap.Node[] |
var15 |
|
Float2ObjectConcurrentHashMap.Node |
var15 |
|
|
var15 |
|
|
var15 |
|
|
var15 |
|
int |
var15 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.TableStack |
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
|
var15 |
|
int |
var15 |
|
int |
var16 |
|
Object |
var16 |
|
int |
var16 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.Node[] |
var16 |
|
int |
var16 |
|
Float2ObjectConcurrentHashMap.Node[] |
var16 |
|
int |
var16 |
|
Float2ObjectConcurrentHashMap.Node |
var16 |
|
Float2ObjectConcurrentHashMap.Node |
var16 |
|
Float2ObjectConcurrentHashMap.Node |
var16 |
|
float |
var16 |
|
int |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
int |
var16 |
|
|
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var16 |
|
int |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var16 |
|
int |
var16 |
|
|
var16 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
int |
var17 |
|
|
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.Node |
var17 |
|
Float2ObjectConcurrentHashMap.Node |
var17 |
|
|
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
int |
var17 |
|
int |
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
int |
var17 |
|
int |
var17 |
|
Float2ObjectConcurrentHashMap.TableStack |
var17 |
|
Float2ObjectConcurrentHashMap.Node |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
int |
var18 |
|
int |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
|
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
|
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
int |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var18 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var18 |
|
Float2ObjectConcurrentHashMap.Node[] |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
Float2ObjectConcurrentHashMap.TableStack |
var18 |
|
int |
var18 |
|
Object |
var19 |
|
Float2ObjectConcurrentHashMap.TreeBin |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
int |
var19 |
|
int |
var19 |
|
int |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
int |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Object |
var19 |
|
Float2ObjectConcurrentHashMap.TreeBin |
var19 |
|
int |
var19 |
|
Object |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
|
var19 |
|
Float2ObjectConcurrentHashMap.Node[] |
var19 |
|
|
var19 |
|
|
var19 |
|
Float2ObjectConcurrentHashMap.TableStack |
var19 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
ObjectIterator |
var2 |
|
ObjectIterator |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
int |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
|
var2 |
|
int |
var2 |
|
|
var2 |
|
Float2ObjectConcurrentHashMap.CounterCell |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
|
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
|
var2 |
|
|
var2 |
|
Class |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.TableStack |
var2 |
|
long |
var2 |
|
Iterator |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
boolean |
var2 |
|
|
var2 |
|
Throwable |
var2 |
|
float |
var2 |
|
float |
var2 |
|
float |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Set |
var2 |
|
Float2ObjectConcurrentHashMap |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
int |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
Throwable |
var2 |
|
int |
var2 |
|
int |
var2 |
|
int |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
Consumer |
var2 |
|
int |
var2 |
|
Throwable |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.TableStack |
var2 |
|
float |
var2 |
|
Float2ObjectConcurrentHashMap |
var2 |
|
Object |
var2 |
|
boolean |
var2 |
|
|
var2 |
|
FloatIterator |
var2 |
|
FloatSet |
var2 |
|
FloatIterator |
var2 |
|
FloatIterator |
var2 |
|
FloatIterator |
var2 |
|
FloatIterator |
var2 |
|
FloatIterator |
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 |
|
Float2ObjectConcurrentHashMap |
var2 |
|
int |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.TableStack |
var2 |
|
int |
var2 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
|
var2 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var2 |
|
Object |
var2 |
|
int |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
Float2ObjectConcurrentHashMap.Node |
var2 |
|
Iterator |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap |
var2 |
|
Float2ObjectConcurrentHashMap.Node[] |
var2 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
int |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
int |
var20 |
|
float |
var20 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var20 |
|
Float2ObjectConcurrentHashMap.TreeBin |
var20 |
|
float |
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Object |
var20 |
|
Float2ObjectConcurrentHashMap.Node |
var20 |
|
Float2ObjectConcurrentHashMap.Node |
var20 |
|
|
var20 |
|
|
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Float2ObjectConcurrentHashMap.TableStack |
var20 |
|
|
var20 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
Object |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var21 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var21 |
|
Object |
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Object |
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Object |
var21 |
|
Object |
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
|
var21 |
|
Float2ObjectConcurrentHashMap.TableStack |
var21 |
|
|
var21 |
|
Object |
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var22 |
|
int |
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var22 |
|
|
var22 |
|
|
var22 |
|
Float2ObjectConcurrentHashMap.TableStack |
var23 |
|
|
var23 |
|
Float2ObjectConcurrentHashMap.TableStack |
var23 |
|
|
var23 |
|
int |
var23 |
|
|
var23 |
|
|
var23 |
|
|
var23 |
|
Float2ObjectConcurrentHashMap.Node |
var24 |
|
Float2ObjectConcurrentHashMap.TreeBin |
var24 |
|
int |
var24 |
|
Float2ObjectConcurrentHashMap.Node[] |
var24 |
|
int |
var24 |
|
Float2ObjectConcurrentHashMap.TreeBin |
var25 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var25 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var25 |
|
Float2ObjectConcurrentHashMap.Node[] |
var25 |
|
|
var25 |
|
|
var25 |
|
int |
var25 |
|
Float2ObjectConcurrentHashMap.Node |
var26 |
|
|
var26 |
|
Float2ObjectConcurrentHashMap.Node |
var26 |
|
|
var26 |
|
Float2ObjectConcurrentHashMap.Node |
var26 |
|
|
var26 |
|
|
var26 |
|
int |
var26 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var27 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var27 |
|
|
var27 |
|
|
var27 |
|
Float2ObjectConcurrentHashMap.TableStack |
var27 |
|
|
var27 |
|
|
var27 |
|
Float2ObjectConcurrentHashMap.Node |
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
|
var27 |
|
Object |
var28 |
|
Float2ObjectConcurrentHashMap.TableStack |
var28 |
|
|
var28 |
|
|
var28 |
|
Float2ObjectConcurrentHashMap.Node[] |
var28 |
|
int |
var29 |
|
int |
var29 |
|
|
var29 |
|
|
var29 |
|
|
var29 |
|
int |
var29 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry |
var3 |
|
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry |
var3 |
|
int |
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Traverser |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Object |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var3 |
|
|
var3 |
|
int |
var3 |
|
long |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
|
var3 |
|
long |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
|
var3 |
|
|
var3 |
|
Class |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
|
var3 |
|
Object |
var3 |
|
Iterator |
var3 |
|
Iterator |
var3 |
|
Object |
var3 |
|
Object |
var3 |
|
Object |
var3 |
|
int |
var3 |
|
Float2ObjectConcurrentHashMap.Traverser |
var3 |
|
long |
var3 |
|
Float2ObjectConcurrentHashMap.Traverser |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Object |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
float |
var3 |
|
int |
var3 |
|
FloatIterator |
var3 |
|
FloatIterator |
var3 |
|
FloatIterator |
var3 |
|
FloatIterator |
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 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
int |
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Node |
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
|
var3 |
|
|
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var3 |
|
int |
var3 |
|
int |
var3 |
|
long |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
|
var3 |
|
|
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
Float2ObjectConcurrentHashMap.Node[] |
var3 |
|
int |
var30 |
|
int |
var30 |
|
int |
var30 |
|
|
var30 |
|
Float2ObjectConcurrentHashMap.Node |
var31 |
|
long |
var31 |
|
int |
var31 |
|
Float2ObjectConcurrentHashMap.TableStack |
var31 |
|
int |
var32 |
|
Float2ObjectConcurrentHashMap.CounterCell |
var32 |
|
int |
var32 |
|
int |
var32 |
|
Float2ObjectConcurrentHashMap.Node |
var33 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var33 |
|
Float2ObjectConcurrentHashMap.Node |
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
|
var33 |
|
Float2ObjectConcurrentHashMap.TableStack |
var33 |
|
boolean |
var34 |
|
|
var34 |
|
Float2ObjectConcurrentHashMap.Node[] |
var34 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var35 |
|
|
var35 |
|
int |
var35 |
|
Float2ObjectConcurrentHashMap.TableStack |
var35 |
|
|
var35 |
|
int |
var36 |
|
|
var36 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var37 |
|
|
var37 |
|
Float2ObjectConcurrentHashMap.TableStack |
var37 |
|
int |
var38 |
|
int |
var38 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var39 |
|
|
var39 |
|
Float2ObjectConcurrentHashMap.TableStack |
var39 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
StringBuilder |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Object |
var4 |
|
|
var4 |
|
|
var4 |
|
Object |
var4 |
|
|
var4 |
|
|
var4 |
|
Object |
var4 |
|
|
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
int |
var4 |
|
|
var4 |
|
int |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
|
var4 |
|
int |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
Object[] |
var4 |
|
|
var4 |
|
int |
var4 |
|
Object |
var4 |
|
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
FloatIterator |
var4 |
|
float |
var4 |
|
float |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
float |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
int |
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TableStack |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
int |
var4 |
|
Class |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var4 |
|
|
var4 |
|
|
var4 |
|
|
var4 |
|
|
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
|
var4 |
|
|
var4 |
|
Float2ObjectConcurrentHashMap.Node[] |
var4 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var40 |
|
|
var40 |
|
int |
var41 |
|
Float2ObjectConcurrentHashMap.TableStack |
var41 |
|
|
var41 |
|
long |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
Float2ObjectConcurrentHashMap.Traverser |
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
Object |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
long |
var5 |
|
int |
var5 |
|
int |
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
boolean |
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var5 |
|
Object[] |
var5 |
|
|
var5 |
|
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
float |
var5 |
|
float |
var5 |
|
float |
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 |
|
float |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
float |
var5 |
|
boolean |
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var5 |
|
int |
var5 |
|
int |
var5 |
|
Float2ObjectConcurrentHashMap.TableStack |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node |
var5 |
|
|
var5 |
|
|
var5 |
|
Float2ObjectConcurrentHashMap.Node[] |
var5 |
|
|
var5 |
|
|
var5 |
|
int |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
float |
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node[] |
var6 |
|
Float2ObjectConcurrentHashMap.ForwardingNode |
var6 |
|
Float2ObjectConcurrentHashMap.CounterCell[] |
var6 |
|
long |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
ObjectIterator |
var6 |
|
int |
var6 |
|
|
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 |
|
Float2ObjectConcurrentHashMap.Entry |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
Object |
var6 |
|
float |
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var6 |
|
int |
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.TableStack |
var6 |
|
|
var6 |
|
|
var6 |
|
Float2ObjectConcurrentHashMap.Node |
var6 |
|
|
var6 |
|
|
var6 |
|
int |
var7 |
|
float |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
int |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
Float2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node[] |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
long |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.Node[] |
var7 |
|
boolean |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.CounterCell |
var7 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var7 |
|
Object |
var7 |
|
int |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
Object |
var7 |
|
float |
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 |
|
Float2ObjectConcurrentHashMap.Entry |
var7 |
|
float |
var7 |
|
Object |
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
Float2ObjectConcurrentHashMap.Node |
var7 |
|
int |
var7 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var7 |
|
|
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var7 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var7 |
|
float |
var7 |
|
int |
var7 |
|
|
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
Float2ObjectConcurrentHashMap.TableStack |
var7 |
|
|
var7 |
|
|
var7 |
|
int |
var8 |
|
int |
var8 |
|
int |
var8 |
|
int |
var8 |
|
|
var8 |
|
int |
var8 |
|
Object |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.Node |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.Node |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
int |
var8 |
|
Float2ObjectConcurrentHashMap.Node |
var8 |
|
Float2ObjectConcurrentHashMap.Node |
var8 |
|
Float2ObjectConcurrentHashMap.Node[] |
var8 |
|
|
var8 |
|
|
var8 |
|
boolean |
var8 |
|
|
var8 |
|
int |
var8 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
ObjectIterator |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Object |
var8 |
|
Float2ObjectConcurrentHashMap.Entry |
var8 |
|
|
var8 |
|
float |
var8 |
|
Object |
var8 |
|
|
var8 |
|
Class |
var8 |
|
int |
var8 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var8 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var8 |
|
int |
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
int |
var8 |
|
|
var8 |
|
|
var8 |
|
|
var8 |
|
Float2ObjectConcurrentHashMap.TableStack |
var8 |
|
|
var8 |
|
|
var8 |
|
float |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
Object |
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TableStack |
var9 |
|
|
var9 |
|
|
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
Float2ObjectConcurrentHashMap.Node |
var9 |
|
Float2ObjectConcurrentHashMap.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 |
|
Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask |
var9 |
|
Object |
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask |
var9 |
|
Float2ObjectConcurrentHashMap.Node |
var9 |
|
boolean |
var9 |
|
|
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.Node |
var9 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var9 |
|
float |
var9 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var9 |
|
|
var9 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var9 |
|
Float2ObjectConcurrentHashMap.TreeNode |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
int |
var9 |
|
|
var9 |
|
|
var9 |
|
|
var9 |
|
public volatile Thread |
waiter |
Методы (1463)
| Модификаторы | Возврат | Сигнатура |
|---|---|---|
|
public |
BaseIteratorpublic BaseIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) |
|
protected |
BulkTaskprotected BulkTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
CollectionViewpublic CollectionView(Float2ObjectConcurrentHashMap<K> var1) |
|
public |
CounterCellpublic CounterCell(long var1) |
|
public |
DoubleReturningBulkTaskpublic DoubleReturningBulkTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
EntryIteratorpublic EntryIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) |
|
public |
EntrySetViewpublic EntrySetView(Float2ObjectConcurrentHashMap<V> var1) |
|
public |
EntrySpliteratorpublic EntrySpliterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5, Float2ObjectConcurrentHashMap<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 |
FloatReturningBulkTask2public FloatReturningBulkTask2(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
ForEachEntryTaskpublic ForEachEntryTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super Float2ObjectConcurrentHashMap.Entry<V>> var6) |
|
public |
ForEachKeyTaskpublic ForEachKeyTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5, FloatConsumer var6) |
|
public |
ForEachMappingTaskpublic ForEachMappingTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var6) |
|
public |
ForEachTransformedEntryTaskpublic ForEachTransformedEntryTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedKeyTaskpublic ForEachTransformedKeyTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatFunction<? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedMappingTaskpublic ForEachTransformedMappingTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachTransformedValueTaskpublic ForEachTransformedValueTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? extends U> var6,
Consumer<? super U> var7) |
|
public |
ForEachValueTaskpublic ForEachValueTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super V> var6) |
|
public |
ForwardingNodepublic ForwardingNode(float var1, Float2ObjectConcurrentHashMap.Node<V>[] var2) |
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(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
KeyIteratorpublic KeyIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) |
|
public |
KeySetViewpublic KeySetView(Float2ObjectConcurrentHashMap<V> var1, V var2) |
|
public |
KeySpliteratorpublic KeySpliterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) |
|
public |
LongReturningBulkTaskpublic LongReturningBulkTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5) |
|
public |
MapEntrypublic MapEntry(boolean var1, float var2, V var3, Float2ObjectConcurrentHashMap<V> var4) |
|
public |
MapReduceEntriesTaskpublic MapReduceEntriesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> var6,
Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceEntriesToDoubleTaskpublic MapReduceEntriesToDoubleTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> var6,
ToDoubleFunction<Float2ObjectConcurrentHashMap.Entry<V>> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceEntriesToIntTaskpublic MapReduceEntriesToIntTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> var6,
ToIntFunction<Float2ObjectConcurrentHashMap.Entry<V>> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceEntriesToLongTaskpublic MapReduceEntriesToLongTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> var6,
ToLongFunction<Float2ObjectConcurrentHashMap.Entry<V>> var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceKeysTaskpublic MapReduceKeysTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> var6,
Float2ObjectConcurrentHashMap.FloatFunction<? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceKeysToDoubleTaskpublic MapReduceKeysToDoubleTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToDoubleFunction var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceKeysToIntTaskpublic MapReduceKeysToIntTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToIntFunction var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceKeysToLongTaskpublic MapReduceKeysToLongTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToLongFunction var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceMappingsTaskpublic MapReduceMappingsTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> var6,
Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceMappingsToDoubleTaskpublic MapReduceMappingsToDoubleTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> var6,
Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceMappingsToIntTaskpublic MapReduceMappingsToIntTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> var6,
Float2ObjectConcurrentHashMap.ToIntFloatObjFunction<? super V> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceMappingsToLongTaskpublic MapReduceMappingsToLongTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> var6,
Float2ObjectConcurrentHashMap.ToLongFloatObjFunction<? super V> var7,
long var8,
LongBinaryOperator var10) |
|
public |
MapReduceValuesTaskpublic MapReduceValuesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> var6,
Function<? super V, ? extends U> var7,
BiFunction<? super U, ? super U, ? extends U> var8) |
|
public |
MapReduceValuesToDoubleTaskpublic MapReduceValuesToDoubleTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> var6,
ToDoubleFunction<? super V> var7,
double var8,
DoubleBinaryOperator var10) |
|
public |
MapReduceValuesToIntTaskpublic MapReduceValuesToIntTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> var6,
ToIntFunction<? super V> var7,
int var8,
IntBinaryOperator var9) |
|
public |
MapReduceValuesToLongTaskpublic MapReduceValuesToLongTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> var6,
ToLongFunction<? super V> var7,
long var8,
LongBinaryOperator var10) |
abstract |
throw new |
NoSuchElementExceptionthrow new NoSuchElementException() |
|
public |
Nodepublic Node(float var1, int var2, float var3, V var4, Float2ObjectConcurrentHashMap.Node<V> var5) |
abstract |
throw new |
NullPointerExceptionthrow new NullPointerException() |
abstract |
throw new |
OutOfMemoryErrorthrow new OutOfMemoryError("Required array size too large") |
|
public |
ReduceEntriesTaskpublic ReduceEntriesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> var6,
BiFunction<Float2ObjectConcurrentHashMap.Entry<V>, Float2ObjectConcurrentHashMap.Entry<V>, ? extends Float2ObjectConcurrentHashMap.Entry<V>> var7) |
|
public |
ReduceKeysTaskpublic ReduceKeysTask(float var1,
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var2,
int var3,
int var4,
int var5,
Float2ObjectConcurrentHashMap.Node<V>[] var6,
Float2ObjectConcurrentHashMap.ReduceKeysTask<V> var7,
Float2ObjectConcurrentHashMap.FloatReduceTaskOperator var8) |
|
public |
ReduceValuesTaskpublic ReduceValuesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.ReduceValuesTask<V> var6,
BiFunction<? super V, ? super V, ? extends V> var7) |
|
public |
ReservationNodepublic ReservationNode(float var1) |
|
public |
SearchEntriesTaskpublic SearchEntriesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchKeysTaskpublic SearchKeysTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatFunction<? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchMappingsTaskpublic SearchMappingsTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
SearchValuesTaskpublic SearchValuesTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<? super V, ? extends U> var6,
AtomicReference<U> var7) |
|
public |
Segmentpublic Segment(float var1) |
|
public |
TableStackpublic TableStack() |
|
public |
Traverserpublic Traverser(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4) |
|
public |
TreeBinpublic TreeBin(float var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) |
|
public |
TreeNodepublic TreeNode(float var1, int var2, float var3, V var4, Float2ObjectConcurrentHashMap.Node<V> var5, Float2ObjectConcurrentHashMap.TreeNode<V> var6) |
abstract |
throw new |
UnsupportedOperationExceptionthrow new UnsupportedOperationException() |
|
public |
ValueIteratorpublic ValueIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) |
|
public |
ValueSpliteratorpublic ValueSpliterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) |
|
public |
ValuesViewpublic ValuesView(Float2ObjectConcurrentHashMap<V> var1) |
abstract |
void |
acceptvoid accept(float var1, V var2, byte var3, X var4) |
abstract |
void |
acceptvoid accept(float var1, V var2, X var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, double var3, X var5) |
abstract |
void |
acceptvoid accept(float var1, V var2, float var3, X var4) |
abstract |
void |
acceptvoid accept(float var1, V var2, int var3, X var4) |
abstract |
void |
acceptvoid accept(float var1, V var2, long var3, X var5) |
abstract |
void |
acceptvoid accept(float var1, V var2, short var3, X var4) |
abstract |
void |
acceptvoid accept(float var1, V var2, byte var3) |
abstract |
void |
acceptvoid accept(float var1, V var2) |
abstract |
void |
acceptvoid accept(float var1, V var2, double var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, float var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, int var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, long var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, short var3) |
abstract |
void |
acceptvoid accept(float var1, V var2, X var3, Y var4) |
|
public boolean |
addpublic boolean add(it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V> var1) |
|
public boolean |
addpublic boolean add(float var1) |
|
public final boolean |
addpublic final boolean add(V var1) |
|
public boolean |
addAllpublic boolean addAll(Collection<? extends it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) |
|
public boolean |
addAllpublic boolean addAll(FloatCollection var1) |
|
public boolean |
addAllpublic boolean addAll(Collection<? extends Float> var1) |
|
public boolean |
addAllpublic boolean addAll(float[] var1) |
|
public final boolean |
addAllpublic final boolean addAll(Collection<? extends V> var1) |
final |
void |
addCountvoid addCount(long var1, int var3) |
|
protected final Float2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Float2ObjectConcurrentHashMap.Node<V> advance() |
|
protected final Float2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Float2ObjectConcurrentHashMap.Node<V> advance() |
|
protected final Float2ObjectConcurrentHashMap.Node<V> |
advanceprotected final Float2ObjectConcurrentHashMap.Node<V> advance() |
abstract |
J |
applyJ apply(float var1, V var2, X var3) |
abstract |
R |
applyR apply(float var1) |
abstract |
J |
applyJ apply(float var1, V var2, byte var3) |
abstract |
J |
applyJ apply(float var1, V var2, double var3) |
abstract |
J |
applyJ apply(float var1, V var2, float var3) |
abstract |
J |
applyJ apply(float var1, V var2) |
abstract |
J |
applyJ apply(float var1, V var2, int var3) |
abstract |
J |
applyJ apply(float var1, V var2, long var3) |
abstract |
J |
applyJ apply(float var1, V var2, short var3) |
abstract |
double |
applyAsDoubledouble applyAsDouble(float var1) |
abstract |
double |
applyAsDoubledouble applyAsDouble(float var1, V var2) |
abstract |
float |
applyAsFloatfloat applyAsFloat(T var1) |
abstract |
int |
applyAsIntint applyAsInt(float var1) |
abstract |
int |
applyAsIntint applyAsInt(float var1, V var2) |
abstract |
long |
applyAsLonglong applyAsLong(float var1) |
abstract |
long |
applyAsLonglong applyAsLong(float var1, V var2) |
|
protected <V> Float2ObjectConcurrentHashMap.TreeNode<V> |
balanceDeletionprotected <V> Float2ObjectConcurrentHashMap.TreeNode<V> balanceDeletion(Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) |
|
protected <V> Float2ObjectConcurrentHashMap.TreeNode<V> |
balanceInsertionprotected <V> Float2ObjectConcurrentHashMap.TreeNode<V> balanceInsertion(Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) |
final |
int |
batchForint batchFor(long var1) |
protected |
Float2ObjectConcurrentHashMap.EntrySetView<V> |
buildEntrySetViewFloat2ObjectConcurrentHashMap.EntrySetView<V> buildEntrySetView() |
protected |
Float2ObjectConcurrentHashMap.KeySetView<V> |
buildKeySetViewFloat2ObjectConcurrentHashMap.KeySetView<V> buildKeySetView() |
protected |
Float2ObjectConcurrentHashMap.ValuesView<V> |
buildValuesViewFloat2ObjectConcurrentHashMap.ValuesView<V> buildValuesView() |
final |
<V> boolean |
casTabAt<V> boolean casTabAt(Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Float2ObjectConcurrentHashMap.Node<V> var2, Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.TreeNode<V> var1) |
public |
void |
clearvoid clear() |
|
public final void |
clearpublic final void clear() |
|
public void |
clearpublic void clear() |
public |
V |
computeV compute(float var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends V> var2) |
|
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(float var1, Float2ObjectConcurrentHashMap.FloatFunction<? extends V> var2) |
public |
V |
computeIfPresentV computeIfPresent(float var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends V> var2) |
|
public boolean |
containspublic boolean contains(Object var1) |
|
public boolean |
containspublic boolean contains(float 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(FloatCollection var1) |
|
public boolean |
containsAllpublic boolean containsAll(float[] var1) |
public |
boolean |
containsKeyboolean containsKey(float var1) |
public |
boolean |
containsValueboolean containsValue(Object var1) |
|
protected final void |
contendedLockprotected final void contendedLock() |
|
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 Float2ObjectConcurrentHashMap.Node<V> |
findprotected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) |
|
protected Float2ObjectConcurrentHashMap.Node<V> |
findprotected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) |
|
protected Float2ObjectConcurrentHashMap.Node<V> |
findprotected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) |
|
protected final Float2ObjectConcurrentHashMap.Node<V> |
findprotected final Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) |
|
protected Float2ObjectConcurrentHashMap.Node<V> |
findprotected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) |
|
protected final Float2ObjectConcurrentHashMap.TreeNode<V> |
findTreeNodeprotected final Float2ObjectConcurrentHashMap.TreeNode<V> findTreeNode(int var1, float var2, Class<?> var3) |
public |
ObjectSet<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> |
float2ObjectEntrySetObjectSet<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> float2ObjectEntrySet() |
|
|
for for(Float2ObjectConcurrentHashMap.Node var18 = var11.next; var18 != null; var18 = var18.next) |
|
|
for for(Float2ObjectConcurrentHashMap.Node var36 = var11; var36 != var17; var36 = var36.next) |
|
|
for for(Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node var9 = var3; var9 != null; var9 = var9.next) |
|
|
for for(Float2ObjectConcurrentHashMap.Node var4 = var1; var4 != null; var4 = var4.next) |
|
|
for for(Object var3 : var1) |
|
|
for for(it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var4 : var1) |
|
|
for for(Object var3 : var1) |
|
|
for for(Float var4 : var1) |
|
|
for for(Object var4 : var1) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceEntriesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceKeysTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceMappingsTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceValuesTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask var10 = var9.rights; var10 != null; var10 = var9.rights = var10.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask var11 = var10.rights; var11 != null; var11 = var10.rights = var11.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.ReduceEntriesTask var5 = var11.rights; var5 != null; var5 = var11.rights = var5.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.ReduceKeysTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) |
|
|
for for(Float2ObjectConcurrentHashMap.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 var12 = this.firstComplete() |
public |
int |
forEachint forEach(Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var1) |
public |
<X> int |
forEach<X> int forEach(Float2ObjectConcurrentHashMap.FloatBiObjConsumer<? super V, X> var1, X var2) |
public |
<X, Y> int |
forEach<X, Y> int forEach(Float2ObjectConcurrentHashMap.FloatTriObjConsumer<? super V, X, Y> var1, X var2, Y var3) |
public |
void |
forEachvoid forEach(long var1, Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var3) |
public |
<U> void |
forEach<U> void forEach(long var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var3, Consumer<? super U> var4) |
|
public void |
forEachpublic void forEach(Consumer<? super it.unimi.dsi.fastutil.floats.Float2ObjectMap.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 Float2ObjectConcurrentHashMap.Entry<V>> var3) |
public |
<U> void |
forEachEntry<U> void forEachEntry(long var1, Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3, Consumer<? super U> var4) |
public |
void |
forEachKeyvoid forEachKey(long var1, FloatConsumer var3) |
public |
<U> void |
forEachKey<U> void forEachKey(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? extends U> var3, Consumer<? super U> var4) |
|
public void |
forEachRemainingpublic void forEachRemaining(Consumer<? super it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) |
|
public void |
forEachRemainingpublic void forEachRemaining(FloatConsumer 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(Float2ObjectConcurrentHashMap.FloatObjByteConsumer<? super V> var1, byte var2) |
public |
<X> int |
forEachWithByte<X> int forEachWithByte(Float2ObjectConcurrentHashMap.FloatBiObjByteConsumer<? super V, X> var1, byte var2, X var3) |
public |
int |
forEachWithDoubleint forEachWithDouble(Float2ObjectConcurrentHashMap.FloatObjDoubleConsumer<? super V> var1, double var2) |
public |
<X> int |
forEachWithDouble<X> int forEachWithDouble(Float2ObjectConcurrentHashMap.FloatBiObjDoubleConsumer<? super V, X> var1, double var2, X var4) |
public |
int |
forEachWithFloatint forEachWithFloat(Float2ObjectConcurrentHashMap.FloatObjFloatConsumer<? super V> var1, float var2) |
public |
<X> int |
forEachWithFloat<X> int forEachWithFloat(Float2ObjectConcurrentHashMap.FloatBiObjFloatConsumer<? super V, X> var1, float var2, X var3) |
|
public void |
forEachWithFloatpublic void forEachWithFloat(FastCollection.FastConsumerF<? super V> var1, float var2) |
public |
int |
forEachWithIntint forEachWithInt(Float2ObjectConcurrentHashMap.FloatObjIntConsumer<? super V> var1, int var2) |
public |
<X> int |
forEachWithInt<X> int forEachWithInt(Float2ObjectConcurrentHashMap.FloatBiObjIntConsumer<? super V, X> var1, int var2, X var3) |
|
public void |
forEachWithIntpublic void forEachWithInt(FastCollection.FastConsumerI<? super V> var1, int var2) |
public |
int |
forEachWithLongint forEachWithLong(Float2ObjectConcurrentHashMap.FloatObjLongConsumer<? super V> var1, long var2) |
public |
<X> int |
forEachWithLong<X> int forEachWithLong(Float2ObjectConcurrentHashMap.FloatBiObjLongConsumer<? super V, X> var1, long var2, X var4) |
|
public void |
forEachWithLongpublic void forEachWithLong(FastCollection.FastConsumerL<? super V> var1, long var2) |
public |
int |
forEachWithShortint forEachWithShort(Float2ObjectConcurrentHashMap.FloatObjShortConsumer<? super V> var1, short var2) |
public |
<X> int |
forEachWithShort<X> int forEachWithShort(Float2ObjectConcurrentHashMap.FloatBiObjShortConsumer<? super V, X> var1, short var2, X var3) |
final |
void |
fullAddCountvoid fullAddCount(long var1, boolean var3) |
public |
V |
getV get(float var1) |
|
public float |
getFloatKeypublic float getFloatKey() |
|
public final float |
getFloatKeypublic final float getFloatKey() |
abstract |
float |
getFloatKeyfloat getFloatKey() |
|
public Float |
getKeypublic Float getKey() |
|
public final Float |
getKeypublic final Float getKey() |
abstract |
Float |
getKeyFloat getKey() |
|
public Float2ObjectConcurrentHashMap<K> |
getMappublic Float2ObjectConcurrentHashMap<K> getMap() |
|
public V |
getMappedValuepublic V getMappedValue() |
|
public float |
getNoEntryValuepublic float getNoEntryValue() |
public |
V |
getOrDefaultV getOrDefault(float var1, V var2) |
|
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 Float2ObjectConcurrentHashMap.Entry<V> |
getRawResultpublic final Float2ObjectConcurrentHashMap.Entry<V> getRawResult() |
|
public final Float |
getRawResultpublic final Float 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 |
Float2ObjectConcurrentHashMap.Node<V>[] |
helpTransferFloat2ObjectConcurrentHashMap.Node<V>[] helpTransfer(Float2ObjectConcurrentHashMap.Node<V>[] var1, Float2ObjectConcurrentHashMap.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(var3.hash == var8) |
|
|
if if(var3.key == var1 || var7 != this.EMPTY && var1 == var7) |
|
|
if if(var3.hash == var8) |
|
|
if if(var3.key == var1 || var9 != this.EMPTY && var1 == var9) |
|
|
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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var11 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var2 == null) |
|
|
if if(var7.hash == -1) |
|
|
if if(var10 < 0) |
|
|
if if(var7 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(!var3) |
|
|
if if(var13.hash == var4) |
|
|
if if(var13.key == var1 || var14 != this.EMPTY && var1 == var14) |
|
|
if if(!var3) |
|
|
if if(var5 != 0) |
|
|
if if(var5 >= 8) |
|
|
if if(var11 != null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var6.hash == -1) |
|
|
if if(var9 < 0) |
|
|
if if(var6 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var2 != null) |
|
|
if if(var13.hash == var4) |
|
|
if if(var13.key == var1 || var15 != this.EMPTY && var1 == var15) |
|
|
if if(var2 != null) |
|
|
if if(var11) |
|
|
if if(var10 != null) |
|
|
if if(var2 == 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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var11 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var23 != null) |
|
|
if if(var15 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var14 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var23 != null) |
|
|
if if(var15 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var11 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 == null) |
|
|
if if(var5 != null) |
|
|
if if(var11 == null) |
|
|
if if(var21 == null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var2 == null) |
|
|
if if(var5 != 0) |
|
|
if if(var7.hash == -1) |
|
|
if if(var10 < 0) |
|
|
if if(var7 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var13.hash == var3) |
|
|
if if(var13.key == var1 || var14 != this.EMPTY && var1 == var14) |
|
|
if if(var5 != 0) |
|
|
if if(var5 >= 8) |
|
|
if if(!var11) |
|
|
if if(var4 != null) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var2 == null) |
|
|
if if(var8.hash == -1) |
|
|
if if(var11 < 0) |
|
|
if if(var8 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var4 != null) |
|
|
if if(var13.hash == var3) |
|
|
if if(var13.key == var1 || var15 != this.EMPTY && var1 == var15) |
|
|
if if(var4 != null) |
|
|
if if(var14 != null) |
|
|
if if(var6 != 0) |
|
|
if if(var5 != 0) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var2 == null) |
|
|
if if(var6 != 0) |
|
|
if if(var8.hash == -1) |
|
|
if if(var11 < 0) |
|
|
if if(var8 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var24.root != null) |
|
|
if if(var4 != null) |
|
|
if if(var27 != null) |
|
|
if if(var13.hash == var3) |
|
|
if if(var13.key == var1 || var15 != this.EMPTY && var1 == var15) |
|
|
if if(var4 != null) |
|
|
if if(var14 != null) |
|
|
if if(var4 != null) |
|
|
if if(var6 != 0) |
|
|
if if(var6 >= 8) |
|
|
if if(var5 != 0) |
|
|
if if(var1 == this.EMPTY) |
|
|
if if(var2 != null && var3 != null) |
|
|
if if(var9.hash == -1) |
|
|
if if(var12 < 0) |
|
|
if if(var9 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var5 != null) |
|
|
if if(var22 != 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(var7 >= 8) |
|
|
if if(var6 != 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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var11 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var22 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Float2ObjectConcurrentHashMap.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(this.next == null) |
|
|
if if(var1 instanceof it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry) |
|
|
if if(var1 instanceof it.unimi.dsi.fastutil.floats.Float2ObjectMap.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(var2 != 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(var4.hash == var1) |
|
|
if if(var4.key == var2 || var7 != this.EMPTY && var2 == var7) |
|
|
if if(var6 < 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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Float2ObjectConcurrentHashMap.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 Float) |
|
|
if if(var1 == null) |
|
|
if if(var1 == null) |
|
|
if if(var2 != null) |
|
|
if if(this == var1) |
|
|
if if(var1 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Entry) |
|
|
if if(var2 != this.EMPTY) |
|
|
if if(var3.hash == var1) |
|
|
if if(var3.key == var2 || var4 != this.EMPTY && var2 == var4) |
|
|
if if(this.reducer != null) |
|
|
if if(var5.result != null) |
|
|
if if(this.reducer != null) |
|
|
if if(!var9) |
|
|
if if(var6.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var1 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(this.stack != null) |
|
|
if if(var4 != null) |
|
|
if if(this.stack != null) |
|
|
if if(var3 == null) |
|
|
if if(var9.hash > var7) |
|
|
if if(var10 <= 0) |
|
|
if if(var1) |
|
|
if if(var2 != this.EMPTY) |
|
|
if if(var3.hash == var1) |
|
|
if if(var3.key == var2 || var5 != this.EMPTY && var2 == var5) |
|
|
if if(this.waiter != null) |
|
|
if if(var6 == null) |
|
|
if if(var6.hash > var1) |
|
|
if if(var6.key == var2 || var9 != this.EMPTY && var2 == var9) |
|
|
if if(!var5) |
|
|
if if(var12 != null) |
|
|
if if(var7 <= 0) |
|
|
if if(!var16.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(var4.hash > var1) |
|
|
if if(var4.key == var2 || var7 != this.EMPTY && var2 == var7) |
|
|
if if(var9 == 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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var19 != null) |
|
|
if if(var11 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var41 != null) |
|
|
if if(var33 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var35 != null) |
|
|
if if(var27 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var20 != null) |
|
|
if if(var12 instanceof Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) |
|
|
if if(var21 != null) |
|
|
if if(var13 instanceof Float2ObjectConcurrentHashMap.TreeBin) |
|
|
if if(var7 == null) |
|
|
if if(var7 != null) |
|
|
if if(var13 == null) |
final |
Float2ObjectConcurrentHashMap.Node<V>[] |
initTableFloat2ObjectConcurrentHashMap.Node<V>[] initTable() |
|
protected double |
invoke0protected double invoke0() |
|
protected float |
invoke0protected float 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.floats.Float2ObjectMap.Entry<V>> |
iteratorpublic ObjectIterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> iterator() |
|
public FloatIterator |
iteratorpublic FloatIterator iterator() |
|
public final ObjectIterator<V> |
iteratorpublic final ObjectIterator<V> iterator() |
abstract |
public abstract ObjectIterator<E> |
iteratorpublic abstract ObjectIterator<E> iterator() |
public |
Float2ObjectConcurrentHashMap.KeySetView<V> |
keySetFloat2ObjectConcurrentHashMap.KeySetView<V> keySet() |
public |
Float2ObjectConcurrentHashMap.KeySetView<V> |
keySetFloat2ObjectConcurrentHashMap.KeySetView<V> keySet(V var1) |
|
protected final void |
lockRootprotected final void lockRoot() |
public |
long |
mappingCountlong mappingCount() |
public |
V |
mergeV merge(float var1, V var2, BiFunction<? super V, ? super V, ? extends V> var3) |
static |
FloatSet |
newKeySetFloatSet newKeySet() |
static |
Float2ObjectConcurrentHashMap.KeySetView<Boolean> |
newKeySetFloat2ObjectConcurrentHashMap.KeySetView<Boolean> newKeySet(int var0) |
|
public final Float2ObjectConcurrentHashMap.Entry<V> |
nextpublic final Float2ObjectConcurrentHashMap.Entry<V> next() |
|
public final V |
nextpublic final V next() |
|
public final V |
nextElementpublic final V nextElement() |
|
public final float |
nextFloatpublic final float nextFloat() |
|
protected void |
pushStateprotected void pushState(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
|
protected void |
pushStateprotected void pushState(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
|
protected void |
pushStateprotected void pushState(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) |
public |
V |
putV put(float var1, V var2) |
public |
void |
putAllvoid putAll(Map<? extends Float, ? extends V> var1) |
public |
void |
putAllvoid putAll(Float2ObjectConcurrentHashMap<? extends V> var1) |
public |
void |
putAllvoid putAll(Float2ObjectMap<V> var1) |
public |
V |
putIfAbsentV putIfAbsent(float var1, V var2) |
|
protected final Float2ObjectConcurrentHashMap.TreeNode<V> |
putTreeValprotected final Float2ObjectConcurrentHashMap.TreeNode<V> putTreeVal(int var1, float var2, V var3) |
final |
V |
putValV putVal(float var1, V var2, boolean var3) |
|
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, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
<U> U |
reduce<U> U reduce(Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var1, BiFunction<? super U, ? super U, ? extends U> var2) |
abstract |
float |
reducefloat reduce(float var1, float var2, float var3) |
public |
Float2ObjectConcurrentHashMap.Entry<V> |
reduceEntriesFloat2ObjectConcurrentHashMap.Entry<V> reduceEntries(long var1,
BiFunction<Float2ObjectConcurrentHashMap.Entry<V>, Float2ObjectConcurrentHashMap.Entry<V>, ? extends Float2ObjectConcurrentHashMap.Entry<V>> var3) |
public |
<U> U |
reduceEntries<U> U reduceEntries(long var1, Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
double |
reduceEntriesToDoubledouble reduceEntriesToDouble(long var1, ToDoubleFunction<Float2ObjectConcurrentHashMap.Entry<V>> var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceEntriesToIntint reduceEntriesToInt(long var1, ToIntFunction<Float2ObjectConcurrentHashMap.Entry<V>> var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceEntriesToLonglong reduceEntriesToLong(long var1, ToLongFunction<Float2ObjectConcurrentHashMap.Entry<V>> var3, long var4, LongBinaryOperator var6) |
public |
float |
reduceKeysfloat reduceKeys(long var1, Float2ObjectConcurrentHashMap.FloatReduceTaskOperator var3) |
public |
<U> U |
reduceKeys<U> U reduceKeys(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? extends U> var3, BiFunction<? super U, ? super U, ? extends U> var4) |
public |
double |
reduceKeysToDoubledouble reduceKeysToDouble(long var1, Float2ObjectConcurrentHashMap.FloatToDoubleFunction var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceKeysToIntint reduceKeysToInt(long var1, Float2ObjectConcurrentHashMap.FloatToIntFunction var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceKeysToLonglong reduceKeysToLong(long var1, Float2ObjectConcurrentHashMap.FloatToLongFunction var3, long var4, LongBinaryOperator var6) |
public |
double |
reduceToDoubledouble reduceToDouble(long var1, Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction<? super V> var3, double var4, DoubleBinaryOperator var6) |
public |
int |
reduceToIntint reduceToInt(long var1, Float2ObjectConcurrentHashMap.ToIntFloatObjFunction<? super V> var3, int var4, IntBinaryOperator var5) |
public |
long |
reduceToLonglong reduceToLong(long var1, Float2ObjectConcurrentHashMap.ToLongFloatObjFunction<? 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, 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(float var1) |
public |
boolean |
removeboolean remove(float var1, Object var2) |
|
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(float 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(FloatCollection var1) |
|
public boolean |
removeAllpublic boolean removeAll(float[] var1) |
|
protected final boolean |
removeTreeNodeprotected final boolean removeTreeNode(Float2ObjectConcurrentHashMap.TreeNode<V> var1) |
public |
boolean |
replaceboolean replace(float var1, V var2, V var3) |
public |
V |
replaceV replace(float var1, V var2) |
public |
void |
replaceAllvoid replaceAll(Float2ObjectOperator<V> var1) |
final |
V |
replaceNodeV replaceNode(float var1, V var2, Object var3) |
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(FloatCollection var1) |
|
public boolean |
retainAllpublic boolean retainAll(float[] var1) |
|
protected <V> Float2ObjectConcurrentHashMap.TreeNode<V> |
rotateLeftprotected <V> Float2ObjectConcurrentHashMap.TreeNode<V> rotateLeft(Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) |
|
protected <V> Float2ObjectConcurrentHashMap.TreeNode<V> |
rotateRightprotected <V> Float2ObjectConcurrentHashMap.TreeNode<V> rotateRight(Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) |
public |
<U> U |
search<U> U search(long var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var3) |
public |
<U> U |
search<U> U search(Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? extends U> var1) |
public |
<U, X> U |
search<U, X> U search(Float2ObjectConcurrentHashMap.FloatBiObjFunction<? super V, X, ? extends U> var1, X var2) |
public |
<U> U |
searchEntries<U> U searchEntries(long var1, Function<Float2ObjectConcurrentHashMap.Entry<V>, ? extends U> var3) |
public |
<U> U |
searchKeys<U> U searchKeys(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? 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(Float2ObjectConcurrentHashMap.FloatObjByteFunction<? super V, ? extends U> var1, byte var2) |
public |
<U> U |
searchWithDouble<U> U searchWithDouble(Float2ObjectConcurrentHashMap.FloatObjDoubleFunction<? super V, ? extends U> var1, double var2) |
public |
<U> U |
searchWithFloat<U> U searchWithFloat(Float2ObjectConcurrentHashMap.FloatObjFloatFunction<? super V, ? extends U> var1, float var2) |
public |
<U> U |
searchWithInt<U> U searchWithInt(Float2ObjectConcurrentHashMap.FloatObjIntFunction<? super V, ? extends U> var1, int var2) |
public |
<U> U |
searchWithLong<U> U searchWithLong(Float2ObjectConcurrentHashMap.FloatObjLongFunction<? super V, ? extends U> var1, long var2) |
public |
<U> U |
searchWithShort<U> U searchWithShort(Float2ObjectConcurrentHashMap.FloatObjShortFunction<? super V, ? extends U> var1, short var2) |
final |
<V> void |
setTabAt<V> void setTabAt(Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Float2ObjectConcurrentHashMap.Node<V> var2) |
abstract |
|
setTabAt setTabAt(var5, var8, var13.next) |
abstract |
|
setTabAt setTabAt(var4, var3++, null) |
abstract |
|
setTabAt setTabAt(var6, var9, var26) |
abstract |
|
setTabAt setTabAt(var7, var10, var16) |
abstract |
|
setTabAt setTabAt(var7, var10, var26) |
abstract |
|
setTabAt setTabAt(var8, var11, var17) |
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.floats.Float2ObjectMap.Entry<V>> |
spliteratorpublic ObjectSpliterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> spliterator() |
|
public FloatSpliterator |
spliteratorpublic FloatSpliterator 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(var2, var3, var4, var5, var6) |
abstract |
|
super super(var1, -3, var1, null, null) |
abstract |
|
super super(var1, -2, var1, null, null) |
|
|
synchronized synchronized(var7) |
|
|
synchronized synchronized(var6) |
|
|
synchronized synchronized(var6) |
|
|
synchronized synchronized(var24) |
|
|
synchronized synchronized(var7) |
|
|
synchronized synchronized(var8) |
|
|
synchronized synchronized(var12) |
|
|
synchronized synchronized(var8) |
|
|
synchronized synchronized(var9) |
|
|
synchronized synchronized(var11) |
|
|
synchronized synchronized(var3) |
final |
<V> Float2ObjectConcurrentHashMap.Node<V> |
tabAt<V> Float2ObjectConcurrentHashMap.Node<V> tabAt(Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1) |
final |
int |
tableSizeForint tableSizeFor(int var0) |
abstract |
|
this this(var1, true, -1.0F) |
abstract |
|
this this(var1, var2, 1, -1.0F) |
|
protected int |
tieBreakOrderprotected int tieBreakOrder(float var1, float var2) |
|
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 float[] |
toArraypublic float[] toArray(float[] var1) |
|
public float[] |
toFloatArraypublic float[] toFloatArray() |
|
public float[] |
toFloatArraypublic float[] toFloatArray(float[] 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(Float2ObjectConcurrentHashMap.Node<V>[] var1, Float2ObjectConcurrentHashMap.Node<V>[] var2) |
final |
void |
treeifyBinvoid treeifyBin(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super Float> var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(FloatConsumer var1) |
|
public boolean |
tryAdvancepublic boolean tryAdvance(Consumer<? super V> var1) |
final |
void |
tryPresizevoid tryPresize(int var1) |
|
public ObjectSpliterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> |
trySplitpublic ObjectSpliterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> trySplit() |
|
public FloatSpliterator |
trySplitpublic FloatSpliterator trySplit() |
|
public ObjectSpliterator<V> |
trySplitpublic ObjectSpliterator<V> trySplit() |
|
protected final void |
unlockRootprotected final void unlockRoot() |
protected |
<V> Float2ObjectConcurrentHashMap.Node<V> |
untreeify<V> Float2ObjectConcurrentHashMap.Node<V> untreeify(Float2ObjectConcurrentHashMap.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(var4 != null) |
|
|
while while(true) |
|
|
while while(var3 != 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.floats;
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.floats.Float2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.floats.FloatCollection;
class="kw">import it.unimi.dsi.fastutil.floats.FloatConsumer;
class="kw">import it.unimi.dsi.fastutil.floats.FloatIterator;
class="kw">import it.unimi.dsi.fastutil.floats.FloatSet;
class="kw">import it.unimi.dsi.fastutil.floats.FloatSpliterator;
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.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.ToDoubleFunction;
class="kw">import java.util.function.ToIntFunction;
class="kw">import java.util.function.ToLongFunction;
class="kw">import sun.misc.Unsafe;
class="kw">public class Float2ObjectConcurrentHashMap<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 Float2ObjectConcurrentHashMap.Node<V>[] table;
class="kw">protected class="kw">transient class="kw">volatile Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.CounterCell[] counterCells;
class="kw">protected class="kw">transient Float2ObjectConcurrentHashMap.KeySetView<V> keySet;
class="kw">protected class="kw">transient Float2ObjectConcurrentHashMap.ValuesView<V> values;
class="kw">protected class="kw">transient Float2ObjectConcurrentHashMap.EntrySetView<V> entrySet;
class="kw">protected class="kw">final float 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> Float2ObjectConcurrentHashMap.Node<V> tabAt(Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1) {
class="kw">return (Float2ObjectConcurrentHashMap.Node<V>)U.getObjectVolatile(var0, ((long)var1 << ASHIFT) + ABASE);
}
class="kw">protected class="kw">static class="kw">final <V> boolean casTabAt(
Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Float2ObjectConcurrentHashMap.Node<V> var2, Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node<V>[] var0, int var1, Float2ObjectConcurrentHashMap.Node<V> var2) {
U.putObjectVolatile(var0, ((long)var1 << ASHIFT) + ABASE, var2);
}
class="kw">public Float2ObjectConcurrentHashMap() {
this.EMPTY = -1.0F;
}
class="kw">public Float2ObjectConcurrentHashMap(boolean var1, float var2) {
this.EMPTY = var2;
}
class="kw">public Float2ObjectConcurrentHashMap(int var1) {
this(var1, true, -1.0F);
}
class="kw">public Float2ObjectConcurrentHashMap(int var1, boolean var2, float var3) {
if (var1 < 0) {
throw new IllegalArgumentException();
}
int var4 = var1 >= 536870912 ? 1073741824 : tableSizeFor(var1 + (var1 >>> 1) + 1);
this.sizeCtl = var4;
this.EMPTY = var3;
}
class="kw">public Float2ObjectConcurrentHashMap(Map<? class="kw">extends Float, ? class="kw">extends V> var1, float var2) {
this.sizeCtl = 16;
this.EMPTY = var2;
this.putAll(var1);
}
class="kw">public Float2ObjectConcurrentHashMap(Float2ObjectConcurrentHashMap<? class="kw">extends V> var1) {
this.sizeCtl = 16;
this.EMPTY = var1.EMPTY;
this.putAll(var1);
}
class="kw">public Float2ObjectConcurrentHashMap(Float2ObjectMap<V> var1) {
this.sizeCtl = 16;
this.EMPTY = -1.0F;
this.putAll(var1);
}
class="kw">public Float2ObjectConcurrentHashMap(Float2ObjectMap<V> var1, float var2) {
this.sizeCtl = 16;
this.EMPTY = var2;
this.putAll(var1);
}
class="kw">public Float2ObjectConcurrentHashMap(int var1, float var2) {
this(var1, var2, 1, -1.0F);
}
class="kw">public Float2ObjectConcurrentHashMap(int var1, float var2, int var3, float var4) {
if (var2 > 0.0F && var1 >= 0 && var3 > 0) {
if (var1 < var3) {
var1 = var3;
}
long var5 = (long)(1.0 + (float)var1 / var2);
int var7 = var5 >= 1073741824L ? 1073741824 : tableSizeFor((int)var5);
this.sizeCtl = var7;
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(float var1) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
int var8 = spread(Float.hashCode(var1));
Float2ObjectConcurrentHashMap.Node[] var2 = this.table;
Float2ObjectConcurrentHashMap.Node var3;
int var5;
if (this.table != null && (var5 = var2.length) > 0 && (var3 = tabAt(var2, var5 - 1 & var8)) != null) {
int var6 = var3.hash;
if (var3.hash == var8) {
float var7 = var3.key;
if (var3.key == var1 || var7 != this.EMPTY && var1 == var7) {
class="kw">return var3.val;
}
} else if (var6 < 0) {
Float2ObjectConcurrentHashMap.Node var4;
class="kw">return (var4 = var3.find(var8, var1)) != null ? var4.val : null;
}
while ((var3 = var3.next) != null) {
if (var3.hash == var8) {
float var9 = var3.key;
if (var3.key == var1 || var9 != this.EMPTY && var1 == var9) {
class="kw">return var3.val;
}
}
}
}
class="kw">return null;
}
class="kw">public boolean containsKey(float var1) {
class="kw">return this.get(var1) != null;
}
class="kw">public boolean containsValue(Object var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = var2;
Float2ObjectConcurrentHashMap.Node var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Float2ObjectConcurrentHashMap.Node var11 = null;
var11 = var4;
if (var4 != null) {
var11 = var11.next;
}
label85:
while (true) {
if (var11 != null) {
var4 = var11;
break;
}
if (var8 < var9) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Float2ObjectConcurrentHashMap.TableStack var20 = var6;
if (var20 != null) {
var6 = var20.next;
} else {
var20 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var12;
var20.length = var14;
var20.index = var13;
var20.next = var5;
var5 = var20;
class="kw">continue;
}
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Float2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
class="kw">continue;
}
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(float var1, V var2) {
class="kw">return this.putVal(var1, var2, false);
}
class="kw">protected class="kw">final V putVal(float var1, V var2, boolean var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var2 == null) {
throw new NullPointerException();
}
int var4 = spread(Float.hashCode(var1));
int var5 = 0;
Float2ObjectConcurrentHashMap.Node[] var6 = this.table;
while (true) {
int var8;
while (var6 == null || (var8 = var6.length) == 0) {
var6 = this.initTable();
}
Float2ObjectConcurrentHashMap.Node var7;
int var9;
if ((var7 = tabAt(var6, var9 = var8 - 1 & var4)) == null) {
if (casTabAt(var6, var9, null, new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var2, null))) {
break;
}
} else {
int var10 = var7.hash;
if (var7.hash == -1) {
var6 = this.helpTransfer(var6, var7);
} else {
Object var11 = null;
class="kw">synchronized (var7) {
if (tabAt(var6, var9) == var7) {
if (var10 < 0) {
if (var7 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var5 = 2;
Float2ObjectConcurrentHashMap.Node var18;
if ((var18 = ((Float2ObjectConcurrentHashMap.TreeBin)var7).putTreeVal(var4, var1, var2)) != null) {
var11 = var18.val;
if (!var3) {
var18.val = var2;
}
}
}
} else {
var5 = 1;
Float2ObjectConcurrentHashMap.Node var13 = var7;
while (true) {
if (var13.hash == var4) {
float var14 = var13.key;
if (var13.key == var1 || var14 != this.EMPTY && var1 == var14) {
var11 = var13.val;
if (!var3) {
var13.val = var2;
}
break;
}
}
Float2ObjectConcurrentHashMap.Node var15 = var13;
if ((var13 = var13.next) == null) {
var15.next = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var2, null);
break;
}
var5++;
}
}
}
}
if (var5 != 0) {
if (var5 >= 8) {
this.treeifyBin(var6, var9);
}
if (var11 != null) {
class="kw">return var11;
}
break;
}
}
}
}
this.addCount(1L, var5);
class="kw">return null;
}
class="kw">public void putAll(Map<? class="kw">extends Float, ? 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(Float2ObjectConcurrentHashMap<? class="kw">extends V> var1) {
this.tryPresize(var1.size());
ObjectIterator var2 = var1.float2ObjectEntrySet().iterator();
while (var2.hasNext()) {
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var3 = (it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<? class="kw">extends V>)var2.next();
this.putVal(var3.getFloatKey(), (V)var3.getValue(), false);
}
}
class="kw">public void putAll(Float2ObjectMap<V> var1) {
this.tryPresize(var1.size());
ObjectIterator var2 = var1.float2ObjectEntrySet().iterator();
while (var2.hasNext()) {
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var3 = (it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<? class="kw">extends V>)var2.next();
this.putVal(var3.getFloatKey(), (V)var3.getValue(), false);
}
}
class="kw">public V remove(float var1) {
class="kw">return this.replaceNode(var1, null, null);
}
@Deprecated
class="kw">public V remove(Float var1) {
class="kw">return this.replaceNode(var1, null, null);
}
@Deprecated
class="kw">public V remove(Object var1) {
class="kw">return this.remove((Float)var1);
}
class="kw">protected class="kw">final V replaceNode(float var1, V var2, Object var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
int var4 = spread(Float.hashCode(var1));
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
Float2ObjectConcurrentHashMap.Node var6;
int var7;
int var8;
while (var5 != null && (var7 = var5.length) != 0 && (var6 = tabAt(var5, var8 = var7 - 1 & var4)) != null) {
int var9 = var6.hash;
if (var6.hash == -1) {
var5 = this.helpTransfer(var5, var6);
} else {
Object var10 = null;
boolean var11 = false;
class="kw">synchronized (var6) {
if (tabAt(var5, var8) == var6) {
if (var9 < 0) {
if (var6 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = true;
Float2ObjectConcurrentHashMap.TreeBin var19 = (Float2ObjectConcurrentHashMap.TreeBin<V>)var6;
Float2ObjectConcurrentHashMap.TreeNode var20 = var19.root;
Float2ObjectConcurrentHashMap.TreeNode var21;
if (var19.root != null && (var21 = var20.findTreeNode(var4, var1, null)) != null) {
Object var22 = var21.val;
if (var3 == null || var3 == var22 || var22 != null && var3.equals(var22)) {
var10 = var22;
if (var2 != null) {
var21.val = var2;
} else if (var19.removeTreeNode(var21)) {
setTabAt(var5, var8, this.untreeify(var19.first));
}
}
}
}
} else {
var11 = true;
Float2ObjectConcurrentHashMap.Node var13 = var6;
Float2ObjectConcurrentHashMap.Node var14 = null;
do {
if (var13.hash == var4) {
float var15 = var13.key;
if (var13.key == var1 || var15 != this.EMPTY && var1 == var15) {
Object var16 = var13.val;
if (var3 == null || var3 == var16 || var16 != null && var3.equals(var16)) {
var10 = var16;
if (var2 != null) {
var13.val = var2;
} else if (var14 != null) {
var14.next = var13.next;
} else {
setTabAt(var5, var8, var13.next);
}
}
break;
}
}
var14 = var13;
} while ((var13 = var13.next) != null);
}
}
}
if (var11) {
if (var10 != null) {
if (var2 == null) {
this.addCount(-1L, -1);
}
class="kw">return var10;
}
break;
}
}
}
class="kw">return null;
}
class="kw">public void clear() {
long var1 = 0L;
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
while (var4 != null && var3 < var4.length) {
Float2ObjectConcurrentHashMap.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 (Float2ObjectConcurrentHashMap.Node var8 = var5 >= 0
? var6
: (var6 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin ? ((Float2ObjectConcurrentHashMap.TreeBin)var6).first : null);
var8 != null;
var8 = var8.next
) {
var1--;
}
setTabAt(var4, var3++, null);
}
}
}
}
}
if (var1 != 0L) {
this.addCount(var1, -1);
}
}
class="kw">public Float2ObjectConcurrentHashMap.KeySetView<V> keySet() {
Float2ObjectConcurrentHashMap.KeySetView var1 = this.keySet;
class="kw">return this.keySet != null ? var1 : (this.keySet = this.buildKeySetView());
}
class="kw">protected Float2ObjectConcurrentHashMap.KeySetView<V> buildKeySetView() {
class="kw">return new Float2ObjectConcurrentHashMap.KeySetView<>(this, null);
}
class="kw">public FastCollection<V> values() {
Float2ObjectConcurrentHashMap.ValuesView var1 = this.values;
class="kw">return this.values != null ? var1 : (this.values = this.buildValuesView());
}
class="kw">protected Float2ObjectConcurrentHashMap.ValuesView<V> buildValuesView() {
class="kw">return new Float2ObjectConcurrentHashMap.ValuesView<>(this);
}
class="kw">public ObjectSet<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> float2ObjectEntrySet() {
Float2ObjectConcurrentHashMap.EntrySetView var1 = this.entrySet;
class="kw">return this.entrySet != null ? var1 : (this.entrySet = this.buildEntrySetView());
}
@Deprecated
class="kw">public ObjectSet<Map.Entry<Float, V>> entrySet() {
class="kw">return this.float2ObjectEntrySet();
}
class="kw">protected Float2ObjectConcurrentHashMap.EntrySetView<V> buildEntrySetView() {
class="kw">return new Float2ObjectConcurrentHashMap.EntrySetView<>(this);
}
@Override
class="kw">public int hashCode() {
int var1 = 0;
Float2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = var2;
Float2ObjectConcurrentHashMap.Node var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Float2ObjectConcurrentHashMap.TableStack var19 = var6;
if (var19 != null) {
var6 = var19.next;
} else {
var19 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var12;
var19.length = var14;
var19.index = var13;
var19.next = var5;
var5 = var19;
class="kw">continue;
}
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Float2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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 += Float.hashCode(var11.key) ^ var11.val.hashCode();
}
}
class="kw">return var1;
}
@Override
class="kw">public String toString() {
Float2ObjectConcurrentHashMap.Node[] var1 = this.table;
int var2 = this.table == null ? 0 : var1.length;
Float2ObjectConcurrentHashMap.Traverser var3 = new Float2ObjectConcurrentHashMap.Traverser<>(var1, var2, 0, var2);
StringBuilder var4 = new StringBuilder();
var4.append('{');
Float2ObjectConcurrentHashMap.Node var5;
if ((var5 = var3.advance()) != null) {
while (true) {
float var6 = var5.key;
Object var7 = var5.val;
var4.append(var6);
var4.append('=');
var4.append(var7 == this ? "(this Map)" : var7);
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 Float2ObjectConcurrentHashMap var2)) {
class="kw">return false;
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
int var4 = this.table == null ? 0 : var3.length;
Float2ObjectConcurrentHashMap.Traverser var5 = new Float2ObjectConcurrentHashMap.Traverser<>(var3, var4, 0, var4);
Float2ObjectConcurrentHashMap.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 var11 = var2.float2ObjectEntrySet().iterator();
while (var11.hasNext()) {
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var12 = (it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<?>)var11.next();
Object var9;
Object var10;
float var13;
if ((var13 = var12.getFloatKey()) == var2.EMPTY
|| (var9 = var12.getValue()) == null
|| (var10 = this.get(var13)) == null
|| var9 != var10 && !var9.equals(var10)) {
class="kw">return false;
}
}
}
class="kw">return true;
}
class="kw">public V putIfAbsent(float var1, V var2) {
class="kw">return this.putVal(var1, var2, true);
}
class="kw">public boolean remove(float var1, Object var2) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else {
class="kw">return var2 != null && this.replaceNode(var1, null, var2) != null;
}
}
class="kw">public boolean replace(float var1, V var2, V var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else if (var2 != null && var3 != null) {
class="kw">return this.replaceNode(var1, var3, var2) != null;
} else {
throw new NullPointerException();
}
}
class="kw">public V replace(float var1, V var2) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
} else if (var2 == null) {
throw new NullPointerException();
} else {
class="kw">return this.replaceNode(var1, var2, null);
}
}
class="kw">public V getOrDefault(float var1, V var2) {
Object var3;
class="kw">return (var3 = this.get(var1)) == null ? var2 : var3;
}
class="kw">public int forEach(Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
int var2 = 0;
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjConsumer<? super V, X> var1, X var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatTriObjConsumer<? super V, X, Y> var1, X var2, Y var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjByteConsumer<? super V> var1, byte var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjShortConsumer<? super V> var1, short var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjIntConsumer<? super V> var1, int var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjLongConsumer<? super V> var1, long var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjFloatConsumer<? super V> var1, float var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var3 = 0;
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjDoubleConsumer<? super V> var1, double var2) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjByteConsumer<? super V, X> var1, byte var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjShortConsumer<? super V, X> var1, short var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjIntConsumer<? super V, X> var1, int var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjLongConsumer<? super V, X> var1, long var2, X var4) {
if (var1 == null) {
throw new NullPointerException();
}
int var5 = 0;
Float2ObjectConcurrentHashMap.Node[] var6 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var7 = var6;
Float2ObjectConcurrentHashMap.Node var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
Float2ObjectConcurrentHashMap.TableStack var10 = null;
int var11 = 0;
int var12 = 0;
int var13 = var6.length;
int var14 = var6.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var7 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var15).nextTable;
var15 = null;
Float2ObjectConcurrentHashMap.TableStack var23 = var10;
if (var23 != null) {
var10 = var23.next;
} else {
var23 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var23.tab = var16;
var23.length = var18;
var23.index = var17;
var23.next = var9;
var9 = var23;
class="kw">continue;
}
if (var15 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var15 = ((Float2ObjectConcurrentHashMap.TreeBin)var15).first;
} else {
var15 = null;
}
}
if (var9 == null) {
if ((var11 = var17 + var14) >= var18) {
var11 = ++var12;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjFloatConsumer<? super V, X> var1, float var2, X var3) {
if (var1 == null) {
throw new NullPointerException();
}
int var4 = 0;
Float2ObjectConcurrentHashMap.Node[] var5 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var6 = var5;
Float2ObjectConcurrentHashMap.Node var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
int var10 = 0;
int var11 = 0;
int var12 = var5.length;
int var13 = var5.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var6 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var14).nextTable;
var14 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var9;
if (var22 != null) {
var9 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var15;
var22.length = var17;
var22.index = var16;
var22.next = var8;
var8 = var22;
class="kw">continue;
}
if (var14 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var14 = ((Float2ObjectConcurrentHashMap.TreeBin)var14).first;
} else {
var14 = null;
}
}
if (var8 == null) {
if ((var10 = var16 + var13) >= var17) {
var10 = ++var11;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjDoubleConsumer<? super V, X> var1, double var2, X var4) {
if (var1 == null) {
throw new NullPointerException();
}
int var5 = 0;
Float2ObjectConcurrentHashMap.Node[] var6 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var7 = var6;
Float2ObjectConcurrentHashMap.Node var8 = null;
Float2ObjectConcurrentHashMap.TableStack var9 = null;
Float2ObjectConcurrentHashMap.TableStack var10 = null;
int var11 = 0;
int var12 = 0;
int var13 = var6.length;
int var14 = var6.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var7 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var15).nextTable;
var15 = null;
Float2ObjectConcurrentHashMap.TableStack var23 = var10;
if (var23 != null) {
var10 = var23.next;
} else {
var23 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var23.tab = var16;
var23.length = var18;
var23.index = var17;
var23.next = var9;
var9 = var23;
class="kw">continue;
}
if (var15 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var15 = ((Float2ObjectConcurrentHashMap.TreeBin)var15).first;
} else {
var15 = null;
}
}
if (var9 == null) {
if ((var11 = var17 + var14) >= var18) {
var11 = ++var12;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectOperator<V> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = var2;
Float2ObjectConcurrentHashMap.Node var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var6;
if (var22 != null) {
var6 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var12;
var22.length = var14;
var22.index = var13;
var22.next = var5;
var5 = var22;
class="kw">continue;
}
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Float2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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;
float var20 = var11.key;
Object var21;
do {
var21 = var1.apply(var20, var19);
if (var21 == null) {
throw new NullPointerException();
}
} while (this.replaceNode(var20, var21, var19) == null && (var19 = this.get(var20)) != null);
}
}
}
class="kw">public V computeIfAbsent(float var1, Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends V> var2) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var2 == null) {
throw new NullPointerException();
}
int var3 = spread(Float.hashCode(var1));
Object var4 = null;
int var5 = 0;
Float2ObjectConcurrentHashMap.Node[] var6 = this.table;
while (true) {
int var8;
while (var6 == null || (var8 = var6.length) == 0) {
var6 = this.initTable();
}
Float2ObjectConcurrentHashMap.Node var7;
int var9;
if ((var7 = tabAt(var6, var9 = var8 - 1 & var3)) == null) {
Float2ObjectConcurrentHashMap.Node var24 = new Float2ObjectConcurrentHashMap.ReservationNode<>(this.EMPTY);
class="kw">synchronized (var24) {
if (casTabAt(var6, var9, null, var24)) {
var5 = 1;
Float2ObjectConcurrentHashMap.Node var26 = null;
try {
if ((var4 = (V)var2.apply(var1)) != null) {
var26 = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var3, var1, var4, null);
}
} class="kw">finally {
setTabAt(var6, var9, var26);
}
}
}
if (var5 != 0) {
break;
}
} else {
int var10 = var7.hash;
if (var7.hash == -1) {
var6 = this.helpTransfer(var6, var7);
} else {
boolean var11 = false;
class="kw">synchronized (var7) {
if (tabAt(var6, var9) == var7) {
if (var10 < 0) {
if (var7 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var5 = 2;
Float2ObjectConcurrentHashMap.TreeBin var25 = (Float2ObjectConcurrentHashMap.TreeBin<V>)var7;
Float2ObjectConcurrentHashMap.TreeNode var27 = var25.root;
Float2ObjectConcurrentHashMap.TreeNode var15;
if (var25.root != null && (var15 = var27.findTreeNode(var3, var1, null)) != null) {
var4 = var15.val;
} else if ((var4 = (V)var2.apply(var1)) != null) {
var11 = true;
var25.putTreeVal(var3, var1, var4);
}
}
} else {
var5 = 1;
Float2ObjectConcurrentHashMap.Node var13 = var7;
while (true) {
if (var13.hash == var3) {
float var14 = var13.key;
if (var13.key == var1 || var14 != this.EMPTY && var1 == var14) {
var4 = var13.val;
break;
}
}
Float2ObjectConcurrentHashMap.Node var16 = var13;
if ((var13 = var13.next) == null) {
if ((var4 = (V)var2.apply(var1)) != null) {
var11 = true;
var16.next = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var3, var1, var4, null);
}
break;
}
var5++;
}
}
}
}
if (var5 != 0) {
if (var5 >= 8) {
this.treeifyBin(var6, var9);
}
if (!var11) {
class="kw">return var4;
}
break;
}
}
}
}
if (var4 != null) {
this.addCount(1L, var5);
}
class="kw">return var4;
}
class="kw">public V computeIfPresent(float var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends V> var2) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var2 == null) {
throw new NullPointerException();
}
int var3 = spread(Float.hashCode(var1));
Object var4 = null;
int var5 = 0;
int var6 = 0;
Float2ObjectConcurrentHashMap.Node[] var7 = this.table;
while (true) {
int var9;
while (var7 == null || (var9 = var7.length) == 0) {
var7 = this.initTable();
}
Float2ObjectConcurrentHashMap.Node var8;
int var10;
if ((var8 = tabAt(var7, var10 = var9 - 1 & var3)) == null) {
break;
}
int var11 = var8.hash;
if (var8.hash == -1) {
var7 = this.helpTransfer(var7, var8);
} else {
class="kw">synchronized (var8) {
if (tabAt(var7, var10) == var8) {
if (var11 < 0) {
if (var8 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var6 = 2;
Float2ObjectConcurrentHashMap.TreeBin var19 = (Float2ObjectConcurrentHashMap.TreeBin<V>)var8;
Float2ObjectConcurrentHashMap.TreeNode var20 = var19.root;
Float2ObjectConcurrentHashMap.TreeNode var21;
if (var19.root != null && (var21 = var20.findTreeNode(var3, var1, null)) != null) {
var4 = (V)var2.apply(var1, var21.val);
if (var4 != null) {
var21.val = var4;
} else {
var5 = -1;
if (var19.removeTreeNode(var21)) {
setTabAt(var7, var10, this.untreeify(var19.first));
}
}
}
}
} else {
var6 = 1;
Float2ObjectConcurrentHashMap.Node var13 = var8;
Float2ObjectConcurrentHashMap.Node var14 = null;
while (true) {
if (var13.hash == var3) {
float var15 = var13.key;
if (var13.key == var1 || var15 != this.EMPTY && var1 == var15) {
var4 = (V)var2.apply(var1, var13.val);
if (var4 != null) {
var13.val = var4;
} else {
var5 = -1;
Float2ObjectConcurrentHashMap.Node var16 = var13.next;
if (var14 != null) {
var14.next = var16;
} else {
setTabAt(var7, var10, var16);
}
}
break;
}
}
var14 = var13;
if ((var13 = var13.next) == null) {
break;
}
var6++;
}
}
}
}
if (var6 != 0) {
break;
}
}
}
if (var5 != 0) {
this.addCount(var5, var6);
}
class="kw">return var4;
}
class="kw">public V compute(float var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends V> var2) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var2 == null) {
throw new NullPointerException();
}
int var3 = spread(Float.hashCode(var1));
Object var4 = null;
int var5 = 0;
int var6 = 0;
Float2ObjectConcurrentHashMap.Node[] var7 = this.table;
while (true) {
int var9;
while (var7 == null || (var9 = var7.length) == 0) {
var7 = this.initTable();
}
Float2ObjectConcurrentHashMap.Node var8;
int var10;
if ((var8 = tabAt(var7, var10 = var9 - 1 & var3)) == null) {
Float2ObjectConcurrentHashMap.Node var12 = new Float2ObjectConcurrentHashMap.ReservationNode<>(this.EMPTY);
class="kw">synchronized (var12) {
if (casTabAt(var7, var10, null, var12)) {
var6 = 1;
Float2ObjectConcurrentHashMap.Node var26 = null;
try {
if ((var4 = (V)var2.apply(var1, null)) != null) {
var5 = 1;
var26 = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var3, var1, var4, null);
}
} class="kw">finally {
setTabAt(var7, var10, var26);
}
}
}
if (var6 != 0) {
break;
}
} else {
int var11 = var8.hash;
if (var8.hash == -1) {
var7 = this.helpTransfer(var7, var8);
} else {
class="kw">synchronized (var8) {
if (tabAt(var7, var10) == var8) {
if (var11 < 0) {
if (var8 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var6 = 1;
Float2ObjectConcurrentHashMap.TreeBin var24 = (Float2ObjectConcurrentHashMap.TreeBin<V>)var8;
Float2ObjectConcurrentHashMap.TreeNode var25 = var24.root;
Float2ObjectConcurrentHashMap.TreeNode var27;
if (var24.root != null) {
var27 = var25.findTreeNode(var3, var1, null);
} else {
var27 = null;
}
Object var28 = var27 == null ? null : var27.val;
var4 = (V)var2.apply(var1, var28);
if (var4 != null) {
if (var27 != null) {
var27.val = var4;
} else {
var5 = 1;
var24.putTreeVal(var3, var1, var4);
}
} else if (var27 != null) {
var5 = -1;
if (var24.removeTreeNode(var27)) {
setTabAt(var7, var10, this.untreeify(var24.first));
}
}
}
} else {
var6 = 1;
Float2ObjectConcurrentHashMap.Node var13 = var8;
Float2ObjectConcurrentHashMap.Node var14 = null;
while (true) {
if (var13.hash == var3) {
float var15 = var13.key;
if (var13.key == var1 || var15 != this.EMPTY && var1 == var15) {
var4 = (V)var2.apply(var1, var13.val);
if (var4 != null) {
var13.val = var4;
} else {
var5 = -1;
Float2ObjectConcurrentHashMap.Node var16 = var13.next;
if (var14 != null) {
var14.next = var16;
} else {
setTabAt(var7, var10, var16);
}
}
break;
}
}
var14 = var13;
if ((var13 = var13.next) == null) {
var4 = (V)var2.apply(var1, null);
if (var4 != null) {
var5 = 1;
var14.next = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var3, var1, var4, null);
}
break;
}
var6++;
}
}
}
}
if (var6 != 0) {
if (var6 >= 8) {
this.treeifyBin(var7, var10);
}
break;
}
}
}
}
if (var5 != 0) {
this.addCount(var5, var6);
}
class="kw">return var4;
}
class="kw">public V merge(float var1, V var2, BiFunction<? super V, ? super V, ? class="kw">extends V> var3) {
if (var1 == this.EMPTY) {
throw new IllegalArgumentException("Key is EMPTY: " + this.EMPTY);
}
if (var2 != null && var3 != null) {
int var4 = spread(Float.hashCode(var1));
Object var5 = null;
int var6 = 0;
int var7 = 0;
Float2ObjectConcurrentHashMap.Node[] var8 = this.table;
while (true) {
int var10;
while (var8 == null || (var10 = var8.length) == 0) {
var8 = this.initTable();
}
Float2ObjectConcurrentHashMap.Node var9;
int var11;
if ((var9 = tabAt(var8, var11 = var10 - 1 & var4)) == null) {
if (casTabAt(var8, var11, null, new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var4, var1, var2, null))) {
var6 = 1;
var5 = var2;
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 Float2ObjectConcurrentHashMap.TreeBin) {
var7 = 2;
Float2ObjectConcurrentHashMap.TreeBin var20 = (Float2ObjectConcurrentHashMap.TreeBin<V>)var9;
Float2ObjectConcurrentHashMap.TreeNode var21 = var20.root;
Float2ObjectConcurrentHashMap.TreeNode var22 = var21 == null ? null : var21.findTreeNode(var4, var1, null);
var5 = var22 == null ? var2 : var3.apply(var22.val, var2);
if (var5 != null) {
if (var22 != null) {
var22.val = var5;
} else {
var6 = 1;
var20.putTreeVal(var4, var1, var5);
}
} else if (var22 != null) {
var6 = -1;
if (var20.removeTreeNode(var22)) {
setTabAt(var8, var11, this.untreeify(var20.first));
}
}
}
} else {
var7 = 1;
Float2ObjectConcurrentHashMap.Node var14 = var9;
Float2ObjectConcurrentHashMap.Node var15 = null;
while (true) {
if (var14.hash == var4) {
float var16 = var14.key;
if (var14.key == var1 || var16 != this.EMPTY && var1 == var16) {
var5 = (V)var3.apply(var14.val, var2);
if (var5 != null) {
var14.val = var5;
} else {
var6 = -1;
Float2ObjectConcurrentHashMap.Node var17 = var14.next;
if (var15 != null) {
var15.next = var17;
} else {
setTabAt(var8, var11, var17);
}
}
break;
}
}
var15 = var14;
if ((var14 = var14.next) == null) {
var6 = 1;
var5 = var2;
var15.next = new Float2ObjectConcurrentHashMap.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;
} 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 FloatSet newKeySet() {
class="kw">return new Float2ObjectConcurrentHashMap.KeySetView<>(new Float2ObjectConcurrentHashMap<>(), Boolean.TRUE);
}
class="kw">public class="kw">static Float2ObjectConcurrentHashMap.KeySetView<Boolean> newKeySet(int var0) {
class="kw">return new Float2ObjectConcurrentHashMap.KeySetView<>(new Float2ObjectConcurrentHashMap<>(var0), Boolean.TRUE);
}
class="kw">public Float2ObjectConcurrentHashMap.KeySetView<V> keySet(V var1) {
if (var1 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V>[] initTable() {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.Node[] var4 = new Float2ObjectConcurrentHashMap.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: {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V>[] helpTransfer(
Float2ObjectConcurrentHashMap.Node<V>[] var1, Float2ObjectConcurrentHashMap.Node<V> var2
) {
if (var1 != null && var2 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
Float2ObjectConcurrentHashMap.Node[] var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var2).nextTable;
if (((Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.Node[] var6 = new Float2ObjectConcurrentHashMap.Node[var5];
this.table = var6;
var3 = var5 - (var5 >>> 2);
}
} class="kw">finally {
this.sizeCtl = var3;
}
}
}
}
}
class="kw">protected class="kw">final void transfer(Float2ObjectConcurrentHashMap.Node<V>[] var1, Float2ObjectConcurrentHashMap.Node<V>[] var2) {
int var3 = var1.length;
int var4;
if ((var4 = NCPU > 1 ? (var3 >>> 3) / NCPU : var3) < 16) {
var4 = 16;
}
if (var2 == null) {
try {
Float2ObjectConcurrentHashMap.Node[] var5 = new Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.ForwardingNode var6 = new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.Node var17 = var11;
for (Float2ObjectConcurrentHashMap.Node var18 = var11.next; var18 != null; var18 = var18.next) {
int var19 = var18.hash & var3;
if (var19 != var16) {
var16 = var19;
var17 = var18;
}
}
Float2ObjectConcurrentHashMap.Node var14;
Float2ObjectConcurrentHashMap.Node var15;
if (var16 == 0) {
var14 = var17;
var15 = null;
} else {
var15 = var17;
var14 = null;
}
for (Float2ObjectConcurrentHashMap.Node var36 = var11; var36 != var17; var36 = var36.next) {
int var38 = var36.hash;
float var20 = var36.key;
Object var21 = var36.val;
if ((var38 & var3) == 0) {
var14 = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var38, var20, var21, var14);
} else {
var15 = new Float2ObjectConcurrentHashMap.Node<>(this.EMPTY, var38, var20, var21, var15);
}
}
setTabAt(var2, var9, var14);
setTabAt(var2, var9 + var3, var15);
setTabAt(var1, var9, var6);
var7 = true;
} else if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin var34) {
Float2ObjectConcurrentHashMap.TreeNode var35 = null;
Float2ObjectConcurrentHashMap.TreeNode var37 = null;
Float2ObjectConcurrentHashMap.TreeNode var39 = null;
Float2ObjectConcurrentHashMap.TreeNode var40 = null;
int var41 = 0;
int var22 = 0;
for (Float2ObjectConcurrentHashMap.Node var23 = var34.first; var23 != null; var23 = var23.next) {
int var24 = var23.hash;
Float2ObjectConcurrentHashMap.TreeNode var25 = new Float2ObjectConcurrentHashMap.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;
var41++;
} else {
if ((var25.prev = var40) == null) {
var39 = var25;
} else {
var40.next = var25;
}
var40 = var25;
var22++;
}
}
Float2ObjectConcurrentHashMap.Node var31 = var41 <= 6
? this.untreeify(var35)
: (var22 != 0 ? new Float2ObjectConcurrentHashMap.TreeBin<>(this.EMPTY, var35) : var34);
Float2ObjectConcurrentHashMap.Node var33 = var22 <= 6
? this.untreeify(var39)
: (var41 != 0 ? new Float2ObjectConcurrentHashMap.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() {
Float2ObjectConcurrentHashMap.CounterCell[] var1 = this.counterCells;
long var3 = this.baseCount;
if (var1 != null) {
for (int var5 = 0; var5 < var1.length; var5++) {
Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.CounterCell[] var6 = this.counterCells;
int var8;
if (this.counterCells != null && (var8 = var6.length) > 0) {
Float2ObjectConcurrentHashMap.CounterCell var7;
if ((var7 = var6[var8 - 1 & var4]) == null) {
if (this.cellsBusy == 0) {
Float2ObjectConcurrentHashMap.CounterCell var32 = new Float2ObjectConcurrentHashMap.CounterCell(var1);
if (this.cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean var34 = false;
try {
Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.CounterCell[] var33 = new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.CounterCell[] var12 = new Float2ObjectConcurrentHashMap.CounterCell[2];
var12[var4 & 1] = new Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2) {
if (var1 != null) {
int var4;
if ((var4 = var1.length) < 64) {
this.tryPresize(var4 << 1);
} else {
Float2ObjectConcurrentHashMap.Node var3;
if ((var3 = tabAt(var1, var2)) != null && var3.hash >= 0) {
class="kw">synchronized (var3) {
if (tabAt(var1, var2) == var3) {
Float2ObjectConcurrentHashMap.TreeNode var7 = null;
Float2ObjectConcurrentHashMap.TreeNode var8 = null;
for (Float2ObjectConcurrentHashMap.Node var9 = var3; var9 != null; var9 = var9.next) {
Float2ObjectConcurrentHashMap.TreeNode var10 = new Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.TreeBin<>(this.EMPTY, var7));
}
}
}
}
}
}
class="kw">protected <V> Float2ObjectConcurrentHashMap.Node<V> untreeify(Float2ObjectConcurrentHashMap.Node<V> var1) {
Float2ObjectConcurrentHashMap.Node var2 = null;
Float2ObjectConcurrentHashMap.Node var3 = null;
for (Float2ObjectConcurrentHashMap.Node var4 = var1; var4 != null; var4 = var4.next) {
Float2ObjectConcurrentHashMap.Node var5 = new Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Float2ObjectConcurrentHashMap.ForEachMappingTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEach(long var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Float2ObjectConcurrentHashMap.ForEachTransformedMappingTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U search(long var1, Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.SearchMappingsTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public <U> U search(Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var2 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = var2;
Float2ObjectConcurrentHashMap.Node var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Float2ObjectConcurrentHashMap.TableStack var20 = var6;
if (var20 != null) {
var6 = var20.next;
} else {
var20 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var12;
var20.length = var14;
var20.index = var13;
var20.next = var5;
var5 = var20;
class="kw">continue;
}
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Float2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatBiObjFunction<? super V, X, ? class="kw">extends U> var1, X var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjByteFunction<? super V, ? class="kw">extends U> var1, byte var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjShortFunction<? super V, ? class="kw">extends U> var1, short var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjIntFunction<? super V, ? class="kw">extends U> var1, int var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjLongFunction<? super V, ? class="kw">extends U> var1, long var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var8;
if (var22 != null) {
var8 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var7;
var7 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjFloatFunction<? super V, ? class="kw">extends U> var1, float var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var7;
if (var21 != null) {
var7 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var13;
var21.length = var15;
var21.index = var14;
var21.next = var6;
var6 = var21;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.FloatObjDoubleFunction<? super V, ? class="kw">extends U> var1, double var2) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var4 = this.table;
if (this.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var8;
if (var22 != null) {
var8 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var7;
var7 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.FloatObjFunction<? 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 Float2ObjectConcurrentHashMap.MapReduceMappingsTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U reduce(Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> var1, BiFunction<? super U, ? super U, ? class="kw">extends U> var2) {
if (var1 != null && var2 != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = this.table;
if (this.table == null) {
class="kw">return null;
}
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
Object var12 = null;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = var7;
if (var22 != null) {
var7 = var22.next;
} else {
var22 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var22.tab = var14;
var22.length = var16;
var22.index = var15;
var22.next = var6;
var6 = var22;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var6 == null) {
if ((var8 = var15 + var11) >= var16) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction<? super V> var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.ToLongFloatObjFunction<? super V> var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.ToIntFloatObjFunction<? super V> var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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, FloatConsumer var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Float2ObjectConcurrentHashMap.ForEachKeyTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEachKey(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Float2ObjectConcurrentHashMap.ForEachTransformedKeyTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public <U> U searchKeys(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.SearchKeysTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public float reduceKeys(long var1, Float2ObjectConcurrentHashMap.FloatReduceTaskOperator var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.ReduceKeysTask<>(this.EMPTY, null, this.batchFor(var1), 0, 0, this.table, null, var3).invoke0();
}
}
class="kw">public <U> U reduceKeys(long var1, Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends U> var3, BiFunction<? super U, ? super U, ? class="kw">extends U> var4) {
if (var3 != null && var4 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.MapReduceKeysTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceKeysToDouble(long var1, Float2ObjectConcurrentHashMap.FloatToDoubleFunction var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.FloatToLongFunction var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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, Float2ObjectConcurrentHashMap.FloatToIntFunction var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceValuesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceValuesToDouble(long var1, ToDoubleFunction<? super V> var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Entry<V>> var3) {
if (var3 == null) {
throw new NullPointerException();
}
new Float2ObjectConcurrentHashMap.ForEachEntryTask<>(null, this.batchFor(var1), 0, 0, this.table, var3).invoke();
}
class="kw">public <U> void forEachEntry(long var1, Function<Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var3, Consumer<? super U> var4) {
if (var3 != null && var4 != null) {
new Float2ObjectConcurrentHashMap.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<Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> var3) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.SearchEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, var3, new AtomicReference()).invoke();
}
}
class="kw">public Float2ObjectConcurrentHashMap.Entry<V> reduceEntries(
long var1,
BiFunction<Float2ObjectConcurrentHashMap.Entry<V>, Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Float2ObjectConcurrentHashMap.Entry<V>> var3
) {
if (var3 == null) {
throw new NullPointerException();
} else {
class="kw">return new Float2ObjectConcurrentHashMap.ReduceEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3).invoke();
}
}
class="kw">public <U> U reduceEntries(long var1, Function<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceEntriesTask<>(null, this.batchFor(var1), 0, 0, this.table, null, var3, var4).invoke();
} else {
throw new NullPointerException();
}
}
class="kw">public double reduceEntriesToDouble(long var1, ToDoubleFunction<Float2ObjectConcurrentHashMap.Entry<V>> var3, double var4, DoubleBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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<Float2ObjectConcurrentHashMap.Entry<V>> var3, long var4, LongBinaryOperator var6) {
if (var3 != null && var6 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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<Float2ObjectConcurrentHashMap.Entry<V>> var3, int var4, IntBinaryOperator var5) {
if (var3 != null && var5 != null) {
class="kw">return new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.Node var3 = null;
Float2ObjectConcurrentHashMap.TableStack var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
int var6 = 0;
int var7 = 0;
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.Node var12 = var3;
if (var3 != null) {
var12 = var12.next;
}
label76:
while (var12 == null) {
if (var7 < var9) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ForwardingNode) {
var2 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var19 = var5;
if (var19 != null) {
var5 = var19.next;
} else {
var19 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var13;
var19.length = var15;
var19.index = var14;
var19.next = var4;
var4 = var19;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var4 == null) {
if ((var6 = var14 + var10) >= var15) {
var6 = ++var7;
}
class="kw">continue;
}
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.CounterCell.class;
CELLVALUE = U.objectFieldOffset(var2.getDeclaredField("value"));
Class var3 = Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Traverser<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap<V> map;
class="kw">public Float2ObjectConcurrentHashMap.Node<V> lastReturned;
class="kw">public BaseIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<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() {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Float2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Float2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> advance() {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Float2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Float2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap<K> map;
class="kw">protected class="kw">static class="kw">final String oomeMsg = "Required array size too large";
class="kw">public CollectionView(Float2ObjectConcurrentHashMap<K> var1) {
this.map = var1;
}
class="kw">public Float2ObjectConcurrentHashMap<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;
}
}
class="kw">protected class="kw">abstract class="kw">static class DoubleReturningBulkTask<V> class="kw">extends Float2ObjectConcurrentHashMap.BulkTask<V, Double> {
class="kw">public double result;
class="kw">public DoubleReturningBulkTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.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">public class="kw">interface Entry<V> class="kw">extends it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V> {
boolean isEmpty();
@Deprecated
Float getKey();
float getFloatKey();
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 Float2ObjectConcurrentHashMap.BaseIterator<V>
class="kw">implements ObjectIterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> {
class="kw">public EntryIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) {
super(var1, var2, var3, var4, var5);
}
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.Entry<V> next() {
Float2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next == null) {
throw new NoSuchElementException();
}
float var2 = var1.key;
Object var3 = var1.val;
this.lastReturned = var1;
this.advance();
class="kw">return new Float2ObjectConcurrentHashMap.MapEntry<>(var1.isEmpty(), var2, var3, this.map);
}
}
class="kw">protected class="kw">static class="kw">final class EntrySetView<V>
class="kw">extends Float2ObjectConcurrentHashMap.CollectionView<V, it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>>
class="kw">implements ObjectSet<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>>,
Serializable {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 2249069246763182397L;
class="kw">public EntrySetView(Float2ObjectConcurrentHashMap<V> var1) {
super(var1);
}
@Override
class="kw">public boolean contains(Object var1) {
if (var1 class="kw">instanceof it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry) {
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var5;
float var2 = (var5 = (it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<?>)var1).getFloatKey();
if (!((Float2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
Object var3;
Object var4;
class="kw">return (var4 = this.map.get(var2)) != null && (var3 = var5.getValue()) != null && (var3 == var4 || var3.equals(var4));
}
}
class="kw">return false;
}
@Override
class="kw">public boolean remove(Object var1) {
if (var1 class="kw">instanceof it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry) {
it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry var4;
float var2 = (var4 = (it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<?>)var1).getFloatKey();
if (!((Float2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
Object var3;
class="kw">return (var3 = var4.getValue()) != null && this.map.remove(var2, var3);
}
}
class="kw">return false;
}
@Override
class="kw">public ObjectIterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> iterator() {
Float2ObjectConcurrentHashMap var1 = this.map;
Float2ObjectConcurrentHashMap.Node[] var2 = var1.table;
int var3 = var1.table == null ? 0 : var2.length;
class="kw">return new Float2ObjectConcurrentHashMap.EntryIterator<>(var2, var3, 0, var3, var1);
}
class="kw">public boolean add(it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V> var1) {
class="kw">return this.map.putVal(var1.getFloatKey(), (V)var1.getValue(), false) == null;
}
class="kw">public boolean addAll(Collection<? class="kw">extends it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) {
boolean var2 = false;
for (it.unimi.dsi.fastutil.floats.Float2ObjectMap.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;
Float2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Traverser var3 = new Float2ObjectConcurrentHashMap.Traverser<>(var2, var2.length, 0, var2.length);
Float2ObjectConcurrentHashMap.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.floats.Float2ObjectMap.Entry<V>> spliterator() {
Float2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Float2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Float2ObjectConcurrentHashMap.EntrySpliterator<>(var1, var5, 0, var5, var3 < 0L ? 0L : var3, var2);
}
class="kw">public void forEach(Consumer<? super it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Traverser var3 = new Float2ObjectConcurrentHashMap.Traverser<>(var2, var2.length, 0, var2.length);
Float2ObjectConcurrentHashMap.Node var4;
while ((var4 = var3.advance()) != null) {
var1.accept(new Float2ObjectConcurrentHashMap.MapEntry<>(var4.isEmpty(), var4.key, var4.val, this.map));
}
}
}
}
class="kw">protected class="kw">static class="kw">final class EntrySpliterator<V>
class="kw">extends Float2ObjectConcurrentHashMap.Traverser<V>
class="kw">implements ObjectSpliterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap<V> map;
class="kw">public long est;
class="kw">public EntrySpliterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5, Float2ObjectConcurrentHashMap<V> var7) {
super(var1, var2, var3, var4);
this.map = var7;
this.est = var5;
}
class="kw">public ObjectSpliterator<it.unimi.dsi.fastutil.floats.Float2ObjectMap.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 Float2ObjectConcurrentHashMap.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.floats.Float2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node var2;
while ((var2 = this.advance()) != null) {
var1.accept(new Float2ObjectConcurrentHashMap.MapEntry<>(var2.isEmpty(), var2.key, var2.val, this.map));
}
}
class="kw">public boolean tryAdvance(Consumer<? super it.unimi.dsi.fastutil.floats.Float2ObjectMap.Entry<V>> var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node var2;
if ((var2 = this.advance()) == null) {
class="kw">return false;
}
var1.accept(new Float2ObjectConcurrentHashMap.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;
}
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjByteConsumer<V, X> {
void accept(float var1, V var2, byte var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjConsumer<V, X> {
void accept(float var1, V var2, X var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjDoubleConsumer<V, X> {
void accept(float var1, V var2, double var3, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjFloatConsumer<V, X> {
void accept(float var1, V var2, float var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjFunction<V, X, J> {
J apply(float var1, V var2, X var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjIntConsumer<V, X> {
void accept(float var1, V var2, int var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjLongConsumer<V, X> {
void accept(float var1, V var2, long var3, X var5);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatBiObjShortConsumer<V, X> {
void accept(float var1, V var2, short var3, X var4);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatFunction<R> {
R apply(float var1);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjByteConsumer<V> {
void accept(float var1, V var2, byte var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjByteFunction<V, J> {
J apply(float var1, V var2, byte var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjConsumer<V> {
void accept(float var1, V var2);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjDoubleConsumer<V> {
void accept(float var1, V var2, double var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjDoubleFunction<V, J> {
J apply(float var1, V var2, double var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjFloatConsumer<V> {
void accept(float var1, V var2, float var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjFloatFunction<V, J> {
J apply(float var1, V var2, float var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjFunction<V, J> {
J apply(float var1, V var2);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjIntConsumer<V> {
void accept(float var1, V var2, int var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjIntFunction<V, J> {
J apply(float var1, V var2, int var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjLongConsumer<V> {
void accept(float var1, V var2, long var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjLongFunction<V, J> {
J apply(float var1, V var2, long var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjShortConsumer<V> {
void accept(float var1, V var2, short var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatObjShortFunction<V, J> {
J apply(float var1, V var2, short var3);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatReduceTaskOperator {
float reduce(float var1, float var2, float var3);
}
class="kw">protected class="kw">abstract class="kw">static class FloatReturningBulkTask2<V> class="kw">extends Float2ObjectConcurrentHashMap.BulkTask<V, Float> {
class="kw">public float result;
class="kw">public FloatReturningBulkTask2(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5
) {
super(var1, var2, var3, var4, var5);
}
class="kw">protected float 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 FloatToDoubleFunction {
double applyAsDouble(float var1);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatToIntFunction {
int applyAsInt(float var1);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatToLongFunction {
long applyAsLong(float var1);
}
@FunctionalInterface
class="kw">public class="kw">interface FloatTriObjConsumer<V, X, Y> {
void accept(float var1, V var2, X var3, Y var4);
}
class="kw">protected class="kw">static class="kw">final class ForEachEntryTask<V> class="kw">extends Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Consumer<? super Float2ObjectConcurrentHashMap.Entry<V>> action;
class="kw">public ForEachEntryTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Consumer<? super Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final FloatConsumer action;
class="kw">public ForEachKeyTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.Node<V>[] var5, FloatConsumer var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
FloatConsumer 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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> action;
class="kw">public ForEachMappingTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjConsumer<? super V> var6
) {
super(var1, var2, var3, var4, var5);
this.action = var6;
}
@Override
class="kw">public class="kw">final void compute() {
Float2ObjectConcurrentHashMap.FloatObjConsumer 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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Function<Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedEntryTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedKeyTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatFunction 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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> transformer;
class="kw">public class="kw">final Consumer<? super U> action;
class="kw">public ForEachTransformedMappingTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatObjFunction 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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Void> {
class="kw">public class="kw">final Consumer<? super V> action;
class="kw">public ForEachValueTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.Node<V>[] nextTable;
class="kw">public ForwardingNode(float var1, Float2ObjectConcurrentHashMap.Node<V>[] var2) {
super(var1, -1, var1, null, null);
this.nextTable = var2;
}
@Override
class="kw">protected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) {
Float2ObjectConcurrentHashMap.Node[] var3 = this.nextTable;
Float2ObjectConcurrentHashMap.Node var4;
int var5;
label41:
while (var2 != this.EMPTY && var3 != null && (var5 = var3.length) != 0 && (var4 = Float2ObjectConcurrentHashMap.tabAt(var3, var5 - 1 & var1)) != null) {
do {
int var6 = var4.hash;
if (var4.hash == var1) {
float var7 = var4.key;
if (var4.key == var2 || var7 != this.EMPTY && var2 == var7) {
class="kw">return var4;
}
}
if (var6 < 0) {
if (!(var4 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode)) {
class="kw">return var4.find(var1, var2);
}
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var4).nextTable;
class="kw">continue label41;
}
} while ((var4 = var4.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 Float2ObjectConcurrentHashMap.BulkTask<V, Integer> {
class="kw">public int result;
class="kw">public IntReturningBulkTask(Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.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 FloatIterator {
class="kw">public Float2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Float2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Float2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap<V> map;
class="kw">public Float2ObjectConcurrentHashMap.Node<V> lastReturned;
class="kw">public KeyIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<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 Float2ObjectConcurrentHashMap.Node<V> advance() {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Float2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Float2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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() {
Float2ObjectConcurrentHashMap.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 float nextFloat() {
Float2ObjectConcurrentHashMap.Node var1 = this.next;
if (this.next == null) {
throw new NoSuchElementException();
}
float var2 = var1.key;
this.lastReturned = var1;
this.advance();
class="kw">return var2;
}
}
class="kw">public class="kw">static class KeySetView<V> class="kw">implements FloatSet {
class="kw">public class="kw">static class="kw">final long serialVersionUID = 7249069246763182397L;
class="kw">public class="kw">final Float2ObjectConcurrentHashMap<V> map;
class="kw">public class="kw">final V value;
class="kw">public KeySetView(Float2ObjectConcurrentHashMap<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(float var1) {
class="kw">return this.map.containsKey(var1);
}
class="kw">public boolean remove(float var1) {
class="kw">return this.map.remove(var1) != null;
}
class="kw">public FloatIterator iterator() {
Float2ObjectConcurrentHashMap var2 = this.map;
Float2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var3 = var2.table == null ? 0 : var1.length;
class="kw">return new Float2ObjectConcurrentHashMap.KeyIterator<>(var1, var3, 0, var3, var2);
}
class="kw">public boolean add(float var1) {
Object var2 = this.value;
if (this.value == null) {
throw new UnsupportedOperationException();
} else {
class="kw">return this.map.putVal(var1, var2, true) == null;
}
}
class="kw">public boolean addAll(FloatCollection var1) {
boolean var2 = false;
Object var3 = this.value;
if (this.value == null) {
throw new UnsupportedOperationException();
}
FloatIterator var4 = var1.iterator();
while (var4.hasNext()) {
float var5 = var4.nextFloat();
if (this.map.putVal(var5, var3, true) == null) {
var2 = true;
}
}
class="kw">return var2;
}
@Override
class="kw">public int hashCode() {
int var1 = 0;
FloatIterator var2 = this.iterator();
while (var2.hasNext()) {
var1 += Float.hashCode(var2.nextFloat());
}
class="kw">return var1;
}
@Override
class="kw">public boolean equals(Object var1) {
FloatSet var2;
class="kw">return var1 class="kw">instanceof FloatSet && ((var2 = (FloatSet)var1) == this || this.containsAll(var2) && var2.containsAll(this));
}
class="kw">public float 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 Float[this.size()];
FloatIterator var2 = this.iterator();
int var3;
for (var3 = 0; var3 < var1.length && var2.hasNext(); var3++) {
var1[var3] = var2.nextFloat();
}
if (var1.length > var3 + 1) {
var1[var3] = this.map.EMPTY;
}
class="kw">return var1;
}
class="kw">public Object[] toArray(Object[] var1) {
FloatIterator 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 float[] toFloatArray() {
float[] var1 = new float[this.size()];
FloatIterator 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 float[] toArray(float[] var1) {
FloatIterator 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 float[] toFloatArray(float[] 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;
}
float var4 = (Float)var3;
if (!this.contains(var4)) {
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">public boolean containsAll(FloatCollection var1) {
FloatIterator var2 = var1.iterator();
while (var2.hasNext()) {
float var3 = var2.next();
if (!this.contains(var3)) {
class="kw">return false;
}
}
class="kw">return true;
}
class="kw">public boolean containsAll(float[] 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 Float> var1) {
boolean var2 = false;
for (Float var4 : var1) {
float var5 = var4;
if (this.add(var5)) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean addAll(float[] 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;
FloatIterator var3 = this.iterator();
while (var3.hasNext()) {
if (!var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean retainAll(FloatCollection var1) {
if (this == var1) {
class="kw">return false;
}
boolean var2 = false;
FloatIterator var3 = this.iterator();
while (var3.hasNext()) {
if (!var1.contains(var3.next())) {
var3.remove();
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean retainAll(float[] var1) {
boolean var2 = false;
FloatIterator var3 = this.iterator();
while (var3.hasNext()) {
if (Arrays.binarySearch(var1, var3.next().floatValue()) < 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 Float) {
float var5 = (Float)var4;
if (this.remove(var5)) {
var2 = true;
}
}
}
class="kw">return var2;
}
class="kw">public boolean removeAll(FloatCollection var1) {
boolean var2 = false;
FloatIterator var3 = var1.iterator();
while (var3.hasNext()) {
float var4 = var3.next();
if (this.remove(var4)) {
var2 = true;
}
}
class="kw">return var2;
}
class="kw">public boolean removeAll(float[] 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 FloatSpliterator spliterator() {
Float2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Float2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Float2ObjectConcurrentHashMap.KeySpliterator<>(var1, var5, 0, var5, var3 < 0L ? 0L : var3);
}
}
class="kw">protected class="kw">static class="kw">final class KeySpliterator<V> class="kw">extends Float2ObjectConcurrentHashMap.Traverser<V> class="kw">implements FloatSpliterator {
class="kw">public long est;
class="kw">public KeySpliterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, long var5) {
super(var1, var2, var3, var4);
this.est = var5;
}
class="kw">public FloatSpliterator trySplit() {
int var1 = this.baseIndex;
int var2 = this.baseLimit;
int var3;
class="kw">return (var3 = this.baseIndex + this.baseLimit >>> 1) <= var1
? null
: new Float2ObjectConcurrentHashMap.KeySpliterator<>(this.tab, this.baseSize, this.baseLimit = var3, var2, this.est >>>= 1);
}
class="kw">public boolean tryAdvance(Consumer<? super Float> var1) {
class="kw">return var1 class="kw">instanceof FloatConsumer ? this.tryAdvance((FloatConsumer)var1) : this.tryAdvance(var1x -> var1.accept(var1x));
}
class="kw">public void forEachRemaining(FloatConsumer var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.Node var2;
while ((var2 = this.advance()) != null) {
var1.accept(var2.key);
}
}
class="kw">public boolean tryAdvance(FloatConsumer var1) {
if (var1 == null) {
throw new NullPointerException();
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, Long> {
class="kw">public long result;
class="kw">public LongReturningBulkTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Entry<V> {
class="kw">public class="kw">final boolean empty;
class="kw">public class="kw">final float key;
class="kw">public V val;
class="kw">public class="kw">final Float2ObjectConcurrentHashMap<V> map;
class="kw">public MapEntry(boolean var1, float var2, V var3, Float2ObjectConcurrentHashMap<V> var4) {
this.empty = var1;
this.key = var2;
this.val = var3;
this.map = var4;
}
@Override
class="kw">public boolean isEmpty() {
class="kw">return this.empty;
}
@Override
class="kw">public Float getKey() {
class="kw">return this.key;
}
@Override
class="kw">public float getFloatKey() {
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 Float2ObjectConcurrentHashMap.Entry) {
if (this.empty != ((Float2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
class="kw">return false;
} else {
class="kw">return !this.empty && this.key != ((Float2ObjectConcurrentHashMap.Entry)var1).getFloatKey()
? false
: this.val.equals(((Float2ObjectConcurrentHashMap.Entry)var1).getValue());
}
} else {
class="kw">return false;
}
}
@Override
class="kw">public int hashCode() {
int var1 = this.empty ? 1 : 0;
var1 = 31 * var1 + Float.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 Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> nextRight;
class="kw">public MapReduceEntriesTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U> var6,
Function<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceEntriesTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceEntriesTask var13 = (Float2ObjectConcurrentHashMap.MapReduceEntriesTask<V, U>)var11;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final ToDoubleFunction<Float2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> nextRight;
class="kw">public MapReduceEntriesToDoubleTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V> var6,
ToDoubleFunction<Float2ObjectConcurrentHashMap.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() {
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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask var10 = (Float2ObjectConcurrentHashMap.MapReduceEntriesToDoubleTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final ToIntFunction<Float2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> nextRight;
class="kw">public MapReduceEntriesToIntTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V> var6,
ToIntFunction<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask var9 = (Float2ObjectConcurrentHashMap.MapReduceEntriesToIntTask<V>)var8;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final ToLongFunction<Float2ObjectConcurrentHashMap.Entry<V>> transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> nextRight;
class="kw">public MapReduceEntriesToLongTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V> var6,
ToLongFunction<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask var10 = (Float2ObjectConcurrentHashMap.MapReduceEntriesToLongTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatFunction<? 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 Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> nextRight;
class="kw">public MapReduceKeysTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U> var6,
Float2ObjectConcurrentHashMap.FloatFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatFunction 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 Float2ObjectConcurrentHashMap.MapReduceKeysTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceKeysTask var13 = (Float2ObjectConcurrentHashMap.MapReduceKeysTask<V, U>)var11;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatToDoubleFunction transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> nextRight;
class="kw">public MapReduceKeysToDoubleTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToDoubleFunction 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() {
Float2ObjectConcurrentHashMap.FloatToDoubleFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask var10 = (Float2ObjectConcurrentHashMap.MapReduceKeysToDoubleTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatToIntFunction transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> nextRight;
class="kw">public MapReduceKeysToIntTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToIntFunction 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() {
Float2ObjectConcurrentHashMap.FloatToIntFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask var9 = (Float2ObjectConcurrentHashMap.MapReduceKeysToIntTask<V>)var8;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatToLongFunction transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> nextRight;
class="kw">public MapReduceKeysToLongTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V> var6,
Float2ObjectConcurrentHashMap.FloatToLongFunction 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() {
Float2ObjectConcurrentHashMap.FloatToLongFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask var10 = (Float2ObjectConcurrentHashMap.MapReduceKeysToLongTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatObjFunction<? 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 Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> nextRight;
class="kw">public MapReduceMappingsTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U> var6,
Float2ObjectConcurrentHashMap.FloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatObjFunction 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 Float2ObjectConcurrentHashMap.MapReduceMappingsTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceMappingsTask var13 = (Float2ObjectConcurrentHashMap.MapReduceMappingsTask<V, U>)var11;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction<? super V> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> nextRight;
class="kw">public MapReduceMappingsToDoubleTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V> var6,
Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.ToDoubleFloatObjFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask var10 = (Float2ObjectConcurrentHashMap.MapReduceMappingsToDoubleTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.IntReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.ToIntFloatObjFunction<? super V> transformer;
class="kw">public class="kw">final IntBinaryOperator reducer;
class="kw">public class="kw">final int basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> nextRight;
class="kw">public MapReduceMappingsToIntTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V> var6,
Float2ObjectConcurrentHashMap.ToIntFloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.ToIntFloatObjFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask var9 = (Float2ObjectConcurrentHashMap.MapReduceMappingsToIntTask<V>)var8;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.LongReturningBulkTask<V> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.ToLongFloatObjFunction<? super V> transformer;
class="kw">public class="kw">final LongBinaryOperator reducer;
class="kw">public class="kw">final long basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> nextRight;
class="kw">public MapReduceMappingsToLongTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V> var6,
Float2ObjectConcurrentHashMap.ToLongFloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.ToLongFloatObjFunction 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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask var10 = (Float2ObjectConcurrentHashMap.MapReduceMappingsToLongTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U> nextRight;
class="kw">public MapReduceValuesTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceValuesTask<>(
this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, this.rights, var1, var2
))
.fork();
}
Object var9 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceValuesTask var13 = (Float2ObjectConcurrentHashMap.MapReduceValuesTask<V, U>)var11;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.DoubleReturningBulkTask<V> {
class="kw">public class="kw">final ToDoubleFunction<? super V> transformer;
class="kw">public class="kw">final DoubleBinaryOperator reducer;
class="kw">public class="kw">final double basis;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> nextRight;
class="kw">public MapReduceValuesToDoubleTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V> var6,
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() {
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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask var10 = (Float2ObjectConcurrentHashMap.MapReduceValuesToDoubleTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V> nextRight;
class="kw">public MapReduceValuesToIntTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask var9 = (Float2ObjectConcurrentHashMap.MapReduceValuesToIntTask<V>)var8;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V> nextRight;
class="kw">public MapReduceValuesToLongTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask var10 = (Float2ObjectConcurrentHashMap.MapReduceValuesToLongTask<V>)var9;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Entry<V> {
class="kw">public class="kw">final float EMPTY;
class="kw">public class="kw">final int hash;
class="kw">public class="kw">final float key;
class="kw">public class="kw">volatile V val;
class="kw">public class="kw">volatile Float2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Node(float var1, int var2, float var3, V var4, Float2ObjectConcurrentHashMap.Node<V> var5) {
this.EMPTY = var1;
this.hash = var2;
this.key = var3;
this.val = var4;
this.next = var5;
}
@Override
class="kw">public class="kw">final boolean isEmpty() {
class="kw">return this.key == this.EMPTY;
}
@Override
class="kw">public class="kw">final Float getKey() {
class="kw">return this.key;
}
@Override
class="kw">public class="kw">final float getFloatKey() {
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 Float.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 Float2ObjectConcurrentHashMap.Entry) {
if (var2 != ((Float2ObjectConcurrentHashMap.Entry)var1).isEmpty()) {
class="kw">return false;
} else {
class="kw">return !var2 && this.key != ((Float2ObjectConcurrentHashMap.Entry)var1).getFloatKey()
? false
: this.val.equals(((Float2ObjectConcurrentHashMap.Entry)var1).getValue());
}
} else {
class="kw">return false;
}
}
class="kw">protected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) {
Float2ObjectConcurrentHashMap.Node var3 = this;
if (var2 != this.EMPTY) {
do {
if (var3.hash == var1) {
float var4 = var3.key;
if (var3.key == var2 || var4 != this.EMPTY && var2 == var4) {
class="kw">return var3;
}
}
} while ((var3 = var3.next) != null);
}
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class ReduceEntriesTask<V> class="kw">extends Float2ObjectConcurrentHashMap.BulkTask<V, Float2ObjectConcurrentHashMap.Entry<V>> {
class="kw">public class="kw">final BiFunction<Float2ObjectConcurrentHashMap.Entry<V>, Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Float2ObjectConcurrentHashMap.Entry<V>> reducer;
class="kw">public Float2ObjectConcurrentHashMap.Entry<V> result;
class="kw">public Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> nextRight;
class="kw">public ReduceEntriesTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.ReduceEntriesTask<V> var6,
BiFunction<Float2ObjectConcurrentHashMap.Entry<V>, Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends Float2ObjectConcurrentHashMap.Entry<V>> var7
) {
super(var1, var2, var3, var4, var5);
this.nextRight = var6;
this.reducer = var7;
}
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ReduceEntriesTask<>(
this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
Float2ObjectConcurrentHashMap.Entry var8 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.ReduceEntriesTask var11 = (Float2ObjectConcurrentHashMap.ReduceEntriesTask<V>)var10;
for (Float2ObjectConcurrentHashMap.ReduceEntriesTask var5 = var11.rights; var5 != null; var5 = var11.rights = var5.nextRight) {
Float2ObjectConcurrentHashMap.Entry var7 = var5.result;
if (var5.result != null) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.FloatReturningBulkTask2<V> {
class="kw">public class="kw">final float EMPTY;
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatReduceTaskOperator reducer;
class="kw">public Float2ObjectConcurrentHashMap.ReduceKeysTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.ReduceKeysTask<V> nextRight;
class="kw">public ReduceKeysTask(
float var1,
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var2,
int var3,
int var4,
int var5,
Float2ObjectConcurrentHashMap.Node<V>[] var6,
Float2ObjectConcurrentHashMap.ReduceKeysTask<V> var7,
Float2ObjectConcurrentHashMap.FloatReduceTaskOperator var8
) {
super(var2, var3, var4, var5, var6);
this.nextRight = var7;
this.EMPTY = var1;
this.reducer = var8;
}
class="kw">public class="kw">final Float getRawResult() {
throw new UnsupportedOperationException();
}
@Override
class="kw">public class="kw">final void compute() {
Float2ObjectConcurrentHashMap.FloatReduceTaskOperator 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 Float2ObjectConcurrentHashMap.ReduceKeysTask<>(
this.EMPTY, this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
boolean var9 = false;
float var10 = this.EMPTY;
Float2ObjectConcurrentHashMap.Node var11;
while ((var11 = this.advance()) != null) {
float var5 = var11.key;
if (!var9) {
var9 = true;
var10 = var5;
} else if (!var11.isEmpty()) {
var9 = true;
var10 = var1.reduce(this.EMPTY, var10, var5);
}
}
this.result = var10;
for (CountedCompleter var12 = this.firstComplete(); var12 != null; var12 = var12.nextComplete()) {
Float2ObjectConcurrentHashMap.ReduceKeysTask var13 = (Float2ObjectConcurrentHashMap.ReduceKeysTask<V>)var12;
for (Float2ObjectConcurrentHashMap.ReduceKeysTask var6 = var13.rights; var6 != null; var6 = var13.rights = var6.nextRight) {
float var8 = var6.result;
if (var6.result != this.EMPTY) {
float var7 = var13.result;
var13.result = var13.result == this.EMPTY ? var8 : var1.reduce(this.EMPTY, var7, var8);
}
}
}
}
}
}
class="kw">protected class="kw">static class="kw">final class ReduceValuesTask<V> class="kw">extends Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ReduceValuesTask<V> rights;
class="kw">public Float2ObjectConcurrentHashMap.ReduceValuesTask<V> nextRight;
class="kw">public ReduceValuesTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.ReduceValuesTask<>(
this, this.batch >>>= 1, this.baseLimit = var4, var3, this.tab, this.rights, var1
))
.fork();
}
Object var8 = null;
Float2ObjectConcurrentHashMap.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()) {
Float2ObjectConcurrentHashMap.ReduceValuesTask var12 = (Float2ObjectConcurrentHashMap.ReduceValuesTask<V>)var10;
for (Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> {
class="kw">public ReservationNode(float var1) {
super(var1, -3, var1, null, null);
}
@Override
class="kw">protected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) {
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class SearchEntriesTask<V, U> class="kw">extends Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Function<Float2ObjectConcurrentHashMap.Entry<V>, ? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchEntriesTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Function<Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.SearchEntriesTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatFunction<? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchKeysTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatFunction 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 Float2ObjectConcurrentHashMap.SearchKeysTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.BulkTask<V, U> {
class="kw">public class="kw">final Float2ObjectConcurrentHashMap.FloatObjFunction<? super V, ? class="kw">extends U> searchFunction;
class="kw">public class="kw">final AtomicReference<U> result;
class="kw">public SearchMappingsTask(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.Node<V>[] var5,
Float2ObjectConcurrentHashMap.FloatObjFunction<? 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() {
Float2ObjectConcurrentHashMap.FloatObjFunction 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 Float2ObjectConcurrentHashMap.SearchMappingsTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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(
Float2ObjectConcurrentHashMap.BulkTask<V, ?> var1,
int var2,
int var3,
int var4,
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.SearchValuesTask<>(this, this.batch >>>= 1, this.baseLimit = var5, var4, this.tab, var1, var2).fork();
}
while (var2.get() == null) {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Float2ObjectConcurrentHashMap.TableStack<V> next;
class="kw">public TableStack() {
}
}
@FunctionalInterface
class="kw">public class="kw">interface ToDoubleFloatObjFunction<V> {
double applyAsDouble(float var1, V var2);
}
@FunctionalInterface
class="kw">public class="kw">interface ToFloatFunction<T> {
float applyAsFloat(T var1);
}
@FunctionalInterface
class="kw">public class="kw">interface ToIntFloatObjFunction<V> {
int applyAsInt(float var1, V var2);
}
@FunctionalInterface
class="kw">public class="kw">interface ToLongFloatObjFunction<V> {
long applyAsLong(float var1, V var2);
}
class="kw">protected class="kw">static class Traverser<V> {
class="kw">public Float2ObjectConcurrentHashMap.Node<V>[] tab;
class="kw">public Float2ObjectConcurrentHashMap.Node<V> next;
class="kw">public Float2ObjectConcurrentHashMap.TableStack<V> stack;
class="kw">public Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> advance() {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var2, var3)) != null && var1.hash < 0) {
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
this.tab = ((Float2ObjectConcurrentHashMap.ForwardingNode)var1).nextTable;
var1 = null;
this.pushState(var2, var3, var4);
class="kw">continue;
}
if (var1 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var1 = ((Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3) {
Float2ObjectConcurrentHashMap.TableStack var4 = this.spare;
if (var4 != null) {
this.spare = var4.next;
} else {
var4 = new Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> {
class="kw">public Float2ObjectConcurrentHashMap.TreeNode<V> root;
class="kw">public class="kw">volatile Float2ObjectConcurrentHashMap.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(float var1, float var2) {
int var3 = Float.compare(var1, var2);
class="kw">return var3 > 0 ? 1 : -1;
}
class="kw">public TreeBin(float var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2) {
super(var1, -2, var1, null, null);
this.first = var2;
Float2ObjectConcurrentHashMap.TreeNode var3 = null;
Float2ObjectConcurrentHashMap.TreeNode var4 = var2;
while (var4 != null) {
Float2ObjectConcurrentHashMap.TreeNode var5 = (Float2ObjectConcurrentHashMap.TreeNode<V>)var4.next;
var4.left = var4.right = null;
if (var3 == null) {
var4.parent = null;
var4.red = false;
var3 = var4;
} else {
float var6 = var4.key;
int var7 = var4.hash;
Class var8 = null;
Float2ObjectConcurrentHashMap.TreeNode var9 = var3;
int var10;
Float2ObjectConcurrentHashMap.TreeNode var13;
do {
float var12 = var9.key;
int var11 = var9.hash;
if (var9.hash > var7) {
var10 = -1;
} else if (var11 < var7) {
var10 = 1;
} else if ((var10 = Float.compare(var6, var12)) == 0) {
var10 = this.tieBreakOrder(var6, var12);
}
var13 = var9;
} while ((var9 = var10 <= 0 ? var9.left : var9.right) != null);
var4.parent = var13;
if (var10 <= 0) {
var13.left = var4;
} else {
var13.right = var4;
}
var3 = this.balanceInsertion(var3, var4);
}
var4 = var5;
}
this.root = var3;
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 Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) {
if (var2 != this.EMPTY) {
Float2ObjectConcurrentHashMap.Node var3 = this.first;
while (var3 != null) {
int var4 = this.lockState;
if ((this.lockState & 3) != 0) {
if (var3.hash == var1) {
float var5 = var3.key;
if (var3.key == var2 || var5 != this.EMPTY && var2 == var5) {
class="kw">return var3;
}
}
var3 = var3.next;
} else if (U.compareAndSwapInt(this, LOCKSTATE, var4, var4 + 4)) {
Float2ObjectConcurrentHashMap.TreeNode var7;
try {
Float2ObjectConcurrentHashMap.TreeNode var6 = this.root;
var7 = this.root == null ? null : var6.findTreeNode(var1, var2, null);
} class="kw">finally {
if (U.getAndAddInt(this, LOCKSTATE, -4) == 6) {
Thread var10 = this.waiter;
if (this.waiter != null) {
LockSupport.unpark(var10);
}
}
}
class="kw">return var7;
}
}
}
class="kw">return null;
}
class="kw">protected class="kw">final Float2ObjectConcurrentHashMap.TreeNode<V> putTreeVal(int var1, float var2, V var3) {
Class var4 = null;
boolean var5 = false;
Float2ObjectConcurrentHashMap.TreeNode var6 = this.root;
while (true) {
if (var6 == null) {
this.first = this.root = new Float2ObjectConcurrentHashMap.TreeNode<>(this.EMPTY, var1, var2, var3, null, null);
} else {
int var8 = var6.hash;
int var7;
if (var6.hash > var1) {
var7 = -1;
} else if (var8 < var1) {
var7 = 1;
} else {
float var9 = var6.key;
if (var6.key == var2 || var9 != this.EMPTY && var2 == var9) {
class="kw">return var6;
}
if ((var7 = Float.compare(var2, var9)) == 0) {
if (!var5) {
var5 = true;
Float2ObjectConcurrentHashMap.TreeNode var11 = var6.left;
Float2ObjectConcurrentHashMap.TreeNode var10;
if (var6.left != null && (var10 = var11.findTreeNode(var1, var2, var4)) != null) {
class="kw">return var10;
}
var11 = var6.right;
if (var6.right != null && (var10 = var11.findTreeNode(var1, var2, var4)) != null) {
class="kw">return var10;
}
}
var7 = this.tieBreakOrder(var2, var9);
}
}
Float2ObjectConcurrentHashMap.TreeNode var16 = var6;
if ((var6 = var7 <= 0 ? var6.left : var6.right) != null) {
class="kw">continue;
}
Float2ObjectConcurrentHashMap.TreeNode var12 = this.first;
Float2ObjectConcurrentHashMap.TreeNode var18;
this.first = var18 = new Float2ObjectConcurrentHashMap.TreeNode<>(this.EMPTY, var1, var2, var3, var12, var16);
if (var12 != null) {
var12.prev = var18;
}
if (var7 <= 0) {
var16.left = var18;
} else {
var16.right = var18;
}
if (!var16.red) {
var18.red = true;
} else {
this.lockRoot();
try {
this.root = this.balanceInsertion(this.root, var18);
} class="kw">finally {
this.unlockRoot();
}
}
}
assert this.checkInvariants(this.root);
class="kw">return null;
}
}
class="kw">protected class="kw">final boolean removeTreeNode(Float2ObjectConcurrentHashMap.TreeNode<V> var1) {
Float2ObjectConcurrentHashMap.TreeNode var2 = (Float2ObjectConcurrentHashMap.TreeNode<V>)var1.next;
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.TreeNode var4 = this.root;
if (this.root != null && var4.right != null) {
Float2ObjectConcurrentHashMap.TreeNode var5 = var4.left;
if (var4.left != null && var5.left != null) {
this.lockRoot();
try {
Float2ObjectConcurrentHashMap.TreeNode var7 = var1.left;
Float2ObjectConcurrentHashMap.TreeNode var8 = var1.right;
Float2ObjectConcurrentHashMap.TreeNode var6;
if (var7 != null && var8 != null) {
Float2ObjectConcurrentHashMap.TreeNode var9 = var8;
while (true) {
Float2ObjectConcurrentHashMap.TreeNode var10 = var9.left;
if (var9.left == null) {
boolean var11 = var9.red;
var9.red = var1.red;
var1.red = var11;
Float2ObjectConcurrentHashMap.TreeNode var12 = var9.right;
Float2ObjectConcurrentHashMap.TreeNode var13 = var1.parent;
if (var9 == var8) {
var1.parent = var9;
var9.right = var1;
} else {
Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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) {
Float2ObjectConcurrentHashMap.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> Float2ObjectConcurrentHashMap.TreeNode<V> rotateLeft(
Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2
) {
if (var2 != null) {
Float2ObjectConcurrentHashMap.TreeNode var3 = var2.right;
if (var2.right != null) {
Float2ObjectConcurrentHashMap.TreeNode var5;
if ((var5 = var2.right = var3.left) != null) {
var5.parent = var2;
}
Float2ObjectConcurrentHashMap.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> Float2ObjectConcurrentHashMap.TreeNode<V> rotateRight(
Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2
) {
if (var2 != null) {
Float2ObjectConcurrentHashMap.TreeNode var3 = var2.left;
if (var2.left != null) {
Float2ObjectConcurrentHashMap.TreeNode var5;
if ((var5 = var2.left = var3.right) != null) {
var5.parent = var2;
}
Float2ObjectConcurrentHashMap.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> Float2ObjectConcurrentHashMap.TreeNode<V> balanceInsertion(
Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2
) {
var2.red = true;
while (true) {
Float2ObjectConcurrentHashMap.TreeNode var3 = var2.parent;
if (var2.parent == null) {
var2.red = false;
class="kw">return var2;
}
if (!var3.red) {
break;
}
Float2ObjectConcurrentHashMap.TreeNode var4 = var3.parent;
if (var3.parent == null) {
break;
}
Float2ObjectConcurrentHashMap.TreeNode var5 = var4.left;
if (var3 == var4.left) {
Float2ObjectConcurrentHashMap.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> Float2ObjectConcurrentHashMap.TreeNode<V> balanceDeletion(
Float2ObjectConcurrentHashMap.TreeNode<V> var1, Float2ObjectConcurrentHashMap.TreeNode<V> var2
) {
while (var2 != null && var2 != var1) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.TreeNode var4 = var3.left;
if (var3.left == var2) {
Float2ObjectConcurrentHashMap.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 {
Float2ObjectConcurrentHashMap.TreeNode var9 = var5.left;
Float2ObjectConcurrentHashMap.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 {
Float2ObjectConcurrentHashMap.TreeNode var6 = var4.left;
Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap.TreeNode<V> var1) {
Float2ObjectConcurrentHashMap.TreeNode var2 = var1.parent;
Float2ObjectConcurrentHashMap.TreeNode var3 = var1.left;
Float2ObjectConcurrentHashMap.TreeNode var4 = var1.right;
Float2ObjectConcurrentHashMap.TreeNode var5 = var1.prev;
Float2ObjectConcurrentHashMap.TreeNode var6 = (Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Node<V> {
class="kw">public Float2ObjectConcurrentHashMap.TreeNode<V> parent;
class="kw">public Float2ObjectConcurrentHashMap.TreeNode<V> left;
class="kw">public Float2ObjectConcurrentHashMap.TreeNode<V> right;
class="kw">public Float2ObjectConcurrentHashMap.TreeNode<V> prev;
class="kw">public boolean red;
class="kw">public TreeNode(float var1, int var2, float var3, V var4, Float2ObjectConcurrentHashMap.Node<V> var5, Float2ObjectConcurrentHashMap.TreeNode<V> var6) {
super(var1, var2, var3, var4, var5);
this.parent = var6;
}
@Override
class="kw">protected Float2ObjectConcurrentHashMap.Node<V> find(int var1, float var2) {
class="kw">return this.findTreeNode(var1, var2, null);
}
class="kw">protected class="kw">final Float2ObjectConcurrentHashMap.TreeNode<V> findTreeNode(int var1, float var2, Class<?> var3) {
if (var2 != this.EMPTY) {
Float2ObjectConcurrentHashMap.TreeNode var4 = this;
do {
Float2ObjectConcurrentHashMap.TreeNode var9 = var4.left;
Float2ObjectConcurrentHashMap.TreeNode var10 = var4.right;
int var5 = var4.hash;
if (var4.hash > var1) {
var4 = var9;
} else if (var5 < var1) {
var4 = var10;
} else {
float var7 = var4.key;
if (var4.key == var2 || var7 != this.EMPTY && var2 == var7) {
class="kw">return var4;
}
if (var9 == null) {
var4 = var10;
} else if (var10 == null) {
var4 = var9;
} else {
int var6;
if ((var6 = Float.compare(var2, var7)) != 0) {
var4 = var6 < 0 ? var9 : var10;
} else {
Float2ObjectConcurrentHashMap.TreeNode var8;
if ((var8 = var10.findTreeNode(var1, var2, var3)) != null) {
class="kw">return var8;
}
var4 = var9;
}
}
}
} while (var4 != null);
}
class="kw">return null;
}
}
class="kw">protected class="kw">static class="kw">final class ValueIterator<V> class="kw">extends Float2ObjectConcurrentHashMap.BaseIterator<V> class="kw">implements ObjectIterator<V>, Enumeration<V> {
class="kw">public ValueIterator(Float2ObjectConcurrentHashMap.Node<V>[] var1, int var2, int var3, int var4, Float2ObjectConcurrentHashMap<V> var5) {
super(var1, var2, var3, var4, var5);
}
class="kw">public class="kw">final V next() {
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.Traverser<V> class="kw">implements ObjectSpliterator<V> {
class="kw">public long est;
class="kw">public ValueSpliterator(Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.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 Float2ObjectConcurrentHashMap.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(Float2ObjectConcurrentHashMap<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() {
Float2ObjectConcurrentHashMap var1 = this.map;
Float2ObjectConcurrentHashMap.Node[] var2 = var1.table;
int var3 = var1.table == null ? 0 : var2.length;
class="kw">return new Float2ObjectConcurrentHashMap.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() {
Float2ObjectConcurrentHashMap var2 = this.map;
long var3 = var2.sumCount();
Float2ObjectConcurrentHashMap.Node[] var1 = var2.table;
int var5 = var2.table == null ? 0 : var1.length;
class="kw">return new Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var2 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var3 = var2;
Float2ObjectConcurrentHashMap.Node var4 = null;
Float2ObjectConcurrentHashMap.TableStack var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
int var7 = 0;
int var8 = 0;
int var9 = var2.length;
int var10 = var2.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var12, var13)) != null && var11.hash < 0) {
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var3 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var11).nextTable;
var11 = null;
Float2ObjectConcurrentHashMap.TableStack var19 = var6;
if (var19 != null) {
var6 = var19.next;
} else {
var19 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var19.tab = var12;
var19.length = var14;
var19.index = var13;
var19.next = var5;
var5 = var19;
class="kw">continue;
}
if (var11 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var11 = ((Float2ObjectConcurrentHashMap.TreeBin)var11).first;
} else {
var11 = null;
}
}
if (var5 == null) {
if ((var7 = var13 + var10) >= var14) {
var7 = ++var8;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var24 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var25 = var24;
Float2ObjectConcurrentHashMap.Node var26 = null;
Float2ObjectConcurrentHashMap.TableStack var27 = null;
Float2ObjectConcurrentHashMap.TableStack var28 = null;
int var29 = 0;
int var30 = 0;
int var31 = var24.length;
int var32 = var24.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var34, var35)) != null && var33.hash < 0) {
if (var33 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var25 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var33).nextTable;
var33 = null;
Float2ObjectConcurrentHashMap.TableStack var41 = var28;
if (var41 != null) {
var28 = var41.next;
} else {
var41 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var41.tab = var34;
var41.length = var36;
var41.index = var35;
var41.next = var27;
var27 = var41;
class="kw">continue;
}
if (var33 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var33 = ((Float2ObjectConcurrentHashMap.TreeBin)var33).first;
} else {
var33 = null;
}
}
if (var27 == null) {
if ((var29 = var35 + var32) >= var36) {
var29 = ++var30;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var18 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var19 = var18;
Float2ObjectConcurrentHashMap.Node var20 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = null;
Float2ObjectConcurrentHashMap.TableStack var22 = null;
int var23 = 0;
int var24 = 0;
int var25 = var18.length;
int var26 = var18.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var28, var29)) != null && var27.hash < 0) {
if (var27 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var19 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var27).nextTable;
var27 = null;
Float2ObjectConcurrentHashMap.TableStack var35 = var22;
if (var35 != null) {
var22 = var35.next;
} else {
var35 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var35.tab = var28;
var35.length = var30;
var35.index = var29;
var35.next = var21;
var21 = var35;
class="kw">continue;
}
if (var27 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var27 = ((Float2ObjectConcurrentHashMap.TreeBin)var27).first;
} else {
var27 = null;
}
}
if (var21 == null) {
if ((var23 = var29 + var26) >= var30) {
var23 = ++var24;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var3 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var4 = var3;
Float2ObjectConcurrentHashMap.Node var5 = null;
Float2ObjectConcurrentHashMap.TableStack var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
int var8 = 0;
int var9 = 0;
int var10 = var3.length;
int var11 = var3.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var13, var14)) != null && var12.hash < 0) {
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var4 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var12).nextTable;
var12 = null;
Float2ObjectConcurrentHashMap.TableStack var20 = var7;
if (var20 != null) {
var7 = var20.next;
} else {
var20 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var20.tab = var13;
var20.length = var15;
var20.index = var14;
var20.next = var6;
var6 = var20;
class="kw">continue;
}
if (var12 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var12 = ((Float2ObjectConcurrentHashMap.TreeBin)var12).first;
} else {
var12 = null;
}
}
if (var6 == null) {
if ((var8 = var14 + var11) >= var15) {
var8 = ++var9;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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();
}
Float2ObjectConcurrentHashMap.Node[] var4 = this.map.table;
if (this.map.table != null) {
Float2ObjectConcurrentHashMap.Node[] var5 = var4;
Float2ObjectConcurrentHashMap.Node var6 = null;
Float2ObjectConcurrentHashMap.TableStack var7 = null;
Float2ObjectConcurrentHashMap.TableStack var8 = null;
int var9 = 0;
int var10 = 0;
int var11 = var4.length;
int var12 = var4.length;
while (true) {
Float2ObjectConcurrentHashMap.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;
}
Float2ObjectConcurrentHashMap.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 = Float2ObjectConcurrentHashMap.tabAt(var14, var15)) != null && var13.hash < 0) {
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.ForwardingNode) {
var5 = ((Float2ObjectConcurrentHashMap.ForwardingNode)var13).nextTable;
var13 = null;
Float2ObjectConcurrentHashMap.TableStack var21 = var8;
if (var21 != null) {
var8 = var21.next;
} else {
var21 = new Float2ObjectConcurrentHashMap.TableStack<>();
}
var21.tab = var14;
var21.length = var16;
var21.index = var15;
var21.next = var7;
var7 = var21;
class="kw">continue;
}
if (var13 class="kw">instanceof Float2ObjectConcurrentHashMap.TreeBin) {
var13 = ((Float2ObjectConcurrentHashMap.TreeBin)var13).first;
} else {
var13 = null;
}
}
if (var7 == null) {
if ((var9 = var15 + var12) >= var16) {
var9 = ++var10;
}
} else {
while (true) {
Float2ObjectConcurrentHashMap.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;
Float2ObjectConcurrentHashMap.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);
}
}
}
}
}