package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.AbstractSequentialList;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;
import mw;
import mx;
import qh;

@GwtCompatible(emulated=true, serializable=true)
public class LinkedListMultimap<K, V>
  extends mx<K, V>
  implements ListMultimap<K, V>, Serializable
{
  @GwtIncompatible("java serialization not supported")
  private static final long serialVersionUID = 0L;
  private transient c<K, V> a;
  private transient c<K, V> b;
  private transient Map<K, b<K, V>> c;
  private transient int d;
  private transient int e;
  
  LinkedListMultimap()
  {
    this.c = Maps.newHashMap();
  }
  
  private LinkedListMultimap(int paramInt)
  {
    this.c = new HashMap(paramInt);
  }
  
  private LinkedListMultimap(Multimap<? extends K, ? extends V> paramMultimap)
  {
    this(paramMultimap.keySet().size());
    putAll(paramMultimap);
  }
  
  private c<K, V> a(@Nullable K paramK, @Nullable V paramV, @Nullable c<K, V> paramc)
  {
    paramV = new c(paramK, paramV);
    if (this.a == null)
    {
      this.b = paramV;
      this.a = paramV;
      this.c.put(paramK, new b(paramV));
      this.e += 1;
    }
    for (;;)
    {
      this.d += 1;
      return paramV;
      if (paramc != null) {
        break;
      }
      this.b.c = paramV;
      paramV.d = this.b;
      this.b = paramV;
      paramc = (b)this.c.get(paramK);
      if (paramc == null)
      {
        this.c.put(paramK, new b(paramV));
        this.e += 1;
      }
      else
      {
        paramc.c += 1;
        paramK = paramc.b;
        paramK.e = paramV;
        paramV.f = paramK;
        paramc.b = paramV;
      }
    }
    b localb = (b)this.c.get(paramK);
    localb.c += 1;
    paramV.d = paramc.d;
    paramV.f = paramc.f;
    paramV.c = paramc;
    paramV.e = paramc;
    if (paramc.f == null)
    {
      ((b)this.c.get(paramK)).a = paramV;
      label253:
      if (paramc.d != null) {
        break label289;
      }
      this.a = paramV;
    }
    for (;;)
    {
      paramc.d = paramV;
      paramc.f = paramV;
      break;
      paramc.f.e = paramV;
      break label253;
      label289:
      paramc.d.c = paramV;
    }
  }
  
  private void b(@Nullable Object paramObject)
  {
    Iterators.b(new e(paramObject));
  }
  
  private List<V> c(@Nullable Object paramObject)
  {
    return Collections.unmodifiableList(Lists.newArrayList(new e(paramObject)));
  }
  
  public static <K, V> LinkedListMultimap<K, V> create()
  {
    return new LinkedListMultimap();
  }
  
  public static <K, V> LinkedListMultimap<K, V> create(int paramInt)
  {
    return new LinkedListMultimap(paramInt);
  }
  
  public static <K, V> LinkedListMultimap<K, V> create(Multimap<? extends K, ? extends V> paramMultimap)
  {
    return new LinkedListMultimap(paramMultimap);
  }
  
  @GwtIncompatible("java.io.ObjectInputStream")
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    this.c = Maps.newLinkedHashMap();
    int j = paramObjectInputStream.readInt();
    int i = 0;
    while (i < j)
    {
      put(paramObjectInputStream.readObject(), paramObjectInputStream.readObject());
      i += 1;
    }
  }
  
  @GwtIncompatible("java.io.ObjectOutputStream")
  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.defaultWriteObject();
    paramObjectOutputStream.writeInt(size());
    Iterator localIterator = entries().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      paramObjectOutputStream.writeObject(localEntry.getKey());
      paramObjectOutputStream.writeObject(localEntry.getValue());
    }
  }
  
  public void clear()
  {
    this.a = null;
    this.b = null;
    this.c.clear();
    this.d = 0;
    this.e += 1;
  }
  
  public boolean containsKey(@Nullable Object paramObject)
  {
    return this.c.containsKey(paramObject);
  }
  
  public boolean containsValue(@Nullable Object paramObject)
  {
    return values().contains(paramObject);
  }
  
  final Set<K> e()
  {
    new Sets.f()
    {
      public final boolean contains(Object paramAnonymousObject)
      {
        return LinkedListMultimap.this.containsKey(paramAnonymousObject);
      }
      
      public final Iterator<K> iterator()
      {
        return new LinkedListMultimap.a(LinkedListMultimap.this, (byte)0);
      }
      
      public final boolean remove(Object paramAnonymousObject)
      {
        return !LinkedListMultimap.this.removeAll(paramAnonymousObject).isEmpty();
      }
      
      public final int size()
      {
        return LinkedListMultimap.d(LinkedListMultimap.this).size();
      }
    };
  }
  
  public List<Map.Entry<K, V>> entries()
  {
    return (List)super.entries();
  }
  
  final Iterator<Map.Entry<K, V>> g()
  {
    throw new AssertionError("should never be called");
  }
  
  public List<V> get(@Nullable final K paramK)
  {
    new AbstractSequentialList()
    {
      public final ListIterator<V> listIterator(int paramAnonymousInt)
      {
        return new LinkedListMultimap.e(LinkedListMultimap.this, paramK, paramAnonymousInt);
      }
      
      public final int size()
      {
        LinkedListMultimap.b localb = (LinkedListMultimap.b)LinkedListMultimap.d(LinkedListMultimap.this).get(paramK);
        if (localb == null) {
          return 0;
        }
        return localb.c;
      }
    };
  }
  
  final Map<K, Collection<V>> h()
  {
    return new Multimaps.a(this);
  }
  
  public boolean isEmpty()
  {
    return this.a == null;
  }
  
  public boolean put(@Nullable K paramK, @Nullable V paramV)
  {
    a(paramK, paramV, null);
    return true;
  }
  
  public List<V> removeAll(@Nullable Object paramObject)
  {
    List localList = c(paramObject);
    b(paramObject);
    return localList;
  }
  
  public List<V> replaceValues(@Nullable K paramK, Iterable<? extends V> paramIterable)
  {
    List localList = c(paramK);
    paramK = new e(paramK);
    paramIterable = paramIterable.iterator();
    while ((paramK.hasNext()) && (paramIterable.hasNext()))
    {
      paramK.next();
      paramK.set(paramIterable.next());
    }
    while (paramK.hasNext())
    {
      paramK.next();
      paramK.remove();
    }
    while (paramIterable.hasNext()) {
      paramK.add(paramIterable.next());
    }
    return localList;
  }
  
  public int size()
  {
    return this.d;
  }
  
  public List<V> values()
  {
    return (List)super.values();
  }
  
  final class a
    implements Iterator<K>
  {
    final Set<K> a = Sets.newHashSetWithExpectedSize(LinkedListMultimap.this.keySet().size());
    LinkedListMultimap.c<K, V> b = LinkedListMultimap.c(LinkedListMultimap.this);
    LinkedListMultimap.c<K, V> c;
    int d = LinkedListMultimap.a(LinkedListMultimap.this);
    
    private a() {}
    
    private void a()
    {
      if (LinkedListMultimap.a(LinkedListMultimap.this) != this.d) {
        throw new ConcurrentModificationException();
      }
    }
    
    public final boolean hasNext()
    {
      a();
      return this.b != null;
    }
    
    public final K next()
    {
      a();
      LinkedListMultimap.a(this.b);
      this.c = this.b;
      this.a.add(this.c.a);
      do
      {
        this.b = this.b.c;
      } while ((this.b != null) && (!this.a.add(this.b.a)));
      return (K)this.c.a;
    }
    
    public final void remove()
    {
      a();
      if (this.c != null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
        LinkedListMultimap.a(LinkedListMultimap.this, this.c.a);
        this.c = null;
        this.d = LinkedListMultimap.a(LinkedListMultimap.this);
        return;
      }
    }
  }
  
  static final class b<K, V>
  {
    LinkedListMultimap.c<K, V> a;
    LinkedListMultimap.c<K, V> b;
    int c;
    
    b(LinkedListMultimap.c<K, V> paramc)
    {
      this.a = paramc;
      this.b = paramc;
      paramc.f = null;
      paramc.e = null;
      this.c = 1;
    }
  }
  
  static final class c<K, V>
    extends mw<K, V>
  {
    final K a;
    V b;
    c<K, V> c;
    c<K, V> d;
    c<K, V> e;
    c<K, V> f;
    
    c(@Nullable K paramK, @Nullable V paramV)
    {
      this.a = paramK;
      this.b = paramV;
    }
    
    public final K getKey()
    {
      return (K)this.a;
    }
    
    public final V getValue()
    {
      return (V)this.b;
    }
    
    public final V setValue(@Nullable V paramV)
    {
      Object localObject = this.b;
      this.b = paramV;
      return (V)localObject;
    }
  }
  
  final class d
    implements ListIterator<Map.Entry<K, V>>
  {
    int a;
    LinkedListMultimap.c<K, V> b;
    LinkedListMultimap.c<K, V> c;
    LinkedListMultimap.c<K, V> d;
    int e = LinkedListMultimap.a(LinkedListMultimap.this);
    
    d(int paramInt)
    {
      int i = LinkedListMultimap.this.size();
      Preconditions.checkPositionIndex(paramInt, i);
      if (paramInt >= i / 2)
      {
        this.d = LinkedListMultimap.b(LinkedListMultimap.this);
        this.a = i;
        while (paramInt < i)
        {
          c();
          paramInt += 1;
        }
      }
      this.b = LinkedListMultimap.c(LinkedListMultimap.this);
      while (paramInt > 0)
      {
        b();
        paramInt -= 1;
      }
      this.c = null;
    }
    
    private void a()
    {
      if (LinkedListMultimap.a(LinkedListMultimap.this) != this.e) {
        throw new ConcurrentModificationException();
      }
    }
    
    private LinkedListMultimap.c<K, V> b()
    {
      a();
      LinkedListMultimap.a(this.b);
      LinkedListMultimap.c localc = this.b;
      this.c = localc;
      this.d = localc;
      this.b = this.b.c;
      this.a += 1;
      return this.c;
    }
    
    private LinkedListMultimap.c<K, V> c()
    {
      a();
      LinkedListMultimap.a(this.d);
      LinkedListMultimap.c localc = this.d;
      this.c = localc;
      this.b = localc;
      this.d = this.d.d;
      this.a -= 1;
      return this.c;
    }
    
    public final boolean hasNext()
    {
      a();
      return this.b != null;
    }
    
    public final boolean hasPrevious()
    {
      a();
      return this.d != null;
    }
    
    public final int nextIndex()
    {
      return this.a;
    }
    
    public final int previousIndex()
    {
      return this.a - 1;
    }
    
    public final void remove()
    {
      a();
      boolean bool;
      if (this.c != null)
      {
        bool = true;
        Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
        if (this.c == this.b) {
          break label84;
        }
        this.d = this.c.d;
        this.a -= 1;
      }
      for (;;)
      {
        LinkedListMultimap.a(LinkedListMultimap.this, this.c);
        this.c = null;
        this.e = LinkedListMultimap.a(LinkedListMultimap.this);
        return;
        bool = false;
        break;
        label84:
        this.b = this.c.c;
      }
    }
  }
  
  final class e
    implements ListIterator<V>
  {
    final Object a;
    int b;
    LinkedListMultimap.c<K, V> c;
    LinkedListMultimap.c<K, V> d;
    LinkedListMultimap.c<K, V> e;
    
    e(@Nullable Object paramObject)
    {
      this.a = paramObject;
      this$1 = (LinkedListMultimap.b)LinkedListMultimap.d(LinkedListMultimap.this).get(paramObject);
      if (LinkedListMultimap.this == null) {}
      for (this$1 = null;; this$1 = LinkedListMultimap.this.a)
      {
        this.c = LinkedListMultimap.this;
        return;
      }
    }
    
    public e(@Nullable Object paramObject, int paramInt)
    {
      this$1 = (LinkedListMultimap.b)LinkedListMultimap.d(LinkedListMultimap.this).get(paramObject);
      int i;
      if (LinkedListMultimap.this == null)
      {
        i = 0;
        Preconditions.checkPositionIndex(paramInt, i);
        if (paramInt < i / 2) {
          break label97;
        }
        if (LinkedListMultimap.this != null) {
          break label89;
        }
      }
      label89:
      for (this$1 = null;; this$1 = LinkedListMultimap.this.b)
      {
        this.e = LinkedListMultimap.this;
        this.b = i;
        while (paramInt < i)
        {
          previous();
          paramInt += 1;
        }
        i = LinkedListMultimap.this.c;
        break;
      }
      label97:
      if (LinkedListMultimap.this == null) {}
      for (this$1 = null;; this$1 = LinkedListMultimap.this.a)
      {
        this.c = LinkedListMultimap.this;
        while (paramInt > 0)
        {
          next();
          paramInt -= 1;
        }
      }
      this.a = paramObject;
      this.d = null;
    }
    
    public final void add(V paramV)
    {
      this.e = LinkedListMultimap.a(LinkedListMultimap.this, this.a, paramV, this.c);
      this.b += 1;
      this.d = null;
    }
    
    public final boolean hasNext()
    {
      return this.c != null;
    }
    
    public final boolean hasPrevious()
    {
      return this.e != null;
    }
    
    public final V next()
    {
      LinkedListMultimap.a(this.c);
      LinkedListMultimap.c localc = this.c;
      this.d = localc;
      this.e = localc;
      this.c = this.c.e;
      this.b += 1;
      return (V)this.d.b;
    }
    
    public final int nextIndex()
    {
      return this.b;
    }
    
    public final V previous()
    {
      LinkedListMultimap.a(this.e);
      LinkedListMultimap.c localc = this.e;
      this.d = localc;
      this.c = localc;
      this.e = this.e.f;
      this.b -= 1;
      return (V)this.d.b;
    }
    
    public final int previousIndex()
    {
      return this.b - 1;
    }
    
    public final void remove()
    {
      boolean bool;
      if (this.d != null)
      {
        bool = true;
        Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
        if (this.d == this.c) {
          break label69;
        }
        this.e = this.d.f;
        this.b -= 1;
      }
      for (;;)
      {
        LinkedListMultimap.a(LinkedListMultimap.this, this.d);
        this.d = null;
        return;
        bool = false;
        break;
        label69:
        this.c = this.d.e;
      }
    }
    
    public final void set(V paramV)
    {
      if (this.d != null) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkState(bool);
        this.d.b = paramV;
        return;
      }
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/collect/LinkedListMultimap.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */