/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.util;

import dalvik.annotation.compat.UnsupportedAppUsage;

@SuppressWarnings({"unchecked", "deprecation", "all"})
public class HashMap<K, V> extends java.util.AbstractMap<K, V>
        implements java.util.Map<K, V>, java.lang.Cloneable, java.io.Serializable {

    public HashMap(int initialCapacity, float loadFactor) {
        throw new RuntimeException("Stub!");
    }

    public HashMap(int initialCapacity) {
        throw new RuntimeException("Stub!");
    }

    public HashMap() {
        throw new RuntimeException("Stub!");
    }

    public HashMap(java.util.Map<? extends K, ? extends V> m) {
        throw new RuntimeException("Stub!");
    }

    static final int hash(java.lang.Object key) {
        throw new RuntimeException("Stub!");
    }

    static java.lang.Class<?> comparableClassFor(java.lang.Object x) {
        throw new RuntimeException("Stub!");
    }

    static int compareComparables(java.lang.Class<?> kc, java.lang.Object k, java.lang.Object x) {
        throw new RuntimeException("Stub!");
    }

    static final int tableSizeFor(int cap) {
        throw new RuntimeException("Stub!");
    }

    final void putMapEntries(java.util.Map<? extends K, ? extends V> m, boolean evict) {
        throw new RuntimeException("Stub!");
    }

    public int size() {
        throw new RuntimeException("Stub!");
    }

    public boolean isEmpty() {
        throw new RuntimeException("Stub!");
    }

    public V get(java.lang.Object key) {
        throw new RuntimeException("Stub!");
    }

    final java.util.HashMap.Node<K, V> getNode(int hash, java.lang.Object key) {
        throw new RuntimeException("Stub!");
    }

    public boolean containsKey(java.lang.Object key) {
        throw new RuntimeException("Stub!");
    }

    public V put(K key, V value) {
        throw new RuntimeException("Stub!");
    }

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        throw new RuntimeException("Stub!");
    }

    final java.util.HashMap.Node<K, V>[] resize() {
        throw new RuntimeException("Stub!");
    }

    final void treeifyBin(java.util.HashMap.Node<K, V>[] tab, int hash) {
        throw new RuntimeException("Stub!");
    }

    public void putAll(java.util.Map<? extends K, ? extends V> m) {
        throw new RuntimeException("Stub!");
    }

    public V remove(java.lang.Object key) {
        throw new RuntimeException("Stub!");
    }

    final java.util.HashMap.Node<K, V> removeNode(
            int hash,
            java.lang.Object key,
            java.lang.Object value,
            boolean matchValue,
            boolean movable) {
        throw new RuntimeException("Stub!");
    }

    public void clear() {
        throw new RuntimeException("Stub!");
    }

    public boolean containsValue(java.lang.Object value) {
        throw new RuntimeException("Stub!");
    }

    public java.util.Set<K> keySet() {
        throw new RuntimeException("Stub!");
    }

    public java.util.Collection<V> values() {
        throw new RuntimeException("Stub!");
    }

    public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
        throw new RuntimeException("Stub!");
    }

    public V getOrDefault(java.lang.Object key, V defaultValue) {
        throw new RuntimeException("Stub!");
    }

    public V putIfAbsent(K key, V value) {
        throw new RuntimeException("Stub!");
    }

    public boolean remove(java.lang.Object key, java.lang.Object value) {
        throw new RuntimeException("Stub!");
    }

    public boolean replace(K key, V oldValue, V newValue) {
        throw new RuntimeException("Stub!");
    }

    public V replace(K key, V value) {
        throw new RuntimeException("Stub!");
    }

    public V computeIfAbsent(
            K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
        throw new RuntimeException("Stub!");
    }

    public V computeIfPresent(
            K key,
            java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        throw new RuntimeException("Stub!");
    }

    public V compute(
            K key,
            java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        throw new RuntimeException("Stub!");
    }

    public V merge(
            K key,
            V value,
            java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        throw new RuntimeException("Stub!");
    }

    public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
        throw new RuntimeException("Stub!");
    }

    public void replaceAll(
            java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
        throw new RuntimeException("Stub!");
    }

    public java.lang.Object clone() {
        throw new RuntimeException("Stub!");
    }

    final float loadFactor() {
        throw new RuntimeException("Stub!");
    }

    final int capacity() {
        throw new RuntimeException("Stub!");
    }

    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
        throw new RuntimeException("Stub!");
    }

    private void readObject(java.io.ObjectInputStream s)
            throws java.lang.ClassNotFoundException, java.io.IOException {
        throw new RuntimeException("Stub!");
    }

    java.util.HashMap.Node<K, V> newNode(
            int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
        throw new RuntimeException("Stub!");
    }

    java.util.HashMap.Node<K, V> replacementNode(
            java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
        throw new RuntimeException("Stub!");
    }

    java.util.HashMap.TreeNode<K, V> newTreeNode(
            int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
        throw new RuntimeException("Stub!");
    }

    java.util.HashMap.TreeNode<K, V> replacementTreeNode(
            java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
        throw new RuntimeException("Stub!");
    }

    void reinitialize() {
        throw new RuntimeException("Stub!");
    }

    void afterNodeAccess(java.util.HashMap.Node<K, V> p) {
        throw new RuntimeException("Stub!");
    }

    void afterNodeInsertion(boolean evict) {
        throw new RuntimeException("Stub!");
    }

    void afterNodeRemoval(java.util.HashMap.Node<K, V> p) {
        throw new RuntimeException("Stub!");
    }

    void internalWriteEntries(java.io.ObjectOutputStream s) throws java.io.IOException {
        throw new RuntimeException("Stub!");
    }

    static final int DEFAULT_INITIAL_CAPACITY = 16; // 0x10

    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    static final int MAXIMUM_CAPACITY = 1073741824; // 0x40000000

    static final int MIN_TREEIFY_CAPACITY = 64; // 0x40

    static final int TREEIFY_THRESHOLD = 8; // 0x8

    static final int UNTREEIFY_THRESHOLD = 6; // 0x6

    transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;

    final float loadFactor;

    {
        loadFactor = 0;
    }

    @UnsupportedAppUsage
    transient int modCount;

    private static final long serialVersionUID = 362498820763181265L; // 0x507dac1c31660d1L

    transient int size;

    @UnsupportedAppUsage
    transient java.util.HashMap.Node<K, V>[] table;

    int threshold;

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class EntryIterator extends java.util.HashMap.HashIterator
            implements java.util.Iterator<java.util.Map.Entry<K, V>> {

        @UnsupportedAppUsage(trackingBug = 122551864)
        public java.util.Map.Entry<K, V> next() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class EntrySet extends java.util.AbstractSet<java.util.Map.Entry<K, V>> {

        EntrySet() {
            throw new RuntimeException("Stub!");
        }

        public int size() {
            throw new RuntimeException("Stub!");
        }

        public void clear() {
            throw new RuntimeException("Stub!");
        }

        public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
            throw new RuntimeException("Stub!");
        }

        public boolean contains(java.lang.Object o) {
            throw new RuntimeException("Stub!");
        }

        public boolean remove(java.lang.Object o) {
            throw new RuntimeException("Stub!");
        }

        public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
            throw new RuntimeException("Stub!");
        }

        public void forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static final class EntrySpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
            implements java.util.Spliterator<java.util.Map.Entry<K, V>> {

        EntrySpliterator(
                java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
            super(null, 0, 0, 0, 0);
            throw new RuntimeException("Stub!");
        }

        public java.util.HashMap.EntrySpliterator<K, V> trySplit() {
            throw new RuntimeException("Stub!");
        }

        public void forEachRemaining(
                java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
            throw new RuntimeException("Stub!");
        }

        public boolean tryAdvance(
                java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
            throw new RuntimeException("Stub!");
        }

        public int characteristics() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    abstract class HashIterator {

        HashIterator() {
            throw new RuntimeException("Stub!");
        }

        public final boolean hasNext() {
            throw new RuntimeException("Stub!");
        }

        final java.util.HashMap.Node<K, V> nextNode() {
            throw new RuntimeException("Stub!");
        }

        public final void remove() {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.Node<K, V> current;

        int expectedModCount;

        int index;

        java.util.HashMap.Node<K, V> next;
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static class HashMapSpliterator<K, V> {

        HashMapSpliterator(
                java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
            throw new RuntimeException("Stub!");
        }

        final int getFence() {
            throw new RuntimeException("Stub!");
        }

        public final long estimateSize() {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.Node<K, V> current;

        int est;

        int expectedModCount;

        int fence;

        int index;

        final java.util.HashMap<K, V> map;

        {
            map = null;
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class KeyIterator extends java.util.HashMap.HashIterator
            implements java.util.Iterator<K> {

        public K next() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class KeySet extends java.util.AbstractSet<K> {

        KeySet() {
            throw new RuntimeException("Stub!");
        }

        public int size() {
            throw new RuntimeException("Stub!");
        }

        public void clear() {
            throw new RuntimeException("Stub!");
        }

        public java.util.Iterator<K> iterator() {
            throw new RuntimeException("Stub!");
        }

        public boolean contains(java.lang.Object o) {
            throw new RuntimeException("Stub!");
        }

        public boolean remove(java.lang.Object key) {
            throw new RuntimeException("Stub!");
        }

        public java.util.Spliterator<K> spliterator() {
            throw new RuntimeException("Stub!");
        }

        public void forEach(java.util.function.Consumer<? super K> action) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static final class KeySpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
            implements java.util.Spliterator<K> {

        KeySpliterator(
                java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
            super(null, 0, 0, 0, 0);
            throw new RuntimeException("Stub!");
        }

        public java.util.HashMap.KeySpliterator<K, V> trySplit() {
            throw new RuntimeException("Stub!");
        }

        public void forEachRemaining(java.util.function.Consumer<? super K> action) {
            throw new RuntimeException("Stub!");
        }

        public boolean tryAdvance(java.util.function.Consumer<? super K> action) {
            throw new RuntimeException("Stub!");
        }

        public int characteristics() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static class Node<K, V> implements java.util.Map.Entry<K, V> {

        Node(int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
            throw new RuntimeException("Stub!");
        }

        public final K getKey() {
            throw new RuntimeException("Stub!");
        }

        public final V getValue() {
            throw new RuntimeException("Stub!");
        }

        public final java.lang.String toString() {
            throw new RuntimeException("Stub!");
        }

        public final int hashCode() {
            throw new RuntimeException("Stub!");
        }

        public final V setValue(V newValue) {
            throw new RuntimeException("Stub!");
        }

        public final boolean equals(java.lang.Object o) {
            throw new RuntimeException("Stub!");
        }

        final int hash;

        {
            hash = 0;
        }

        @UnsupportedAppUsage
        final K key;

        {
            key = null;
        }

        @UnsupportedAppUsage
        java.util.HashMap.Node<K, V> next;

        @UnsupportedAppUsage
        V value;
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static final class TreeNode<K, V> extends java.util.LinkedHashMap.LinkedHashMapEntry<K, V> {

        TreeNode(int hash, K key, V val, java.util.HashMap.Node<K, V> next) {
            super(0, null, null, null);
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.TreeNode<K, V> root() {
            throw new RuntimeException("Stub!");
        }

        static <K, V> void moveRootToFront(
                java.util.HashMap.Node<K, V>[] tab, java.util.HashMap.TreeNode<K, V> root) {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.TreeNode<K, V> find(int h, java.lang.Object k, java.lang.Class<?> kc) {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.TreeNode<K, V> getTreeNode(int h, java.lang.Object k) {
            throw new RuntimeException("Stub!");
        }

        static int tieBreakOrder(java.lang.Object a, java.lang.Object b) {
            throw new RuntimeException("Stub!");
        }

        void treeify(java.util.HashMap.Node<K, V>[] tab) {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.Node<K, V> untreeify(java.util.HashMap<K, V> map) {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.TreeNode<K, V> putTreeVal(
                java.util.HashMap<K, V> map, java.util.HashMap.Node<K, V>[] tab, int h, K k, V v) {
            throw new RuntimeException("Stub!");
        }

        void removeTreeNode(
                java.util.HashMap<K, V> map, java.util.HashMap.Node<K, V>[] tab, boolean movable) {
            throw new RuntimeException("Stub!");
        }

        void split(
                java.util.HashMap<K, V> map,
                java.util.HashMap.Node<K, V>[] tab,
                int index,
                int bit) {
            throw new RuntimeException("Stub!");
        }

        static <K, V> java.util.HashMap.TreeNode<K, V> rotateLeft(
                java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> p) {
            throw new RuntimeException("Stub!");
        }

        static <K, V> java.util.HashMap.TreeNode<K, V> rotateRight(
                java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> p) {
            throw new RuntimeException("Stub!");
        }

        static <K, V> java.util.HashMap.TreeNode<K, V> balanceInsertion(
                java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> x) {
            throw new RuntimeException("Stub!");
        }

        static <K, V> java.util.HashMap.TreeNode<K, V> balanceDeletion(
                java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> x) {
            throw new RuntimeException("Stub!");
        }

        static <K, V> boolean checkInvariants(java.util.HashMap.TreeNode<K, V> t) {
            throw new RuntimeException("Stub!");
        }

        java.util.HashMap.TreeNode<K, V> left;

        java.util.HashMap.TreeNode<K, V> parent;

        java.util.HashMap.TreeNode<K, V> prev;

        boolean red;

        java.util.HashMap.TreeNode<K, V> right;
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class ValueIterator extends java.util.HashMap.HashIterator
            implements java.util.Iterator<V> {

        public V next() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    static final class ValueSpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
            implements java.util.Spliterator<V> {

        ValueSpliterator(
                java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
            super(null, 0, 0, 0, 0);
            throw new RuntimeException("Stub!");
        }

        public java.util.HashMap.ValueSpliterator<K, V> trySplit() {
            throw new RuntimeException("Stub!");
        }

        public void forEachRemaining(java.util.function.Consumer<? super V> action) {
            throw new RuntimeException("Stub!");
        }

        public boolean tryAdvance(java.util.function.Consumer<? super V> action) {
            throw new RuntimeException("Stub!");
        }

        public int characteristics() {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    final class Values extends java.util.AbstractCollection<V> {

        Values() {
            throw new RuntimeException("Stub!");
        }

        public int size() {
            throw new RuntimeException("Stub!");
        }

        public void clear() {
            throw new RuntimeException("Stub!");
        }

        public java.util.Iterator<V> iterator() {
            throw new RuntimeException("Stub!");
        }

        public boolean contains(java.lang.Object o) {
            throw new RuntimeException("Stub!");
        }

        public java.util.Spliterator<V> spliterator() {
            throw new RuntimeException("Stub!");
        }

        public void forEach(java.util.function.Consumer<? super V> action) {
            throw new RuntimeException("Stub!");
        }
    }
}