import com.google.common.base.Preconditions;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import javax.annotation.Nullable;

public class mu$i
  extends AbstractCollection<V>
{
  final K b;
  Collection<V> c;
  final mu<K, V>.i d;
  final Collection<V> e;
  
  mu$i(K paramK, @Nullable Collection<V> paramCollection, mu<K, V>.i parammu)
  {
    this.b = paramCollection;
    this.c = parammu;
    i locali;
    this.d = locali;
    if (locali == null) {}
    for (paramK = null;; paramK = locali.c)
    {
      this.e = paramK;
      return;
    }
  }
  
  final void a()
  {
    if (this.d != null)
    {
      this.d.a();
      if (this.d.c != this.e) {
        throw new ConcurrentModificationException();
      }
    }
    else if (this.c.isEmpty())
    {
      Collection localCollection = (Collection)mu.a(this.f).get(this.b);
      if (localCollection != null) {
        this.c = localCollection;
      }
    }
  }
  
  public boolean add(V paramV)
  {
    a();
    boolean bool1 = this.c.isEmpty();
    boolean bool2 = this.c.add(paramV);
    if (bool2)
    {
      mu.c(this.f);
      if (bool1) {
        c();
      }
    }
    return bool2;
  }
  
  public boolean addAll(Collection<? extends V> paramCollection)
  {
    boolean bool1;
    if (paramCollection.isEmpty()) {
      bool1 = false;
    }
    int i;
    boolean bool2;
    do
    {
      do
      {
        return bool1;
        i = size();
        bool2 = this.c.addAll(paramCollection);
        bool1 = bool2;
      } while (!bool2);
      int j = this.c.size();
      mu.a(this.f, j - i);
      bool1 = bool2;
    } while (i != 0);
    c();
    return bool2;
  }
  
  final void b()
  {
    for (i locali = this; locali.d != null; locali = locali.d) {}
    if (locali.c.isEmpty()) {
      mu.a(locali.f).remove(locali.b);
    }
  }
  
  final void c()
  {
    for (i locali = this; locali.d != null; locali = locali.d) {}
    mu.a(locali.f).put(locali.b, locali.c);
  }
  
  public void clear()
  {
    int i = size();
    if (i == 0) {
      return;
    }
    this.c.clear();
    mu.b(this.f, i);
    b();
  }
  
  public boolean contains(Object paramObject)
  {
    a();
    return this.c.contains(paramObject);
  }
  
  public boolean containsAll(Collection<?> paramCollection)
  {
    a();
    return this.c.containsAll(paramCollection);
  }
  
  public boolean equals(@Nullable Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    a();
    return this.c.equals(paramObject);
  }
  
  public int hashCode()
  {
    a();
    return this.c.hashCode();
  }
  
  public Iterator<V> iterator()
  {
    a();
    return new mu.i.a();
  }
  
  public boolean remove(Object paramObject)
  {
    a();
    boolean bool = this.c.remove(paramObject);
    if (bool)
    {
      mu.b(this.f);
      b();
    }
    return bool;
  }
  
  public boolean removeAll(Collection<?> paramCollection)
  {
    boolean bool1;
    if (paramCollection.isEmpty()) {
      bool1 = false;
    }
    int i;
    boolean bool2;
    do
    {
      return bool1;
      i = size();
      bool2 = this.c.removeAll(paramCollection);
      bool1 = bool2;
    } while (!bool2);
    int j = this.c.size();
    mu.a(this.f, j - i);
    b();
    return bool2;
  }
  
  public boolean retainAll(Collection<?> paramCollection)
  {
    Preconditions.checkNotNull(paramCollection);
    int i = size();
    boolean bool = this.c.retainAll(paramCollection);
    if (bool)
    {
      int j = this.c.size();
      mu.a(this.f, j - i);
      b();
    }
    return bool;
  }
  
  public int size()
  {
    a();
    return this.c.size();
  }
  
  public String toString()
  {
    a();
    return this.c.toString();
  }
  
  class a
    implements Iterator<V>
  {
    final Iterator<V> a;
    final Collection<V> b = mu.i.this.c;
    
    a()
    {
      this.a = mu.b(mu.i.this.c);
    }
    
    a()
    {
      Iterator localIterator;
      this.a = localIterator;
    }
    
    final void a()
    {
      mu.i.this.a();
      if (mu.i.this.c != this.b) {
        throw new ConcurrentModificationException();
      }
    }
    
    public boolean hasNext()
    {
      a();
      return this.a.hasNext();
    }
    
    public V next()
    {
      a();
      return (V)this.a.next();
    }
    
    public void remove()
    {
      this.a.remove();
      mu.b(mu.i.this.f);
      mu.i.this.b();
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/mu$i.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */