import com.google.common.annotations.GwtCompatible;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.AbstractIterator;
import com.google.common.collect.Collections2;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Maps.ac;
import com.google.common.collect.Maps.f;
import com.google.common.collect.Maps.m;
import com.google.common.collect.Maps.n;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps.g;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.Multisets.c;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;

@GwtCompatible
public class oe<K, V>
  extends mx<K, V>
  implements oj<K, V>
{
  final Multimap<K, V> a;
  final Predicate<? super Map.Entry<K, V>> b;
  
  public oe(Multimap<K, V> paramMultimap, Predicate<? super Map.Entry<K, V>> paramPredicate)
  {
    this.a = ((Multimap)Preconditions.checkNotNull(paramMultimap));
    this.b = ((Predicate)Preconditions.checkNotNull(paramPredicate));
  }
  
  static <E> Collection<E> a(Collection<E> paramCollection, Predicate<? super E> paramPredicate)
  {
    if ((paramCollection instanceof Set)) {
      return Sets.filter((Set)paramCollection, paramPredicate);
    }
    return Collections2.filter(paramCollection, paramPredicate);
  }
  
  public Multimap<K, V> a()
  {
    return this.a;
  }
  
  final boolean a(Predicate<? super Map.Entry<K, Collection<V>>> paramPredicate)
  {
    Iterator localIterator = this.a.asMap().entrySet().iterator();
    boolean bool = false;
    Collection localCollection;
    if (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      Object localObject = localEntry.getKey();
      localCollection = a((Collection)localEntry.getValue(), new oe.c(localObject));
      if ((localCollection.isEmpty()) || (!paramPredicate.apply(Maps.immutableEntry(localObject, localCollection)))) {
        break label150;
      }
      if (localCollection.size() == ((Collection)localEntry.getValue()).size())
      {
        localIterator.remove();
        label133:
        bool = true;
      }
    }
    label150:
    for (;;)
    {
      break;
      localCollection.clear();
      break label133;
      return bool;
    }
  }
  
  public final Predicate<? super Map.Entry<K, V>> b()
  {
    return this.b;
  }
  
  public void clear()
  {
    entries().clear();
  }
  
  public boolean containsKey(@Nullable Object paramObject)
  {
    return asMap().get(paramObject) != null;
  }
  
  final Iterator<Map.Entry<K, V>> g()
  {
    throw new AssertionError("should never be called");
  }
  
  public Collection<V> get(K paramK)
  {
    return a(this.a.get(paramK), new oe.c(paramK));
  }
  
  final Map<K, Collection<V>> h()
  {
    return new oe.a();
  }
  
  Collection<Map.Entry<K, V>> i()
  {
    return a(this.a.entries(), this.b);
  }
  
  final Multiset<K> j()
  {
    return new oe.b();
  }
  
  final Collection<V> k()
  {
    return new ok(this);
  }
  
  public Set<K> keySet()
  {
    return asMap().keySet();
  }
  
  public Collection<V> removeAll(@Nullable Object paramObject)
  {
    Object localObject = asMap().remove(paramObject);
    if ((this.a instanceof SetMultimap)) {}
    for (paramObject = Collections.emptySet();; paramObject = Collections.emptyList()) {
      return (Collection)MoreObjects.firstNonNull(localObject, paramObject);
    }
  }
  
  public int size()
  {
    return entries().size();
  }
  
  final class a
    extends Maps.m<K, Collection<V>>
  {
    a() {}
    
    private Collection<V> b(@Nullable Object paramObject)
    {
      Collection localCollection = (Collection)oe.this.a.asMap().get(paramObject);
      if (localCollection == null) {
        paramObject = null;
      }
      do
      {
        return (Collection<V>)paramObject;
        localCollection = oe.a(localCollection, new oe.c(oe.this, paramObject));
        paramObject = localCollection;
      } while (!localCollection.isEmpty());
      return null;
    }
    
    public final Collection<V> a(@Nullable Object paramObject)
    {
      Object localObject1 = (Collection)oe.this.a.asMap().get(paramObject);
      if (localObject1 == null) {
        return null;
      }
      ArrayList localArrayList = Lists.newArrayList();
      localObject1 = ((Collection)localObject1).iterator();
      while (((Iterator)localObject1).hasNext())
      {
        Object localObject2 = ((Iterator)localObject1).next();
        if (oe.a(oe.this, paramObject, localObject2))
        {
          ((Iterator)localObject1).remove();
          localArrayList.add(localObject2);
        }
      }
      if (localArrayList.isEmpty()) {
        return null;
      }
      if ((oe.this.a instanceof SetMultimap)) {
        return Collections.unmodifiableSet(Sets.newLinkedHashSet(localArrayList));
      }
      return Collections.unmodifiableList(localArrayList);
    }
    
    final Set<Map.Entry<K, Collection<V>>> a()
    {
      new Maps.f()
      {
        final Map<K, Collection<V>> a()
        {
          return oe.a.this;
        }
        
        public final Iterator<Map.Entry<K, Collection<V>>> iterator()
        {
          new AbstractIterator()
          {
            final Iterator<Map.Entry<K, Collection<V>>> a = oe.this.a.asMap().entrySet().iterator();
          };
        }
        
        public final boolean removeAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Predicates.in(paramAnonymousCollection));
        }
        
        public final boolean retainAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Predicates.not(Predicates.in(paramAnonymousCollection)));
        }
        
        public final int size()
        {
          return Iterators.size(iterator());
        }
      };
    }
    
    final Collection<Collection<V>> b_()
    {
      new Maps.ac(this)
      {
        public final boolean remove(@Nullable Object paramAnonymousObject)
        {
          if ((paramAnonymousObject instanceof Collection))
          {
            paramAnonymousObject = (Collection)paramAnonymousObject;
            Iterator localIterator = oe.this.a.asMap().entrySet().iterator();
            while (localIterator.hasNext())
            {
              Map.Entry localEntry = (Map.Entry)localIterator.next();
              Object localObject = localEntry.getKey();
              localObject = oe.a((Collection)localEntry.getValue(), new oe.c(oe.this, localObject));
              if ((!((Collection)localObject).isEmpty()) && (((Collection)paramAnonymousObject).equals(localObject)))
              {
                if (((Collection)localObject).size() == ((Collection)localEntry.getValue()).size()) {
                  localIterator.remove();
                }
                for (;;)
                {
                  return true;
                  ((Collection)localObject).clear();
                }
              }
            }
          }
          return false;
        }
        
        public final boolean removeAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Maps.b(Predicates.in(paramAnonymousCollection)));
        }
        
        public final boolean retainAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Maps.b(Predicates.not(Predicates.in(paramAnonymousCollection))));
        }
      };
    }
    
    public final void clear()
    {
      oe.this.clear();
    }
    
    public final boolean containsKey(@Nullable Object paramObject)
    {
      return b(paramObject) != null;
    }
    
    final Set<K> e()
    {
      new Maps.n(this)
      {
        public final boolean remove(@Nullable Object paramAnonymousObject)
        {
          return oe.a.this.a(paramAnonymousObject) != null;
        }
        
        public final boolean removeAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Maps.a(Predicates.in(paramAnonymousCollection)));
        }
        
        public final boolean retainAll(Collection<?> paramAnonymousCollection)
        {
          return oe.this.a(Maps.a(Predicates.not(Predicates.in(paramAnonymousCollection))));
        }
      };
    }
  }
  
  final class b
    extends Multimaps.g<K, V>
  {
    b()
    {
      super();
    }
    
    public final Set<Multiset.Entry<K>> entrySet()
    {
      new Multisets.c()
      {
        private boolean a(final Predicate<? super Multiset.Entry<K>> paramAnonymousPredicate)
        {
          oe.this.a(new Predicate() {});
        }
        
        final Multiset<K> a()
        {
          return oe.b.this;
        }
        
        public final Iterator<Multiset.Entry<K>> iterator()
        {
          return oe.b.this.a();
        }
        
        public final boolean removeAll(Collection<?> paramAnonymousCollection)
        {
          return a(Predicates.in(paramAnonymousCollection));
        }
        
        public final boolean retainAll(Collection<?> paramAnonymousCollection)
        {
          return a(Predicates.not(Predicates.in(paramAnonymousCollection)));
        }
        
        public final int size()
        {
          return oe.this.keySet().size();
        }
      };
    }
    
    public final int remove(@Nullable Object paramObject, int paramInt)
    {
      int i = 0;
      nj.a(paramInt, "occurrences");
      if (paramInt == 0) {
        i = count(paramObject);
      }
      do
      {
        return i;
        localObject1 = (Collection)oe.this.a.asMap().get(paramObject);
      } while (localObject1 == null);
      Object localObject1 = ((Collection)localObject1).iterator();
      i = 0;
      while (((Iterator)localObject1).hasNext())
      {
        Object localObject2 = ((Iterator)localObject1).next();
        if (oe.a(oe.this, paramObject, localObject2))
        {
          int j = i + 1;
          i = j;
          if (j <= paramInt)
          {
            ((Iterator)localObject1).remove();
            i = j;
          }
        }
      }
      return i;
    }
  }
  
  final class c
    implements Predicate<V>
  {
    private final K b;
    
    c()
    {
      Object localObject;
      this.b = localObject;
    }
    
    public final boolean apply(@Nullable V paramV)
    {
      return oe.a(oe.this, this.b, paramV);
    }
  }
}


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