try {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }

public Interface Map<K,V>{
  int size();

  boolean isEmpty();

  boolean constainsKey(Object key);

  boolean containsValue(Object value);

  V get(Object key);

  V put(Object key,Object value);

  V remove(Object key);

  void putAll(Map<? extends K, ? extends V> m);

  void clear();

  Set<K> keySet();

  Collection<V> values();

  Set<Map.Entry<K,V>> entrySet();

  Interface Entry<K,V> {
    K getKey();

    V getValue();

    V setValue(V  value);

    boolean equals(Object o);

    int hashCode();

    public static <K extends Comparable<? super K> ,V> Comparator<Map.Entry<K,V> comparingByKey(){
      return (Comparator<Map.Entry<K,V>> & Serializable) (c1,c2)->c1.getKey().compareTo(c2.getKey());
    }

    public static <K,V extends Comparable <? super V>> Comparator<Map.Entry<K,V>> comparingByValue(){
      return (Comparator<Map.Entry<K,V>> & Serializable) (c1,c2) -> c1.getValue().compareTo(c2.getValue());
    }

    public static <K,V> Comparator<Map.Entry<K,V>> comparingByKey(Comparator<? super K> cmp){
      Objects.requireNonNull(cmp);
      return (Comparator<Map.Entry<K,V>> & Serializable)(c1,c2) -> cmp.compare(c1.getKey(),c2.getKey());
    }

    public static <K,V> Comparator<Map.Entry<K,V>> comparingByValue(Comparator<? super V> cmp){
      Objects.requireNonNull(cmp);
      return (Comparator<Map.Entry<K,V>> & Serializable)(c1,c2)->cmp.compare(c1.getValue(), c2.getValue());
    }
  }

  boolean equals (Object o);

  int hashCode();

  default V getOrDefault(Object key , V defaultValue){
    V v;
    return (((v = get(key)) != null) || constainsKey(key))
      ? v
      : defaultValue;
  }

  default void forEach(BiConsumer<? super K, ? super V> action){
    Objects.requireNonNull(action);
    for(Map.Entry<K,V> entry :entrySet()){
      K k;
      V v;
      try{
        k = entry.getKey();
        v = entry.getValue();
      } catch (IllegalStateException ise){
        throw new ConcurrentModificationException(ise);
      }

      action.accept(k,v);
    }
  }

  default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function){
    Objects.requireNonNull(function);
    for(Map.Entry<K,V> entry : entrySet()){
      K k;
      V v;
      try {
        k = entry.getKey();
        v = entry.getValue();
      } catch (IllegalStateException ise){
        throw new ConcurrentModificationException(ise);
      }

      v = function.apply(k,v);

      try{
        entry.setValue(v);
      } catch(IllegalStateException ise){
        throw new ConcurrentModificationException(ise);
      }
    }
  }

  default V putIfAbsent(K key, V value){
    V v = get(key);
    if( v== null){
      v = put(key,value);
    }

    return v;
  }

  default boolean remove(Object key,Object value){
    Object vurValue = get(key);
    if(!Objects.equals(curValue ,value) ||
      （curValue == null && !constainsKey(key)){
        return false;
      }
      remove(key);
      return true;
  }

  default boolean replace(K key,V oldValue, V newValue){
    Object curValue = get(key);
    if( !Objects.equals(curValue,oldValue) ||
      (curValue == null && !containsKey(key))){
        return false;
      }

      put(key,newValue);
      return true;
  }

  default V replace(K key, V value){
    V curValue;
    if(((curValue = get(key)) != null) || containsKey(key)){
      curValue = put(key,value);
    }
    return curValue
  }

  default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction){
    Objects.requireNonNull(mappingFunction);
    V v;
    if((v = get（key)) == null ){
      V newValue
      if((newValue = mappingFunction.apply(key)) != null) {
        put(key, newValue);
        return newValue;
      }
    }

    return v;
  }

  default V computeIfPresent(K key,
    BiFunction<? super K , ? super V, ? extends V> remappingFunction){
      V oldValue;
      if((oldValue = get(key)) != null){
        V newValue = remappingFunction.apply(key,oldValue);
        if(newValue != null){
          put(key,newValue);
          return newValue;
        } else {
          remove(key);
          return null;
        }
      }
    }

    default V compute(K key,BiFunction<? super K, ? super V , ? extends V> remappingFunction){
      Objects.requireNonNull(remappingFunction);

      V newValue = remappingFunction.apply(key,oldValue);
      if(newValue == null){
        if(oldValue != null || containsKey(key)){
          remove(key);
          return null;
        } else {
          return null;
        }
      } else {
        put(key,newValue);
        return newValue;
      }
    }

    default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction){
      Objects.requireNonNull(remappingFunction);
      Objects.requireNonNull(value);

      V oldValue = get(key);
      V newValue = (oldValue == null ?) value : remappingFunction.apply(oldValue,value);

      if(newValue == null){
        remove(key);
      } else {
        put(key,newValue);
      }

      return newValue;
    }
}

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>. Deque<E>, Cloneable, java.io.Serializable{

  private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> pre,E element,Node<E> next){
      this.item = element;
      this.next = next;
      this.prev = pre;
    }
  }
}

public Deque<E> extends Queue<E>{
  void addFirst();
  void addLast();
  boolean offerFirst();
  boolean offerLast();
  E removeFirst();
  E removeLast();
  E pollFirst();
  E pollLast();
  E getLast();
  E peekFirst();
  E peekLast();

  boolean removeFirstOccurence(Object o);
  boolean removeLastOccurence(Object o);

  // Queue Methods
  boolean add(E e);
  boolean offer(E e);
  E remove();
  E poll();
  E element();
  E peek();

  // Stack Methods
  void push(E e);
  E pop();


  // Collection Methods
  boolean remove(Object o);
  boolean contains(Object o);
  public int size();

  Iterator<E> iterator();

  Iterator<E> descendingIterator();

}

public abstract class AbstractSequentialList<E> extends AbstractList<E>{
  protected AbstractSequentialList{

  }

  public E get(int index){
    try{
      return listIterator(index).next();
    } catch(NuSuchElementException exc){
      throw new IndexOutOfBoundsException("index: "+index);
    }
  }

  public E set(int index, E element){
    try{
      ListIterator<E> e =listIterator(index);
      E oldVal = e.next();
      e.set(element);
      return oldVal;
    } catch(NoSuchElementException exc){
      throw new IndexOutOfBoundsException("index : "+index);
    }
  }

  public void add(int index, E element ){
    try{
      listIterator(index).add(element);
    } catch(NoSuchElementException exc){
      throw new IndexOutOfBoundsException("index: "+index);
    }
  }

  public E remove(int index){
    try{
      ListIterator<E> e = listIterator(index);
      E outCast = e.next();
      e.remove();
      return outCast;
    } catch(NoSuchElementException exc){
      throw new IndexOutOfBoundsException("index: "+index);
    }
  }

  public boolean addAll(int index, Collection<? extends E> c){
    try{
      boolean modified = false;
      ListIterator<E> e1 = listIterator(index);
      Iterator<? extends E> e2 = c.Iterator();
      while( e2.hasNext()){
        e1.add(e2.next());
        modified = true;
      }
      return modified;
    } catch(NoSuchElementException exc){
      throw new IndexOutOfBoundsException("index : "+index);
    }
  }

  public Iterator<E> iterator(){return listIterator();}

  public abstract ListIterator<E> listIterator(int index);
}

public interface Queue<E> extends Collection<E>{
  boolean add(E e);

  boolean offer(E e);

  E remove();

  E poll();

  E element();

  E peek();
}

transient Object[] elementData;

ArrayList<E> extends AbstractList<E> implements List<E> ,RandomAccess,Cloneable,java.io.Serializable{
  ...
}

public interface RandomAccess{

}

public interface Cloneable{

}

public interface Serializable {
}

private static final long serialVersionUID = 8683452581122892189L;