HashMap 源码

jdk版本信息：

java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)

package java.util;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import sun.misc.SharedSecrets;

public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable {
    private static final long serialVersionUID = 362498820763181265L;
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    static final int MAXIMUM_CAPACITY = 1073741824;
    static final float DEFAULT_LOAD_FACTOR = 0.75F;
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;
    transient HashMap.Node<K, V>[] table;
    transient Set<Entry<K, V>> entrySet;
    transient int size;
    transient int modCount;
    int threshold;
    final float loadFactor;

    static final int hash(Object var0) {
        int var1;
        return var0 == null ? 0 : (var1 = var0.hashCode()) ^ var1 >>> 16;
    }

    static Class<?> comparableClassFor(Object var0) {
        if (var0 instanceof Comparable) {
            Class var1;
            if ((var1 = var0.getClass()) == String.class) {
                return var1;
            }

            Type[] var2;
            if ((var2 = var1.getGenericInterfaces()) != null) {
                for(int var6 = 0; var6 < var2.length; ++var6) {
                    Type[] var3;
                    Type var4;
                    ParameterizedType var5;
                    if ((var4 = var2[var6]) instanceof ParameterizedType && (var5 = (ParameterizedType)var4).getRawType() == Comparable.class && (var3 = var5.getActualTypeArguments()) != null && var3.length == 1 && var3[0] == var1) {
                        return var1;
                    }
                }
            }
        }

        return null;
    }

    static int compareComparables(Class<?> var0, Object var1, Object var2) {
        return var2 != null && var2.getClass() == var0 ? ((Comparable)var1).compareTo(var2) : 0;
    }

    static final int tableSizeFor(int var0) {
        int var1 = var0 - 1;
        var1 |= var1 >>> 1;
        var1 |= var1 >>> 2;
        var1 |= var1 >>> 4;
        var1 |= var1 >>> 8;
        var1 |= var1 >>> 16;
        return var1 < 0 ? 1 : (var1 >= 1073741824 ? 1073741824 : var1 + 1);
    }

    public HashMap(int var1, float var2) {
        if (var1 < 0) {
            throw new IllegalArgumentException("Illegal initial capacity: " + var1);
        } else {
            if (var1 > 1073741824) {
                var1 = 1073741824;
            }

            if (var2 > 0.0F && !Float.isNaN(var2)) {
                this.loadFactor = var2;
                this.threshold = tableSizeFor(var1);
            } else {
                throw new IllegalArgumentException("Illegal load factor: " + var2);
            }
        }
    }

    public HashMap(int var1) {
        this(var1, 0.75F);
    }

    public HashMap() {
        this.loadFactor = 0.75F;
    }

    public HashMap(Map<? extends K, ? extends V> var1) {
        this.loadFactor = 0.75F;
        this.putMapEntries(var1, false);
    }

    final void putMapEntries(Map<? extends K, ? extends V> var1, boolean var2) {
        int var3 = var1.size();
        if (var3 > 0) {
            if (this.table == null) {
                float var4 = (float)var3 / this.loadFactor + 1.0F;
                int var5 = var4 < 1.07374182E9F ? (int)var4 : 1073741824;
                if (var5 > this.threshold) {
                    this.threshold = tableSizeFor(var5);
                }
            } else if (var3 > this.threshold) {
                this.resize();
            }

            Iterator var8 = var1.entrySet().iterator();

            while(var8.hasNext()) {
                Entry var9 = (Entry)var8.next();
                Object var6 = var9.getKey();
                Object var7 = var9.getValue();
                this.putVal(hash(var6), var6, var7, false, var2);
            }
        }

    }

    public int size() {
        return this.size;
    }

    public boolean isEmpty() {
        return this.size == 0;
    }

    public V get(Object var1) {
        HashMap.Node var2;
        return (var2 = this.getNode(hash(var1), var1)) == null ? null : var2.value;
    }

    final HashMap.Node<K, V> getNode(int var1, Object var2) {
        HashMap.Node[] var3 = this.table;
        HashMap.Node var4;
        int var6;
        if (this.table != null && (var6 = var3.length) > 0 && (var4 = var3[var6 - 1 & var1]) != null) {
            Object var7;
            if (var4.hash == var1) {
                var7 = var4.key;
                if (var4.key == var2 || var2 != null && var2.equals(var7)) {
                    return var4;
                }
            }

            HashMap.Node var5 = var4.next;
            if (var4.next != null) {
                if (var4 instanceof HashMap.TreeNode) {
                    return ((HashMap.TreeNode)var4).getTreeNode(var1, var2);
                }

                do {
                    if (var5.hash == var1) {
                        var7 = var5.key;
                        if (var5.key == var2 || var2 != null && var2.equals(var7)) {
                            return var5;
                        }
                    }
                } while((var5 = var5.next) != null);
            }
        }

        return null;
    }

    public boolean containsKey(Object var1) {
        return this.getNode(hash(var1), var1) != null;
    }

    public V put(K var1, V var2) {
        return this.putVal(hash(var1), var1, var2, false, true);
    }

    final V putVal(int var1, K var2, V var3, boolean var4, boolean var5) {
        HashMap.Node[] var6 = this.table;
        int var8;
        if (this.table == null || (var8 = var6.length) == 0) {
            var8 = (var6 = this.resize()).length;
        }

        Object var7;
        int var9;
        if ((var7 = var6[var9 = var8 - 1 & var1]) == null) {
            var6[var9] = this.newNode(var1, var2, var3, (HashMap.Node)null);
        } else {
            Object var10;
            label79: {
                Object var11;
                if (((HashMap.Node)var7).hash == var1) {
                    var11 = ((HashMap.Node)var7).key;
                    if (((HashMap.Node)var7).key == var2 || var2 != null && var2.equals(var11)) {
                        var10 = var7;
                        break label79;
                    }
                }

                if (var7 instanceof HashMap.TreeNode) {
                    var10 = ((HashMap.TreeNode)var7).putTreeVal(this, var6, var1, var2, var3);
                } else {
                    int var12 = 0;

                    while(true) {
                        var10 = ((HashMap.Node)var7).next;
                        if (((HashMap.Node)var7).next == null) {
                            ((HashMap.Node)var7).next = this.newNode(var1, var2, var3, (HashMap.Node)null);
                            if (var12 >= 7) {
                                this.treeifyBin(var6, var1);
                            }
                            break;
                        }

                        if (((HashMap.Node)var10).hash == var1) {
                            var11 = ((HashMap.Node)var10).key;
                            if (((HashMap.Node)var10).key == var2 || var2 != null && var2.equals(var11)) {
                                break;
                            }
                        }

                        var7 = var10;
                        ++var12;
                    }
                }
            }

            if (var10 != null) {
                Object var13 = ((HashMap.Node)var10).value;
                if (!var4 || var13 == null) {
                    ((HashMap.Node)var10).value = var3;
                }

                this.afterNodeAccess((HashMap.Node)var10);
                return var13;
            }
        }

        ++this.modCount;
        if (++this.size > this.threshold) {
            this.resize();
        }

        this.afterNodeInsertion(var5);
        return null;
    }

    final HashMap.Node<K, V>[] resize() {
        HashMap.Node[] var1 = this.table;
        int var2 = var1 == null ? 0 : var1.length;
        int var3 = this.threshold;
        int var5 = 0;
        int var4;
        if (var2 > 0) {
            if (var2 >= 1073741824) {
                this.threshold = 2147483647;
                return var1;
            }

            if ((var4 = var2 << 1) < 1073741824 && var2 >= 16) {
                var5 = var3 << 1;
            }
        } else if (var3 > 0) {
            var4 = var3;
        } else {
            var4 = 16;
            var5 = 12;
        }

        if (var5 == 0) {
            float var6 = (float)var4 * this.loadFactor;
            var5 = var4 < 1073741824 && var6 < 1.07374182E9F ? (int)var6 : 2147483647;
        }

        this.threshold = var5;
        HashMap.Node[] var14 = (HashMap.Node[])(new HashMap.Node[var4]);
        this.table = var14;
        if (var1 != null) {
            for(int var7 = 0; var7 < var2; ++var7) {
                HashMap.Node var8;
                if ((var8 = var1[var7]) != null) {
                    var1[var7] = null;
                    if (var8.next == null) {
                        var14[var8.hash & var4 - 1] = var8;
                    } else if (var8 instanceof HashMap.TreeNode) {
                        ((HashMap.TreeNode)var8).split(this, var14, var7, var2);
                    } else {
                        HashMap.Node var9 = null;
                        HashMap.Node var10 = null;
                        HashMap.Node var11 = null;
                        HashMap.Node var12 = null;

                        HashMap.Node var13;
                        do {
                            var13 = var8.next;
                            if ((var8.hash & var2) == 0) {
                                if (var10 == null) {
                                    var9 = var8;
                                } else {
                                    var10.next = var8;
                                }

                                var10 = var8;
                            } else {
                                if (var12 == null) {
                                    var11 = var8;
                                } else {
                                    var12.next = var8;
                                }

                                var12 = var8;
                            }

                            var8 = var13;
                        } while(var13 != null);

                        if (var10 != null) {
                            var10.next = null;
                            var14[var7] = var9;
                        }

                        if (var12 != null) {
                            var12.next = null;
                            var14[var7 + var2] = var11;
                        }
                    }
                }
            }
        }

        return var14;
    }

    final void treeifyBin(HashMap.Node<K, V>[] var1, int var2) {
        int var3;
        if (var1 != null && (var3 = var1.length) >= 64) {
            int var4;
            HashMap.Node var5;
            if ((var5 = var1[var4 = var3 - 1 & var2]) != null) {
                HashMap.TreeNode var6 = null;
                HashMap.TreeNode var7 = null;

                do {
                    HashMap.TreeNode var8 = this.replacementTreeNode(var5, (HashMap.Node)null);
                    if (var7 == null) {
                        var6 = var8;
                    } else {
                        var8.prev = var7;
                        var7.next = var8;
                    }

                    var7 = var8;
                } while((var5 = var5.next) != null);

                if ((var1[var4] = var6) != null) {
                    var6.treeify(var1);
                }
            }
        } else {
            this.resize();
        }

    }

    public void putAll(Map<? extends K, ? extends V> var1) {
        this.putMapEntries(var1, true);
    }

    public V remove(Object var1) {
        HashMap.Node var2;
        return (var2 = this.removeNode(hash(var1), var1, (Object)null, false, true)) == null ? null : var2.value;
    }

    final HashMap.Node<K, V> removeNode(int var1, Object var2, Object var3, boolean var4, boolean var5) {
        HashMap.Node[] var6;
        HashMap.Node var7;
        int var9;
        Object var10;
        label89: {
            var6 = this.table;
            int var8;
            if (this.table != null && (var8 = var6.length) > 0 && (var7 = var6[var9 = var8 - 1 & var1]) != null) {
                label90: {
                    var10 = null;
                    Object var12;
                    if (var7.hash == var1) {
                        var12 = var7.key;
                        if (var7.key == var2 || var2 != null && var2.equals(var12)) {
                            var10 = var7;
                            break label90;
                        }
                    }

                    HashMap.Node var11 = var7.next;
                    if (var7.next != null) {
                        if (var7 instanceof HashMap.TreeNode) {
                            var10 = ((HashMap.TreeNode)var7).getTreeNode(var1, var2);
                        } else {
                            do {
                                if (var11.hash == var1) {
                                    var12 = var11.key;
                                    if (var11.key == var2 || var2 != null && var2.equals(var12)) {
                                        var10 = var11;
                                        break;
                                    }
                                }

                                var7 = var11;
                            } while((var11 = var11.next) != null);
                        }
                    }
                }

                if (var10 != null) {
                    if (!var4) {
                        break label89;
                    }

                    Object var13 = ((HashMap.Node)var10).value;
                    if (((HashMap.Node)var10).value == var3 || var3 != null && var3.equals(var13)) {
                        break label89;
                    }
                }
            }

            return null;
        }

        if (var10 instanceof HashMap.TreeNode) {
            ((HashMap.TreeNode)var10).removeTreeNode(this, var6, var5);
        } else if (var10 == var7) {
            var6[var9] = ((HashMap.Node)var10).next;
        } else {
            var7.next = ((HashMap.Node)var10).next;
        }

        ++this.modCount;
        --this.size;
        this.afterNodeRemoval((HashMap.Node)var10);
        return (HashMap.Node)var10;
    }

    public void clear() {
        ++this.modCount;
        HashMap.Node[] var1 = this.table;
        if (this.table != null && this.size > 0) {
            this.size = 0;

            for(int var2 = 0; var2 < var1.length; ++var2) {
                var1[var2] = null;
            }
        }

    }

    public boolean containsValue(Object var1) {
        HashMap.Node[] var2 = this.table;
        if (this.table != null && this.size > 0) {
            for(int var4 = 0; var4 < var2.length; ++var4) {
                for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                    Object var3 = var5.value;
                    if (var5.value == var1 || var1 != null && var1.equals(var3)) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    public Set<K> keySet() {
        Object var1 = this.keySet;
        if (var1 == null) {
            var1 = new HashMap.KeySet();
            this.keySet = (Set)var1;
        }

        return (Set)var1;
    }

    public Collection<V> values() {
        Object var1 = this.values;
        if (var1 == null) {
            var1 = new HashMap.Values();
            this.values = (Collection)var1;
        }

        return (Collection)var1;
    }

    public Set<Entry<K, V>> entrySet() {
        Set var1 = this.entrySet;
        return this.entrySet == null ? (this.entrySet = new HashMap.EntrySet()) : var1;
    }

    public V getOrDefault(Object var1, V var2) {
        HashMap.Node var3;
        return (var3 = this.getNode(hash(var1), var1)) == null ? var2 : var3.value;
    }

    public V putIfAbsent(K var1, V var2) {
        return this.putVal(hash(var1), var1, var2, true, true);
    }

    public boolean remove(Object var1, Object var2) {
        return this.removeNode(hash(var1), var1, var2, true, true) != null;
    }

    public boolean replace(K var1, V var2, V var3) {
        HashMap.Node var4;
        if ((var4 = this.getNode(hash(var1), var1)) != null) {
            Object var5 = var4.value;
            if (var4.value == var2 || var5 != null && var5.equals(var2)) {
                var4.value = var3;
                this.afterNodeAccess(var4);
                return true;
            }
        }

        return false;
    }

    public V replace(K var1, V var2) {
        HashMap.Node var3;
        if ((var3 = this.getNode(hash(var1), var1)) != null) {
            Object var4 = var3.value;
            var3.value = var2;
            this.afterNodeAccess(var3);
            return var4;
        } else {
            return null;
        }
    }

    public V computeIfAbsent(K var1, Function<? super K, ? extends V> var2) {
        if (var2 == null) {
            throw new NullPointerException();
        } else {
            int var3;
            HashMap.Node[] var4;
            int var6;
            int var8;
            HashMap.TreeNode var9;
            Object var10;
            label63: {
                var3 = hash(var1);
                var8 = 0;
                var9 = null;
                var10 = null;
                if (this.size <= this.threshold) {
                    var4 = this.table;
                    if (this.table != null && (var6 = var4.length) != 0) {
                        break label63;
                    }
                }

                var6 = (var4 = this.resize()).length;
            }

            HashMap.Node var5;
            int var7;
            Object var13;
            if ((var5 = var4[var7 = var6 - 1 & var3]) != null) {
                if (var5 instanceof HashMap.TreeNode) {
                    var10 = (var9 = (HashMap.TreeNode)var5).getTreeNode(var3, var1);
                } else {
                    HashMap.Node var11 = var5;

                    do {
                        if (var11.hash == var3) {
                            Object var12 = var11.key;
                            if (var11.key == var1 || var1 != null && var1.equals(var12)) {
                                var10 = var11;
                                break;
                            }
                        }

                        ++var8;
                    } while((var11 = var11.next) != null);
                }

                if (var10 != null) {
                    var13 = ((HashMap.Node)var10).value;
                    if (((HashMap.Node)var10).value != null) {
                        this.afterNodeAccess((HashMap.Node)var10);
                        return var13;
                    }
                }
            }

            var13 = var2.apply(var1);
            if (var13 == null) {
                return null;
            } else if (var10 != null) {
                ((HashMap.Node)var10).value = var13;
                this.afterNodeAccess((HashMap.Node)var10);
                return var13;
            } else {
                if (var9 != null) {
                    var9.putTreeVal(this, var4, var3, var1, var13);
                } else {
                    var4[var7] = this.newNode(var3, var1, var13, var5);
                    if (var8 >= 7) {
                        this.treeifyBin(var4, var3);
                    }
                }

                ++this.modCount;
                ++this.size;
                this.afterNodeInsertion(true);
                return var13;
            }
        }
    }

    public V computeIfPresent(K var1, BiFunction<? super K, ? super V, ? extends V> var2) {
        if (var2 == null) {
            throw new NullPointerException();
        } else {
            int var5 = hash(var1);
            HashMap.Node var3;
            if ((var3 = this.getNode(var5, var1)) != null) {
                Object var4 = var3.value;
                if (var3.value != null) {
                    Object var6 = var2.apply(var1, var4);
                    if (var6 != null) {
                        var3.value = var6;
                        this.afterNodeAccess(var3);
                        return var6;
                    }

                    this.removeNode(var5, var1, (Object)null, false, true);
                }
            }

            return null;
        }
    }

    public V compute(K var1, BiFunction<? super K, ? super V, ? extends V> var2) {
        if (var2 == null) {
            throw new NullPointerException();
        } else {
            int var3;
            HashMap.Node[] var4;
            int var6;
            int var8;
            HashMap.TreeNode var9;
            Object var10;
            label63: {
                var3 = hash(var1);
                var8 = 0;
                var9 = null;
                var10 = null;
                if (this.size <= this.threshold) {
                    var4 = this.table;
                    if (this.table != null && (var6 = var4.length) != 0) {
                        break label63;
                    }
                }

                var6 = (var4 = this.resize()).length;
            }

            HashMap.Node var5;
            int var7;
            Object var12;
            if ((var5 = var4[var7 = var6 - 1 & var3]) != null) {
                if (var5 instanceof HashMap.TreeNode) {
                    var10 = (var9 = (HashMap.TreeNode)var5).getTreeNode(var3, var1);
                } else {
                    HashMap.Node var11 = var5;

                    do {
                        if (var11.hash == var3) {
                            var12 = var11.key;
                            if (var11.key == var1 || var1 != null && var1.equals(var12)) {
                                var10 = var11;
                                break;
                            }
                        }

                        ++var8;
                    } while((var11 = var11.next) != null);
                }
            }

            Object var13 = var10 == null ? null : ((HashMap.Node)var10).value;
            var12 = var2.apply(var1, var13);
            if (var10 != null) {
                if (var12 != null) {
                    ((HashMap.Node)var10).value = var12;
                    this.afterNodeAccess((HashMap.Node)var10);
                } else {
                    this.removeNode(var3, var1, (Object)null, false, true);
                }
            } else if (var12 != null) {
                if (var9 != null) {
                    var9.putTreeVal(this, var4, var3, var1, var12);
                } else {
                    var4[var7] = this.newNode(var3, var1, var12, var5);
                    if (var8 >= 7) {
                        this.treeifyBin(var4, var3);
                    }
                }

                ++this.modCount;
                ++this.size;
                this.afterNodeInsertion(true);
            }

            return var12;
        }
    }

    public V merge(K var1, V var2, BiFunction<? super V, ? super V, ? extends V> var3) {
        if (var2 == null) {
            throw new NullPointerException();
        } else if (var3 == null) {
            throw new NullPointerException();
        } else {
            int var4;
            HashMap.Node[] var5;
            int var7;
            int var9;
            HashMap.TreeNode var10;
            Object var11;
            label68: {
                var4 = hash(var1);
                var9 = 0;
                var10 = null;
                var11 = null;
                if (this.size <= this.threshold) {
                    var5 = this.table;
                    if (this.table != null && (var7 = var5.length) != 0) {
                        break label68;
                    }
                }

                var7 = (var5 = this.resize()).length;
            }

            HashMap.Node var6;
            int var8;
            if ((var6 = var5[var8 = var7 - 1 & var4]) != null) {
                if (var6 instanceof HashMap.TreeNode) {
                    var11 = (var10 = (HashMap.TreeNode)var6).getTreeNode(var4, var1);
                } else {
                    HashMap.Node var12 = var6;

                    do {
                        if (var12.hash == var4) {
                            Object var13 = var12.key;
                            if (var12.key == var1 || var1 != null && var1.equals(var13)) {
                                var11 = var12;
                                break;
                            }
                        }

                        ++var9;
                    } while((var12 = var12.next) != null);
                }
            }

            if (var11 != null) {
                Object var14;
                if (((HashMap.Node)var11).value != null) {
                    var14 = var3.apply(((HashMap.Node)var11).value, var2);
                } else {
                    var14 = var2;
                }

                if (var14 != null) {
                    ((HashMap.Node)var11).value = var14;
                    this.afterNodeAccess((HashMap.Node)var11);
                } else {
                    this.removeNode(var4, var1, (Object)null, false, true);
                }

                return var14;
            } else {
                if (var2 != null) {
                    if (var10 != null) {
                        var10.putTreeVal(this, var5, var4, var1, var2);
                    } else {
                        var5[var8] = this.newNode(var4, var1, var2, var6);
                        if (var9 >= 7) {
                            this.treeifyBin(var5, var4);
                        }
                    }

                    ++this.modCount;
                    ++this.size;
                    this.afterNodeInsertion(true);
                }

                return var2;
            }
        }
    }

    public void forEach(BiConsumer<? super K, ? super V> var1) {
        if (var1 == null) {
            throw new NullPointerException();
        } else {
            if (this.size > 0) {
                HashMap.Node[] var2 = this.table;
                if (this.table != null) {
                    int var3 = this.modCount;

                    for(int var4 = 0; var4 < var2.length; ++var4) {
                        for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                            var1.accept(var5.key, var5.value);
                        }
                    }

                    if (this.modCount != var3) {
                        throw new ConcurrentModificationException();
                    }
                }
            }

        }
    }

    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> var1) {
        if (var1 == null) {
            throw new NullPointerException();
        } else {
            if (this.size > 0) {
                HashMap.Node[] var2 = this.table;
                if (this.table != null) {
                    int var3 = this.modCount;

                    for(int var4 = 0; var4 < var2.length; ++var4) {
                        for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                            var5.value = var1.apply(var5.key, var5.value);
                        }
                    }

                    if (this.modCount != var3) {
                        throw new ConcurrentModificationException();
                    }
                }
            }

        }
    }

    public Object clone() {
        HashMap var1;
        try {
            var1 = (HashMap)super.clone();
        } catch (CloneNotSupportedException var3) {
            throw new InternalError(var3);
        }

        var1.reinitialize();
        var1.putMapEntries(this, false);
        return var1;
    }

    final float loadFactor() {
        return this.loadFactor;
    }

    final int capacity() {
        return this.table != null ? this.table.length : (this.threshold > 0 ? this.threshold : 16);
    }

    private void writeObject(ObjectOutputStream var1) throws IOException {
        int var2 = this.capacity();
        var1.defaultWriteObject();
        var1.writeInt(var2);
        var1.writeInt(this.size);
        this.internalWriteEntries(var1);
    }

    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
        var1.defaultReadObject();
        this.reinitialize();
        if (this.loadFactor > 0.0F && !Float.isNaN(this.loadFactor)) {
            var1.readInt();
            int var2 = var1.readInt();
            if (var2 < 0) {
                throw new InvalidObjectException("Illegal mappings count: " + var2);
            } else {
                if (var2 > 0) {
                    float var3 = Math.min(Math.max(0.25F, this.loadFactor), 4.0F);
                    float var4 = (float)var2 / var3 + 1.0F;
                    int var5 = var4 < 16.0F ? 16 : (var4 >= 1.07374182E9F ? 1073741824 : tableSizeFor((int)var4));
                    float var6 = (float)var5 * var3;
                    this.threshold = var5 < 1073741824 && var6 < 1.07374182E9F ? (int)var6 : 2147483647;
                    SharedSecrets.getJavaOISAccess().checkArray(var1, Entry[].class, var5);
                    HashMap.Node[] var7 = (HashMap.Node[])(new HashMap.Node[var5]);
                    this.table = var7;

                    for(int var8 = 0; var8 < var2; ++var8) {
                        Object var9 = var1.readObject();
                        Object var10 = var1.readObject();
                        this.putVal(hash(var9), var9, var10, false, false);
                    }
                }

            }
        } else {
            throw new InvalidObjectException("Illegal load factor: " + this.loadFactor);
        }
    }

    HashMap.Node<K, V> newNode(int var1, K var2, V var3, HashMap.Node<K, V> var4) {
        return new HashMap.Node(var1, var2, var3, var4);
    }

    HashMap.Node<K, V> replacementNode(HashMap.Node<K, V> var1, HashMap.Node<K, V> var2) {
        return new HashMap.Node(var1.hash, var1.key, var1.value, var2);
    }

    HashMap.TreeNode<K, V> newTreeNode(int var1, K var2, V var3, HashMap.Node<K, V> var4) {
        return new HashMap.TreeNode(var1, var2, var3, var4);
    }

    HashMap.TreeNode<K, V> replacementTreeNode(HashMap.Node<K, V> var1, HashMap.Node<K, V> var2) {
        return new HashMap.TreeNode(var1.hash, var1.key, var1.value, var2);
    }

    void reinitialize() {
        this.table = null;
        this.entrySet = null;
        this.keySet = null;
        this.values = null;
        this.modCount = 0;
        this.threshold = 0;
        this.size = 0;
    }

    void afterNodeAccess(HashMap.Node<K, V> var1) {
    }

    void afterNodeInsertion(boolean var1) {
    }

    void afterNodeRemoval(HashMap.Node<K, V> var1) {
    }

    void internalWriteEntries(ObjectOutputStream var1) throws IOException {
        if (this.size > 0) {
            HashMap.Node[] var2 = this.table;
            if (this.table != null) {
                for(int var3 = 0; var3 < var2.length; ++var3) {
                    for(HashMap.Node var4 = var2[var3]; var4 != null; var4 = var4.next) {
                        var1.writeObject(var4.key);
                        var1.writeObject(var4.value);
                    }
                }
            }
        }

    }

    final class EntryIterator extends HashMap<K, V>.HashIterator implements Iterator<Entry<K, V>> {
        EntryIterator() {
            super();
        }

        public final Entry<K, V> next() {
            return this.nextNode();
        }
    }

    final class EntrySet extends AbstractSet<Entry<K, V>> {
        EntrySet() {
        }

        public final int size() {
            return HashMap.this.size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<Entry<K, V>> iterator() {
            return HashMap.this.new EntryIterator();
        }

        public final boolean contains(Object var1) {
            if (!(var1 instanceof Entry)) {
                return false;
            } else {
                Entry var2 = (Entry)var1;
                Object var3 = var2.getKey();
                HashMap.Node var4 = HashMap.this.getNode(HashMap.hash(var3), var3);
                return var4 != null && var4.equals(var2);
            }
        }

        public final boolean remove(Object var1) {
            if (var1 instanceof Entry) {
                Entry var2 = (Entry)var1;
                Object var3 = var2.getKey();
                Object var4 = var2.getValue();
                return HashMap.this.removeNode(HashMap.hash(var3), var3, var4, true, true) != null;
            } else {
                return false;
            }
        }

        public final Spliterator<Entry<K, V>> spliterator() {
            return new HashMap.EntrySpliterator(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super Entry<K, V>> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                if (HashMap.this.size > 0) {
                    HashMap.Node[] var2 = HashMap.this.table;
                    if (HashMap.this.table != null) {
                        int var3 = HashMap.this.modCount;

                        for(int var4 = 0; var4 < var2.length; ++var4) {
                            for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                                var1.accept(var5);
                            }
                        }

                        if (HashMap.this.modCount != var3) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }
    }

    static final class EntrySpliterator<K, V> extends HashMap.HashMapSpliterator<K, V> implements Spliterator<Entry<K, V>> {
        EntrySpliterator(HashMap<K, V> var1, int var2, int var3, int var4, int var5) {
            super(var1, var2, var3, var4, var5);
        }

        public HashMap.EntrySpliterator<K, V> trySplit() {
            int var1 = this.getFence();
            int var2 = this.index;
            int var3 = var2 + var1 >>> 1;
            return var2 < var3 && this.current == null ? new HashMap.EntrySpliterator(this.map, var2, this.index = var3, this.est >>>= 1, this.expectedModCount) : null;
        }

        public void forEachRemaining(Consumer<? super Entry<K, V>> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap var5 = this.map;
                HashMap.Node[] var6 = var5.table;
                int var3 = this.fence;
                int var4;
                if (this.fence < 0) {
                    var4 = this.expectedModCount = var5.modCount;
                    var3 = this.fence = var6 == null ? 0 : var6.length;
                } else {
                    var4 = this.expectedModCount;
                }

                if (var6 != null && var6.length >= var3) {
                    int var2 = this.index;
                    if (this.index >= 0 && (var2 < (this.index = var3) || this.current != null)) {
                        HashMap.Node var7 = this.current;
                        this.current = null;

                        do {
                            do {
                                if (var7 == null) {
                                    var7 = var6[var2++];
                                } else {
                                    var1.accept(var7);
                                    var7 = var7.next;
                                }
                            } while(var7 != null);
                        } while(var2 < var3);

                        if (var5.modCount != var4) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }

        public boolean tryAdvance(Consumer<? super Entry<K, V>> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap.Node[] var3 = this.map.table;
                int var2;
                if (var3 != null && var3.length >= (var2 = this.getFence()) && this.index >= 0) {
                    while(this.current != null || this.index < var2) {
                        if (this.current != null) {
                            HashMap.Node var4 = this.current;
                            this.current = this.current.next;
                            var1.accept(var4);
                            if (this.map.modCount != this.expectedModCount) {
                                throw new ConcurrentModificationException();
                            }

                            return true;
                        }

                        this.current = var3[this.index++];
                    }
                }

                return false;
            }
        }

        public int characteristics() {
            return (this.fence >= 0 && this.est != this.map.size ? 0 : 64) | 1;
        }
    }

    abstract class HashIterator {
        HashMap.Node<K, V> next;
        HashMap.Node<K, V> current;
        int expectedModCount;
        int index;

        HashIterator() {
            this.expectedModCount = HashMap.this.modCount;
            HashMap.Node[] var2 = HashMap.this.table;
            this.current = this.next = null;
            this.index = 0;
            if (var2 != null && HashMap.this.size > 0) {
                while(this.index < var2.length && (this.next = var2[this.index++]) == null) {
                    ;
                }
            }

        }

        public final boolean hasNext() {
            return this.next != null;
        }

        final HashMap.Node<K, V> nextNode() {
            HashMap.Node var2 = this.next;
            if (HashMap.this.modCount != this.expectedModCount) {
                throw new ConcurrentModificationException();
            } else if (var2 == null) {
                throw new NoSuchElementException();
            } else {
                if ((this.next = (this.current = var2).next) == null) {
                    HashMap.Node[] var1 = HashMap.this.table;
                    if (HashMap.this.table != null) {
                        while(this.index < var1.length && (this.next = var1[this.index++]) == null) {
                            ;
                        }
                    }
                }

                return var2;
            }
        }

        public final void remove() {
            HashMap.Node var1 = this.current;
            if (var1 == null) {
                throw new IllegalStateException();
            } else if (HashMap.this.modCount != this.expectedModCount) {
                throw new ConcurrentModificationException();
            } else {
                this.current = null;
                Object var2 = var1.key;
                HashMap.this.removeNode(HashMap.hash(var2), var2, (Object)null, false, false);
                this.expectedModCount = HashMap.this.modCount;
            }
        }
    }

    static class HashMapSpliterator<K, V> {
        final HashMap<K, V> map;
        HashMap.Node<K, V> current;
        int index;
        int fence;
        int est;
        int expectedModCount;

        HashMapSpliterator(HashMap<K, V> var1, int var2, int var3, int var4, int var5) {
            this.map = var1;
            this.index = var2;
            this.fence = var3;
            this.est = var4;
            this.expectedModCount = var5;
        }

        final int getFence() {
            int var1 = this.fence;
            if (this.fence < 0) {
                HashMap var2 = this.map;
                this.est = var2.size;
                this.expectedModCount = var2.modCount;
                HashMap.Node[] var3 = var2.table;
                var1 = this.fence = var3 == null ? 0 : var3.length;
            }

            return var1;
        }

        public final long estimateSize() {
            this.getFence();
            return (long)this.est;
        }
    }

    final class KeyIterator extends HashMap<K, V>.HashIterator implements Iterator<K> {
        KeyIterator() {
            super();
        }

        public final K next() {
            return this.nextNode().key;
        }
    }

    final class KeySet extends AbstractSet<K> {
        KeySet() {
        }

        public final int size() {
            return HashMap.this.size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<K> iterator() {
            return HashMap.this.new KeyIterator();
        }

        public final boolean contains(Object var1) {
            return HashMap.this.containsKey(var1);
        }

        public final boolean remove(Object var1) {
            return HashMap.this.removeNode(HashMap.hash(var1), var1, (Object)null, false, true) != null;
        }

        public final Spliterator<K> spliterator() {
            return new HashMap.KeySpliterator(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super K> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                if (HashMap.this.size > 0) {
                    HashMap.Node[] var2 = HashMap.this.table;
                    if (HashMap.this.table != null) {
                        int var3 = HashMap.this.modCount;

                        for(int var4 = 0; var4 < var2.length; ++var4) {
                            for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                                var1.accept(var5.key);
                            }
                        }

                        if (HashMap.this.modCount != var3) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }
    }

    static final class KeySpliterator<K, V> extends HashMap.HashMapSpliterator<K, V> implements Spliterator<K> {
        KeySpliterator(HashMap<K, V> var1, int var2, int var3, int var4, int var5) {
            super(var1, var2, var3, var4, var5);
        }

        public HashMap.KeySpliterator<K, V> trySplit() {
            int var1 = this.getFence();
            int var2 = this.index;
            int var3 = var2 + var1 >>> 1;
            return var2 < var3 && this.current == null ? new HashMap.KeySpliterator(this.map, var2, this.index = var3, this.est >>>= 1, this.expectedModCount) : null;
        }

        public void forEachRemaining(Consumer<? super K> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap var5 = this.map;
                HashMap.Node[] var6 = var5.table;
                int var3 = this.fence;
                int var4;
                if (this.fence < 0) {
                    var4 = this.expectedModCount = var5.modCount;
                    var3 = this.fence = var6 == null ? 0 : var6.length;
                } else {
                    var4 = this.expectedModCount;
                }

                if (var6 != null && var6.length >= var3) {
                    int var2 = this.index;
                    if (this.index >= 0 && (var2 < (this.index = var3) || this.current != null)) {
                        HashMap.Node var7 = this.current;
                        this.current = null;

                        do {
                            do {
                                if (var7 == null) {
                                    var7 = var6[var2++];
                                } else {
                                    var1.accept(var7.key);
                                    var7 = var7.next;
                                }
                            } while(var7 != null);
                        } while(var2 < var3);

                        if (var5.modCount != var4) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }

        public boolean tryAdvance(Consumer<? super K> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap.Node[] var3 = this.map.table;
                int var2;
                if (var3 != null && var3.length >= (var2 = this.getFence()) && this.index >= 0) {
                    while(this.current != null || this.index < var2) {
                        if (this.current != null) {
                            Object var4 = this.current.key;
                            this.current = this.current.next;
                            var1.accept(var4);
                            if (this.map.modCount != this.expectedModCount) {
                                throw new ConcurrentModificationException();
                            }

                            return true;
                        }

                        this.current = var3[this.index++];
                    }
                }

                return false;
            }
        }

        public int characteristics() {
            return (this.fence >= 0 && this.est != this.map.size ? 0 : 64) | 1;
        }
    }

    static class Node<K, V> implements Entry<K, V> {
        final int hash;
        final K key;
        V value;
        HashMap.Node<K, V> next;

        Node(int var1, K var2, V var3, HashMap.Node<K, V> var4) {
            this.hash = var1;
            this.key = var2;
            this.value = var3;
            this.next = var4;
        }

        public final K getKey() {
            return this.key;
        }

        public final V getValue() {
            return this.value;
        }

        public final String toString() {
            return this.key + "=" + this.value;
        }

        public final int hashCode() {
            return Objects.hashCode(this.key) ^ Objects.hashCode(this.value);
        }

        public final V setValue(V var1) {
            Object var2 = this.value;
            this.value = var1;
            return var2;
        }

        public final boolean equals(Object var1) {
            if (var1 == this) {
                return true;
            } else {
                if (var1 instanceof Entry) {
                    Entry var2 = (Entry)var1;
                    if (Objects.equals(this.key, var2.getKey()) && Objects.equals(this.value, var2.getValue())) {
                        return true;
                    }
                }

                return false;
            }
        }
    }

    static final class TreeNode<K, V> extends java.util.LinkedHashMap.Entry<K, V> {
        HashMap.TreeNode<K, V> parent;
        HashMap.TreeNode<K, V> left;
        HashMap.TreeNode<K, V> right;
        HashMap.TreeNode<K, V> prev;
        boolean red;

        TreeNode(int var1, K var2, V var3, HashMap.Node<K, V> var4) {
            super(var1, var2, var3, var4);
        }

        final HashMap.TreeNode<K, V> root() {
            HashMap.TreeNode var1 = this;

            while(true) {
                HashMap.TreeNode var2 = var1.parent;
                if (var1.parent == null) {
                    return var1;
                }

                var1 = var2;
            }
        }

        static <K, V> void moveRootToFront(HashMap.Node<K, V>[] var0, HashMap.TreeNode<K, V> var1) {
            int var2;
            if (var1 != null && var0 != null && (var2 = var0.length) > 0) {
                int var3 = var2 - 1 & var1.hash;
                HashMap.TreeNode var4 = (HashMap.TreeNode)var0[var3];
                if (var1 != var4) {
                    var0[var3] = var1;
                    HashMap.TreeNode var6 = var1.prev;
                    HashMap.Node var5 = var1.next;
                    if (var1.next != null) {
                        ((HashMap.TreeNode)var5).prev = var6;
                    }

                    if (var6 != null) {
                        var6.next = var5;
                    }

                    if (var4 != null) {
                        var4.prev = var1;
                    }

                    var1.next = var4;
                    var1.prev = null;
                }

                assert checkInvariants(var1);
            }

        }

        final HashMap.TreeNode<K, V> find(int var1, Object var2, Class<?> var3) {
            HashMap.TreeNode var4 = this;

            do {
                HashMap.TreeNode var8 = var4.left;
                HashMap.TreeNode var9 = var4.right;
                int var5 = var4.hash;
                if (var4.hash > var1) {
                    var4 = var8;
                } else if (var5 < var1) {
                    var4 = var9;
                } else {
                    Object var7 = var4.key;
                    if (var4.key == var2 || var2 != null && var2.equals(var7)) {
                        return var4;
                    }

                    if (var8 == null) {
                        var4 = var9;
                    } else if (var9 == null) {
                        var4 = var8;
                    } else {
                        int var6;
                        if ((var3 != null || (var3 = HashMap.comparableClassFor(var2)) != null) && (var6 = HashMap.compareComparables(var3, var2, var7)) != 0) {
                            var4 = var6 < 0 ? var8 : var9;
                        } else {
                            HashMap.TreeNode var10;
                            if ((var10 = var9.find(var1, var2, var3)) != null) {
                                return var10;
                            }

                            var4 = var8;
                        }
                    }
                }
            } while(var4 != null);

            return null;
        }

        final HashMap.TreeNode<K, V> getTreeNode(int var1, Object var2) {
            return (this.parent != null ? this.root() : this).find(var1, var2, (Class)null);
        }

        static int tieBreakOrder(Object var0, Object var1) {
            int var2;
            if (var0 == null || var1 == null || (var2 = var0.getClass().getName().compareTo(var1.getClass().getName())) == 0) {
                var2 = System.identityHashCode(var0) <= System.identityHashCode(var1) ? -1 : 1;
            }

            return var2;
        }

        final void treeify(HashMap.Node<K, V>[] var1) {
            HashMap.TreeNode var2 = null;

            HashMap.TreeNode var4;
            for(HashMap.TreeNode var3 = this; var3 != null; var3 = var4) {
                var4 = (HashMap.TreeNode)var3.next;
                var3.left = var3.right = null;
                if (var2 == null) {
                    var3.parent = null;
                    var3.red = false;
                    var2 = var3;
                } else {
                    Object var5 = var3.key;
                    int var6 = var3.hash;
                    Class var7 = null;
                    HashMap.TreeNode var8 = var2;

                    int var9;
                    HashMap.TreeNode var12;
                    do {
                        Object var11 = var8.key;
                        int var10 = var8.hash;
                        if (var8.hash > var6) {
                            var9 = -1;
                        } else if (var10 < var6) {
                            var9 = 1;
                        } else if (var7 == null && (var7 = HashMap.comparableClassFor(var5)) == null || (var9 = HashMap.compareComparables(var7, var5, var11)) == 0) {
                            var9 = tieBreakOrder(var5, var11);
                        }

                        var12 = var8;
                    } while((var8 = var9 <= 0 ? var8.left : var8.right) != null);

                    var3.parent = var12;
                    if (var9 <= 0) {
                        var12.left = var3;
                    } else {
                        var12.right = var3;
                    }

                    var2 = balanceInsertion(var2, var3);
                }
            }

            moveRootToFront(var1, var2);
        }

        final HashMap.Node<K, V> untreeify(HashMap<K, V> var1) {
            HashMap.Node var2 = null;
            HashMap.Node var3 = null;

            for(Object var4 = this; var4 != null; var4 = ((HashMap.Node)var4).next) {
                HashMap.Node var5 = var1.replacementNode((HashMap.Node)var4, (HashMap.Node)null);
                if (var3 == null) {
                    var2 = var5;
                } else {
                    var3.next = var5;
                }

                var3 = var5;
            }

            return var2;
        }

        final HashMap.TreeNode<K, V> putTreeVal(HashMap<K, V> var1, HashMap.Node<K, V>[] var2, int var3, K var4, V var5) {
            Class var6 = null;
            boolean var7 = false;
            HashMap.TreeNode var8 = this.parent != null ? this.root() : this;
            HashMap.TreeNode var9 = var8;

            HashMap.TreeNode var13;
            while(true) {
                int var11 = var9.hash;
                int var10;
                if (var9.hash > var3) {
                    var10 = -1;
                } else if (var11 < var3) {
                    var10 = 1;
                } else {
                    Object var12 = var9.key;
                    if (var9.key == var4 || var4 != null && var4.equals(var12)) {
                        return var9;
                    }

                    if (var6 == null && (var6 = HashMap.comparableClassFor(var4)) == null || (var10 = HashMap.compareComparables(var6, var4, var12)) == 0) {
                        if (!var7) {
                            var7 = true;
                            HashMap.TreeNode var14 = var9.left;
                            if (var9.left != null && (var13 = var14.find(var3, var4, var6)) != null) {
                                break;
                            }

                            var14 = var9.right;
                            if (var9.right != null && (var13 = var14.find(var3, var4, var6)) != null) {
                                break;
                            }
                        }

                        var10 = tieBreakOrder(var4, var12);
                    }
                }

                var13 = var9;
                if ((var9 = var10 <= 0 ? var9.left : var9.right) == null) {
                    HashMap.Node var16 = var13.next;
                    HashMap.TreeNode var15 = var1.newTreeNode(var3, var4, var5, var16);
                    if (var10 <= 0) {
                        var13.left = var15;
                    } else {
                        var13.right = var15;
                    }

                    var13.next = var15;
                    var15.parent = var15.prev = var13;
                    if (var16 != null) {
                        ((HashMap.TreeNode)var16).prev = var15;
                    }

                    moveRootToFront(var2, balanceInsertion(var8, var15));
                    return null;
                }
            }

            return var13;
        }

        final void removeTreeNode(HashMap<K, V> var1, HashMap.Node<K, V>[] var2, boolean var3) {
            int var4;
            if (var2 != null && (var4 = var2.length) != 0) {
                int var5 = var4 - 1 & this.hash;
                HashMap.TreeNode var6 = (HashMap.TreeNode)var2[var5];
                HashMap.TreeNode var7 = var6;
                HashMap.TreeNode var9 = (HashMap.TreeNode)this.next;
                HashMap.TreeNode var10 = this.prev;
                if (var10 == null) {
                    var6 = var9;
                    var2[var5] = var9;
                } else {
                    var10.next = var9;
                }

                if (var9 != null) {
                    var9.prev = var10;
                }

                if (var6 != null) {
                    if (var7.parent != null) {
                        var7 = var7.root();
                    }

                    if (var7 != null && var7.right != null) {
                        HashMap.TreeNode var8 = var7.left;
                        if (var7.left != null && var8.left != null) {
                            HashMap.TreeNode var12 = this.left;
                            HashMap.TreeNode var13 = this.right;
                            HashMap.TreeNode var14;
                            HashMap.TreeNode var15;
                            HashMap.TreeNode var16;
                            if (var12 != null && var13 != null) {
                                var15 = var13;

                                while(true) {
                                    var16 = var15.left;
                                    if (var15.left == null) {
                                        boolean var17 = var15.red;
                                        var15.red = this.red;
                                        this.red = var17;
                                        HashMap.TreeNode var18 = var15.right;
                                        HashMap.TreeNode var19 = this.parent;
                                        if (var15 == var13) {
                                            this.parent = var15;
                                            var15.right = this;
                                        } else {
                                            HashMap.TreeNode var20 = var15.parent;
                                            if ((this.parent = var20) != null) {
                                                if (var15 == var20.left) {
                                                    var20.left = this;
                                                } else {
                                                    var20.right = this;
                                                }
                                            }

                                            if ((var15.right = var13) != null) {
                                                var13.parent = var15;
                                            }
                                        }

                                        this.left = null;
                                        if ((this.right = var18) != null) {
                                            var18.parent = this;
                                        }

                                        if ((var15.left = var12) != null) {
                                            var12.parent = var15;
                                        }

                                        if ((var15.parent = var19) == null) {
                                            var7 = var15;
                                        } else if (this == var19.left) {
                                            var19.left = var15;
                                        } else {
                                            var19.right = var15;
                                        }

                                        if (var18 != null) {
                                            var14 = var18;
                                        } else {
                                            var14 = this;
                                        }
                                        break;
                                    }

                                    var15 = var16;
                                }
                            } else if (var12 != null) {
                                var14 = var12;
                            } else if (var13 != null) {
                                var14 = var13;
                            } else {
                                var14 = this;
                            }

                            if (var14 != this) {
                                var15 = var14.parent = this.parent;
                                if (var15 == null) {
                                    var7 = var14;
                                } else if (this == var15.left) {
                                    var15.left = var14;
                                } else {
                                    var15.right = var14;
                                }

                                this.left = this.right = this.parent = null;
                            }

                            var15 = this.red ? var7 : balanceDeletion(var7, var14);
                            if (var14 == this) {
                                var16 = this.parent;
                                this.parent = null;
                                if (var16 != null) {
                                    if (this == var16.left) {
                                        var16.left = null;
                                    } else if (this == var16.right) {
                                        var16.right = null;
                                    }
                                }
                            }

                            if (var3) {
                                moveRootToFront(var2, var15);
                            }

                            return;
                        }
                    }

                    var2[var5] = var6.untreeify(var1);
                }
            }
        }

        final void split(HashMap<K, V> var1, HashMap.Node<K, V>[] var2, int var3, int var4) {
            HashMap.TreeNode var6 = null;
            HashMap.TreeNode var7 = null;
            HashMap.TreeNode var8 = null;
            HashMap.TreeNode var9 = null;
            int var10 = 0;
            int var11 = 0;

            HashMap.TreeNode var13;
            for(HashMap.TreeNode var12 = this; var12 != null; var12 = var13) {
                var13 = (HashMap.TreeNode)var12.next;
                var12.next = null;
                if ((var12.hash & var4) == 0) {
                    if ((var12.prev = var7) == null) {
                        var6 = var12;
                    } else {
                        var7.next = var12;
                    }

                    var7 = var12;
                    ++var10;
                } else {
                    if ((var12.prev = var9) == null) {
                        var8 = var12;
                    } else {
                        var9.next = var12;
                    }

                    var9 = var12;
                    ++var11;
                }
            }

            if (var6 != null) {
                if (var10 <= 6) {
                    var2[var3] = var6.untreeify(var1);
                } else {
                    var2[var3] = var6;
                    if (var8 != null) {
                        var6.treeify(var2);
                    }
                }
            }

            if (var8 != null) {
                if (var11 <= 6) {
                    var2[var3 + var4] = var8.untreeify(var1);
                } else {
                    var2[var3 + var4] = var8;
                    if (var6 != null) {
                        var8.treeify(var2);
                    }
                }
            }

        }

        static <K, V> HashMap.TreeNode<K, V> rotateLeft(HashMap.TreeNode<K, V> var0, HashMap.TreeNode<K, V> var1) {
            if (var1 != null) {
                HashMap.TreeNode var2 = var1.right;
                if (var1.right != null) {
                    HashMap.TreeNode var4;
                    if ((var4 = var1.right = var2.left) != null) {
                        var4.parent = var1;
                    }

                    HashMap.TreeNode var3;
                    if ((var3 = var2.parent = var1.parent) == null) {
                        var0 = var2;
                        var2.red = false;
                    } else if (var3.left == var1) {
                        var3.left = var2;
                    } else {
                        var3.right = var2;
                    }

                    var2.left = var1;
                    var1.parent = var2;
                }
            }

            return var0;
        }

        static <K, V> HashMap.TreeNode<K, V> rotateRight(HashMap.TreeNode<K, V> var0, HashMap.TreeNode<K, V> var1) {
            if (var1 != null) {
                HashMap.TreeNode var2 = var1.left;
                if (var1.left != null) {
                    HashMap.TreeNode var4;
                    if ((var4 = var1.left = var2.right) != null) {
                        var4.parent = var1;
                    }

                    HashMap.TreeNode var3;
                    if ((var3 = var2.parent = var1.parent) == null) {
                        var0 = var2;
                        var2.red = false;
                    } else if (var3.right == var1) {
                        var3.right = var2;
                    } else {
                        var3.left = var2;
                    }

                    var2.right = var1;
                    var1.parent = var2;
                }
            }

            return var0;
        }

        static <K, V> HashMap.TreeNode<K, V> balanceInsertion(HashMap.TreeNode<K, V> var0, HashMap.TreeNode<K, V> var1) {
            var1.red = true;

            while(true) {
                HashMap.TreeNode var2 = var1.parent;
                if (var1.parent == null) {
                    var1.red = false;
                    return var1;
                }

                if (!var2.red) {
                    break;
                }

                HashMap.TreeNode var3 = var2.parent;
                if (var2.parent == null) {
                    break;
                }

                HashMap.TreeNode var4 = var3.left;
                if (var2 == var3.left) {
                    HashMap.TreeNode var5 = var3.right;
                    if (var3.right != null && var5.red) {
                        var5.red = false;
                        var2.red = false;
                        var3.red = true;
                        var1 = var3;
                    } else {
                        if (var1 == var2.right) {
                            var1 = var2;
                            var0 = rotateLeft(var0, var2);
                            var3 = (var2 = var2.parent) == null ? null : var2.parent;
                        }

                        if (var2 != null) {
                            var2.red = false;
                            if (var3 != null) {
                                var3.red = true;
                                var0 = rotateRight(var0, var3);
                            }
                        }
                    }
                } else if (var4 != null && var4.red) {
                    var4.red = false;
                    var2.red = false;
                    var3.red = true;
                    var1 = var3;
                } else {
                    if (var1 == var2.left) {
                        var1 = var2;
                        var0 = rotateRight(var0, var2);
                        var3 = (var2 = var2.parent) == null ? null : var2.parent;
                    }

                    if (var2 != null) {
                        var2.red = false;
                        if (var3 != null) {
                            var3.red = true;
                            var0 = rotateLeft(var0, var3);
                        }
                    }
                }
            }

            return var0;
        }

        static <K, V> HashMap.TreeNode<K, V> balanceDeletion(HashMap.TreeNode<K, V> var0, HashMap.TreeNode<K, V> var1) {
            while(var1 != null && var1 != var0) {
                HashMap.TreeNode var2 = var1.parent;
                if (var1.parent == null) {
                    var1.red = false;
                    return var1;
                }

                if (var1.red) {
                    var1.red = false;
                    return var0;
                }

                HashMap.TreeNode var3 = var2.left;
                HashMap.TreeNode var5;
                HashMap.TreeNode var6;
                if (var2.left == var1) {
                    HashMap.TreeNode var4 = var2.right;
                    if (var2.right != null && var4.red) {
                        var4.red = false;
                        var2.red = true;
                        var0 = rotateLeft(var0, var2);
                        var2 = var1.parent;
                        var4 = var1.parent == null ? null : var2.right;
                    }

                    if (var4 == null) {
                        var1 = var2;
                    } else {
                        var5 = var4.left;
                        var6 = var4.right;
                        if (var6 != null && var6.red || var5 != null && var5.red) {
                            if (var6 == null || !var6.red) {
                                if (var5 != null) {
                                    var5.red = false;
                                }

                                var4.red = true;
                                var0 = rotateRight(var0, var4);
                                var2 = var1.parent;
                                var4 = var1.parent == null ? null : var2.right;
                            }

                            if (var4 != null) {
                                var4.red = var2 == null ? false : var2.red;
                                var6 = var4.right;
                                if (var4.right != null) {
                                    var6.red = false;
                                }
                            }

                            if (var2 != null) {
                                var2.red = false;
                                var0 = rotateLeft(var0, var2);
                            }

                            var1 = var0;
                        } else {
                            var4.red = true;
                            var1 = var2;
                        }
                    }
                } else {
                    if (var3 != null && var3.red) {
                        var3.red = false;
                        var2.red = true;
                        var0 = rotateRight(var0, var2);
                        var2 = var1.parent;
                        var3 = var1.parent == null ? null : var2.left;
                    }

                    if (var3 == null) {
                        var1 = var2;
                    } else {
                        var5 = var3.left;
                        var6 = var3.right;
                        if ((var5 == null || !var5.red) && (var6 == null || !var6.red)) {
                            var3.red = true;
                            var1 = var2;
                        } else {
                            if (var5 == null || !var5.red) {
                                if (var6 != null) {
                                    var6.red = false;
                                }

                                var3.red = true;
                                var0 = rotateLeft(var0, var3);
                                var2 = var1.parent;
                                var3 = var1.parent == null ? null : var2.left;
                            }

                            if (var3 != null) {
                                var3.red = var2 == null ? false : var2.red;
                                var5 = var3.left;
                                if (var3.left != null) {
                                    var5.red = false;
                                }
                            }

                            if (var2 != null) {
                                var2.red = false;
                                var0 = rotateRight(var0, var2);
                            }

                            var1 = var0;
                        }
                    }
                }
            }

            return var0;
        }

        static <K, V> boolean checkInvariants(HashMap.TreeNode<K, V> var0) {
            HashMap.TreeNode var1 = var0.parent;
            HashMap.TreeNode var2 = var0.left;
            HashMap.TreeNode var3 = var0.right;
            HashMap.TreeNode var4 = var0.prev;
            HashMap.TreeNode var5 = (HashMap.TreeNode)var0.next;
            if (var4 != null && var4.next != var0) {
                return false;
            } else if (var5 != null && var5.prev != var0) {
                return false;
            } else if (var1 != null && var0 != var1.left && var0 != var1.right) {
                return false;
            } else if (var2 != null && (var2.parent != var0 || var2.hash > var0.hash)) {
                return false;
            } else if (var3 == null || var3.parent == var0 && var3.hash >= var0.hash) {
                if (var0.red && var2 != null && var2.red && var3 != null && var3.red) {
                    return false;
                } else if (var2 != null && !checkInvariants(var2)) {
                    return false;
                } else {
                    return var3 == null || checkInvariants(var3);
                }
            } else {
                return false;
            }
        }
    }

    final class ValueIterator extends HashMap<K, V>.HashIterator implements Iterator<V> {
        ValueIterator() {
            super();
        }

        public final V next() {
            return this.nextNode().value;
        }
    }

    static final class ValueSpliterator<K, V> extends HashMap.HashMapSpliterator<K, V> implements Spliterator<V> {
        ValueSpliterator(HashMap<K, V> var1, int var2, int var3, int var4, int var5) {
            super(var1, var2, var3, var4, var5);
        }

        public HashMap.ValueSpliterator<K, V> trySplit() {
            int var1 = this.getFence();
            int var2 = this.index;
            int var3 = var2 + var1 >>> 1;
            return var2 < var3 && this.current == null ? new HashMap.ValueSpliterator(this.map, var2, this.index = var3, this.est >>>= 1, this.expectedModCount) : null;
        }

        public void forEachRemaining(Consumer<? super V> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap var5 = this.map;
                HashMap.Node[] var6 = var5.table;
                int var3 = this.fence;
                int var4;
                if (this.fence < 0) {
                    var4 = this.expectedModCount = var5.modCount;
                    var3 = this.fence = var6 == null ? 0 : var6.length;
                } else {
                    var4 = this.expectedModCount;
                }

                if (var6 != null && var6.length >= var3) {
                    int var2 = this.index;
                    if (this.index >= 0 && (var2 < (this.index = var3) || this.current != null)) {
                        HashMap.Node var7 = this.current;
                        this.current = null;

                        do {
                            do {
                                if (var7 == null) {
                                    var7 = var6[var2++];
                                } else {
                                    var1.accept(var7.value);
                                    var7 = var7.next;
                                }
                            } while(var7 != null);
                        } while(var2 < var3);

                        if (var5.modCount != var4) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }

        public boolean tryAdvance(Consumer<? super V> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                HashMap.Node[] var3 = this.map.table;
                int var2;
                if (var3 != null && var3.length >= (var2 = this.getFence()) && this.index >= 0) {
                    while(this.current != null || this.index < var2) {
                        if (this.current != null) {
                            Object var4 = this.current.value;
                            this.current = this.current.next;
                            var1.accept(var4);
                            if (this.map.modCount != this.expectedModCount) {
                                throw new ConcurrentModificationException();
                            }

                            return true;
                        }

                        this.current = var3[this.index++];
                    }
                }

                return false;
            }
        }

        public int characteristics() {
            return this.fence >= 0 && this.est != this.map.size ? 0 : 64;
        }
    }

    final class Values extends AbstractCollection<V> {
        Values() {
        }

        public final int size() {
            return HashMap.this.size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<V> iterator() {
            return HashMap.this.new ValueIterator();
        }

        public final boolean contains(Object var1) {
            return HashMap.this.containsValue(var1);
        }

        public final Spliterator<V> spliterator() {
            return new HashMap.ValueSpliterator(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super V> var1) {
            if (var1 == null) {
                throw new NullPointerException();
            } else {
                if (HashMap.this.size > 0) {
                    HashMap.Node[] var2 = HashMap.this.table;
                    if (HashMap.this.table != null) {
                        int var3 = HashMap.this.modCount;

                        for(int var4 = 0; var4 < var2.length; ++var4) {
                            for(HashMap.Node var5 = var2[var4]; var5 != null; var5 = var5.next) {
                                var1.accept(var5.value);
                            }
                        }

                        if (HashMap.this.modCount != var3) {
                            throw new ConcurrentModificationException();
                        }
                    }
                }

            }
        }
    }
}