package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.base.Supplier;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedSet;
import javax.annotation.Nullable;
import mt;
import mu;
import mx;
import my;
import nb;
import ne;
import nj;
import oe;
import of;
import og;
import oh;
import oi;
import oj;
import ol;
import qf.i;
import qf.k;
import qf.s;
import qf.v;
import qg;

@GwtCompatible(emulated=true)
public final class Multimaps
{
  private static <K, V> Multimap<K, V> a(oj<K, V> paramoj, Predicate<? super Map.Entry<K, V>> paramPredicate)
  {
    paramPredicate = Predicates.and(paramoj.b(), paramPredicate);
    return new oe(paramoj.a(), paramPredicate);
  }
  
  private static <K, V> SetMultimap<K, V> a(ol<K, V> paramol, Predicate<? super Map.Entry<K, V>> paramPredicate)
  {
    paramPredicate = Predicates.and(paramol.b(), paramPredicate);
    return new of(paramol.c(), paramPredicate);
  }
  
  public static boolean a(Multimap<?, ?> paramMultimap, @Nullable Object paramObject)
  {
    if (paramObject == paramMultimap) {
      return true;
    }
    if ((paramObject instanceof Multimap))
    {
      paramObject = (Multimap)paramObject;
      return paramMultimap.asMap().equals(((Multimap)paramObject).asMap());
    }
    return false;
  }
  
  @Beta
  public static <K, V> Map<K, List<V>> asMap(ListMultimap<K, V> paramListMultimap)
  {
    return paramListMultimap.asMap();
  }
  
  @Beta
  public static <K, V> Map<K, Collection<V>> asMap(Multimap<K, V> paramMultimap)
  {
    return paramMultimap.asMap();
  }
  
  @Beta
  public static <K, V> Map<K, Set<V>> asMap(SetMultimap<K, V> paramSetMultimap)
  {
    return paramSetMultimap.asMap();
  }
  
  @Beta
  public static <K, V> Map<K, SortedSet<V>> asMap(SortedSetMultimap<K, V> paramSortedSetMultimap)
  {
    return paramSortedSetMultimap.asMap();
  }
  
  public static <K, V> Multimap<K, V> filterEntries(Multimap<K, V> paramMultimap, Predicate<? super Map.Entry<K, V>> paramPredicate)
  {
    Preconditions.checkNotNull(paramPredicate);
    if ((paramMultimap instanceof SetMultimap)) {
      return filterEntries((SetMultimap)paramMultimap, paramPredicate);
    }
    if ((paramMultimap instanceof oj)) {
      return a((oj)paramMultimap, paramPredicate);
    }
    return new oe((Multimap)Preconditions.checkNotNull(paramMultimap), paramPredicate);
  }
  
  public static <K, V> SetMultimap<K, V> filterEntries(SetMultimap<K, V> paramSetMultimap, Predicate<? super Map.Entry<K, V>> paramPredicate)
  {
    Preconditions.checkNotNull(paramPredicate);
    if ((paramSetMultimap instanceof ol)) {
      return a((ol)paramSetMultimap, paramPredicate);
    }
    return new of((SetMultimap)Preconditions.checkNotNull(paramSetMultimap), paramPredicate);
  }
  
  public static <K, V> ListMultimap<K, V> filterKeys(ListMultimap<K, V> paramListMultimap, Predicate<? super K> paramPredicate)
  {
    if ((paramListMultimap instanceof og))
    {
      paramListMultimap = (og)paramListMultimap;
      return new og(paramListMultimap.c(), Predicates.and(paramListMultimap.b, paramPredicate));
    }
    return new og(paramListMultimap, paramPredicate);
  }
  
  public static <K, V> Multimap<K, V> filterKeys(Multimap<K, V> paramMultimap, Predicate<? super K> paramPredicate)
  {
    if ((paramMultimap instanceof SetMultimap)) {
      return filterKeys((SetMultimap)paramMultimap, paramPredicate);
    }
    if ((paramMultimap instanceof ListMultimap)) {
      return filterKeys((ListMultimap)paramMultimap, paramPredicate);
    }
    if ((paramMultimap instanceof oh))
    {
      paramMultimap = (oh)paramMultimap;
      return new oh(paramMultimap.a, Predicates.and(paramMultimap.b, paramPredicate));
    }
    if ((paramMultimap instanceof oj)) {
      return a((oj)paramMultimap, Maps.a(paramPredicate));
    }
    return new oh(paramMultimap, paramPredicate);
  }
  
  public static <K, V> SetMultimap<K, V> filterKeys(SetMultimap<K, V> paramSetMultimap, Predicate<? super K> paramPredicate)
  {
    if ((paramSetMultimap instanceof oi))
    {
      paramSetMultimap = (oi)paramSetMultimap;
      return new oi((SetMultimap)paramSetMultimap.a, Predicates.and(paramSetMultimap.b, paramPredicate));
    }
    if ((paramSetMultimap instanceof ol)) {
      return a((ol)paramSetMultimap, Maps.a(paramPredicate));
    }
    return new oi(paramSetMultimap, paramPredicate);
  }
  
  public static <K, V> Multimap<K, V> filterValues(Multimap<K, V> paramMultimap, Predicate<? super V> paramPredicate)
  {
    return filterEntries(paramMultimap, Maps.b(paramPredicate));
  }
  
  public static <K, V> SetMultimap<K, V> filterValues(SetMultimap<K, V> paramSetMultimap, Predicate<? super V> paramPredicate)
  {
    return filterEntries(paramSetMultimap, Maps.b(paramPredicate));
  }
  
  public static <K, V> SetMultimap<K, V> forMap(Map<K, V> paramMap)
  {
    return new h(paramMap);
  }
  
  public static <K, V> ImmutableListMultimap<K, V> index(Iterable<V> paramIterable, Function<? super V, K> paramFunction)
  {
    return index(paramIterable.iterator(), paramFunction);
  }
  
  public static <K, V> ImmutableListMultimap<K, V> index(Iterator<V> paramIterator, Function<? super V, K> paramFunction)
  {
    Preconditions.checkNotNull(paramFunction);
    ImmutableListMultimap.Builder localBuilder = ImmutableListMultimap.builder();
    while (paramIterator.hasNext())
    {
      Object localObject = paramIterator.next();
      Preconditions.checkNotNull(localObject, paramIterator);
      localBuilder.put(paramFunction.apply(localObject), localObject);
    }
    return localBuilder.build();
  }
  
  public static <K, V, M extends Multimap<K, V>> M invertFrom(Multimap<? extends V, ? extends K> paramMultimap, M paramM)
  {
    Preconditions.checkNotNull(paramM);
    paramMultimap = paramMultimap.entries().iterator();
    while (paramMultimap.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)paramMultimap.next();
      paramM.put(localEntry.getValue(), localEntry.getKey());
    }
    return paramM;
  }
  
  public static <K, V> ListMultimap<K, V> newListMultimap(Map<K, Collection<V>> paramMap, Supplier<? extends List<V>> paramSupplier)
  {
    return new b(paramMap, paramSupplier);
  }
  
  public static <K, V> Multimap<K, V> newMultimap(Map<K, Collection<V>> paramMap, Supplier<? extends Collection<V>> paramSupplier)
  {
    return new c(paramMap, paramSupplier);
  }
  
  public static <K, V> SetMultimap<K, V> newSetMultimap(Map<K, Collection<V>> paramMap, Supplier<? extends Set<V>> paramSupplier)
  {
    return new d(paramMap, paramSupplier);
  }
  
  public static <K, V> SortedSetMultimap<K, V> newSortedSetMultimap(Map<K, Collection<V>> paramMap, Supplier<? extends SortedSet<V>> paramSupplier)
  {
    return new e(paramMap, paramSupplier);
  }
  
  public static <K, V> ListMultimap<K, V> synchronizedListMultimap(ListMultimap<K, V> paramListMultimap)
  {
    if (((paramListMultimap instanceof qf.i)) || ((paramListMultimap instanceof ImmutableListMultimap))) {
      return paramListMultimap;
    }
    return new qf.i(paramListMultimap);
  }
  
  public static <K, V> Multimap<K, V> synchronizedMultimap(Multimap<K, V> paramMultimap)
  {
    if (((paramMultimap instanceof qf.k)) || ((paramMultimap instanceof ImmutableMultimap))) {
      return paramMultimap;
    }
    return new qf.k(paramMultimap);
  }
  
  public static <K, V> SetMultimap<K, V> synchronizedSetMultimap(SetMultimap<K, V> paramSetMultimap)
  {
    if (((paramSetMultimap instanceof qf.s)) || ((paramSetMultimap instanceof ImmutableSetMultimap))) {
      return paramSetMultimap;
    }
    return new qf.s(paramSetMultimap);
  }
  
  public static <K, V> SortedSetMultimap<K, V> synchronizedSortedSetMultimap(SortedSetMultimap<K, V> paramSortedSetMultimap)
  {
    if ((paramSortedSetMultimap instanceof qf.v)) {
      return paramSortedSetMultimap;
    }
    return new qf.v(paramSortedSetMultimap);
  }
  
  public static <K, V1, V2> ListMultimap<K, V2> transformEntries(ListMultimap<K, V1> paramListMultimap, Maps.EntryTransformer<? super K, ? super V1, V2> paramEntryTransformer)
  {
    return new i(paramListMultimap, paramEntryTransformer);
  }
  
  public static <K, V1, V2> Multimap<K, V2> transformEntries(Multimap<K, V1> paramMultimap, Maps.EntryTransformer<? super K, ? super V1, V2> paramEntryTransformer)
  {
    return new j(paramMultimap, paramEntryTransformer);
  }
  
  public static <K, V1, V2> ListMultimap<K, V2> transformValues(ListMultimap<K, V1> paramListMultimap, Function<? super V1, V2> paramFunction)
  {
    Preconditions.checkNotNull(paramFunction);
    return transformEntries(paramListMultimap, Maps.a(paramFunction));
  }
  
  public static <K, V1, V2> Multimap<K, V2> transformValues(Multimap<K, V1> paramMultimap, Function<? super V1, V2> paramFunction)
  {
    Preconditions.checkNotNull(paramFunction);
    return transformEntries(paramMultimap, Maps.a(paramFunction));
  }
  
  @Deprecated
  public static <K, V> ListMultimap<K, V> unmodifiableListMultimap(ImmutableListMultimap<K, V> paramImmutableListMultimap)
  {
    return (ListMultimap)Preconditions.checkNotNull(paramImmutableListMultimap);
  }
  
  public static <K, V> ListMultimap<K, V> unmodifiableListMultimap(ListMultimap<K, V> paramListMultimap)
  {
    if (((paramListMultimap instanceof k)) || ((paramListMultimap instanceof ImmutableListMultimap))) {
      return paramListMultimap;
    }
    return new k(paramListMultimap);
  }
  
  @Deprecated
  public static <K, V> Multimap<K, V> unmodifiableMultimap(ImmutableMultimap<K, V> paramImmutableMultimap)
  {
    return (Multimap)Preconditions.checkNotNull(paramImmutableMultimap);
  }
  
  public static <K, V> Multimap<K, V> unmodifiableMultimap(Multimap<K, V> paramMultimap)
  {
    if (((paramMultimap instanceof l)) || ((paramMultimap instanceof ImmutableMultimap))) {
      return paramMultimap;
    }
    return new l(paramMultimap);
  }
  
  @Deprecated
  public static <K, V> SetMultimap<K, V> unmodifiableSetMultimap(ImmutableSetMultimap<K, V> paramImmutableSetMultimap)
  {
    return (SetMultimap)Preconditions.checkNotNull(paramImmutableSetMultimap);
  }
  
  public static <K, V> SetMultimap<K, V> unmodifiableSetMultimap(SetMultimap<K, V> paramSetMultimap)
  {
    if (((paramSetMultimap instanceof m)) || ((paramSetMultimap instanceof ImmutableSetMultimap))) {
      return paramSetMultimap;
    }
    return new m(paramSetMultimap);
  }
  
  public static <K, V> SortedSetMultimap<K, V> unmodifiableSortedSetMultimap(SortedSetMultimap<K, V> paramSortedSetMultimap)
  {
    if ((paramSortedSetMultimap instanceof n)) {
      return paramSortedSetMultimap;
    }
    return new n(paramSortedSetMultimap);
  }
  
  static final class a<K, V>
    extends Maps.m<K, Collection<V>>
  {
    final Multimap<K, V> a;
    
    a(Multimap<K, V> paramMultimap)
    {
      this.a = ((Multimap)Preconditions.checkNotNull(paramMultimap));
    }
    
    protected final Set<Map.Entry<K, Collection<V>>> a()
    {
      return new a();
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final boolean containsKey(Object paramObject)
    {
      return this.a.containsKey(paramObject);
    }
    
    public final boolean isEmpty()
    {
      return this.a.isEmpty();
    }
    
    public final Set<K> keySet()
    {
      return this.a.keySet();
    }
    
    public final int size()
    {
      return this.a.keySet().size();
    }
    
    final class a
      extends Maps.f<K, Collection<V>>
    {
      a() {}
      
      final Map<K, Collection<V>> a()
      {
        return Multimaps.a.this;
      }
      
      public final Iterator<Map.Entry<K, Collection<V>>> iterator()
      {
        Maps.a(Multimaps.a.a(Multimaps.a.this).keySet(), new Function() {});
      }
      
      public final boolean remove(Object paramObject)
      {
        if (!contains(paramObject)) {
          return false;
        }
        Object localObject = (Map.Entry)paramObject;
        paramObject = Multimaps.a.this;
        localObject = ((Map.Entry)localObject).getKey();
        ((Multimaps.a)paramObject).a.keySet().remove(localObject);
        return true;
      }
    }
  }
  
  static final class b<K, V>
    extends mt<K, V>
  {
    @GwtIncompatible("java serialization not supported")
    private static final long serialVersionUID = 0L;
    transient Supplier<? extends List<V>> a;
    
    b(Map<K, Collection<V>> paramMap, Supplier<? extends List<V>> paramSupplier)
    {
      super();
      this.a = ((Supplier)Preconditions.checkNotNull(paramSupplier));
    }
    
    @GwtIncompatible("java.io.ObjectInputStream")
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      paramObjectInputStream.defaultReadObject();
      this.a = ((Supplier)paramObjectInputStream.readObject());
      a((Map)paramObjectInputStream.readObject());
    }
    
    @GwtIncompatible("java.io.ObjectOutputStream")
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.defaultWriteObject();
      paramObjectOutputStream.writeObject(this.a);
      paramObjectOutputStream.writeObject(d());
    }
    
    protected final List<V> a()
    {
      return (List)this.a.get();
    }
  }
  
  static final class c<K, V>
    extends mu<K, V>
  {
    @GwtIncompatible("java serialization not supported")
    private static final long serialVersionUID = 0L;
    transient Supplier<? extends Collection<V>> a;
    
    c(Map<K, Collection<V>> paramMap, Supplier<? extends Collection<V>> paramSupplier)
    {
      super();
      this.a = ((Supplier)Preconditions.checkNotNull(paramSupplier));
    }
    
    @GwtIncompatible("java.io.ObjectInputStream")
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      paramObjectInputStream.defaultReadObject();
      this.a = ((Supplier)paramObjectInputStream.readObject());
      a((Map)paramObjectInputStream.readObject());
    }
    
    @GwtIncompatible("java.io.ObjectOutputStream")
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.defaultWriteObject();
      paramObjectOutputStream.writeObject(this.a);
      paramObjectOutputStream.writeObject(d());
    }
    
    protected final Collection<V> b()
    {
      return (Collection)this.a.get();
    }
  }
  
  static final class d<K, V>
    extends nb<K, V>
  {
    @GwtIncompatible("not needed in emulated source")
    private static final long serialVersionUID = 0L;
    transient Supplier<? extends Set<V>> a;
    
    d(Map<K, Collection<V>> paramMap, Supplier<? extends Set<V>> paramSupplier)
    {
      super();
      this.a = ((Supplier)Preconditions.checkNotNull(paramSupplier));
    }
    
    @GwtIncompatible("java.io.ObjectInputStream")
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      paramObjectInputStream.defaultReadObject();
      this.a = ((Supplier)paramObjectInputStream.readObject());
      a((Map)paramObjectInputStream.readObject());
    }
    
    @GwtIncompatible("java.io.ObjectOutputStream")
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.defaultWriteObject();
      paramObjectOutputStream.writeObject(this.a);
      paramObjectOutputStream.writeObject(d());
    }
    
    protected final Set<V> a()
    {
      return (Set)this.a.get();
    }
  }
  
  static final class e<K, V>
    extends ne<K, V>
  {
    @GwtIncompatible("not needed in emulated source")
    private static final long serialVersionUID = 0L;
    transient Supplier<? extends SortedSet<V>> a;
    transient Comparator<? super V> b;
    
    e(Map<K, Collection<V>> paramMap, Supplier<? extends SortedSet<V>> paramSupplier)
    {
      super();
      this.a = ((Supplier)Preconditions.checkNotNull(paramSupplier));
      this.b = ((SortedSet)paramSupplier.get()).comparator();
    }
    
    @GwtIncompatible("java.io.ObjectInputStream")
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      paramObjectInputStream.defaultReadObject();
      this.a = ((Supplier)paramObjectInputStream.readObject());
      this.b = ((SortedSet)this.a.get()).comparator();
      a((Map)paramObjectInputStream.readObject());
    }
    
    @GwtIncompatible("java.io.ObjectOutputStream")
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.defaultWriteObject();
      paramObjectOutputStream.writeObject(this.a);
      paramObjectOutputStream.writeObject(d());
    }
    
    protected final SortedSet<V> n()
    {
      return (SortedSet)this.a.get();
    }
    
    public final Comparator<? super V> valueComparator()
    {
      return this.b;
    }
  }
  
  public static abstract class f<K, V>
    extends AbstractCollection<Map.Entry<K, V>>
  {
    public abstract Multimap<K, V> a();
    
    public void clear()
    {
      a().clear();
    }
    
    public boolean contains(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Map.Entry))
      {
        paramObject = (Map.Entry)paramObject;
        return a().containsEntry(((Map.Entry)paramObject).getKey(), ((Map.Entry)paramObject).getValue());
      }
      return false;
    }
    
    public boolean remove(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Map.Entry))
      {
        paramObject = (Map.Entry)paramObject;
        return a().remove(((Map.Entry)paramObject).getKey(), ((Map.Entry)paramObject).getValue());
      }
      return false;
    }
    
    public int size()
    {
      return a().size();
    }
  }
  
  public static class g<K, V>
    extends my<K>
  {
    final Multimap<K, V> b;
    
    public g(Multimap<K, V> paramMultimap)
    {
      this.b = paramMultimap;
    }
    
    public final Iterator<Multiset.Entry<K>> a()
    {
      new qg(this.b.asMap().entrySet().iterator()) {};
    }
    
    final int b()
    {
      return this.b.asMap().size();
    }
    
    public void clear()
    {
      this.b.clear();
    }
    
    public boolean contains(@Nullable Object paramObject)
    {
      return this.b.containsKey(paramObject);
    }
    
    public int count(@Nullable Object paramObject)
    {
      paramObject = (Collection)Maps.a(this.b.asMap(), paramObject);
      if (paramObject == null) {
        return 0;
      }
      return ((Collection)paramObject).size();
    }
    
    Set<Multiset.Entry<K>> createEntrySet()
    {
      return new a();
    }
    
    public Set<K> elementSet()
    {
      return this.b.keySet();
    }
    
    public Iterator<K> iterator()
    {
      return Maps.a(this.b.entries().iterator());
    }
    
    public int remove(@Nullable Object paramObject, int paramInt)
    {
      int i = 0;
      nj.a(paramInt, "occurrences");
      if (paramInt == 0) {
        return count(paramObject);
      }
      paramObject = (Collection)Maps.a(this.b.asMap(), paramObject);
      if (paramObject == null) {
        return 0;
      }
      int j = ((Collection)paramObject).size();
      if (paramInt >= j) {
        ((Collection)paramObject).clear();
      }
      for (;;)
      {
        return j;
        paramObject = ((Collection)paramObject).iterator();
        while (i < paramInt)
        {
          ((Iterator)paramObject).next();
          ((Iterator)paramObject).remove();
          i += 1;
        }
      }
    }
    
    final class a
      extends Multisets.c<K>
    {
      a() {}
      
      final Multiset<K> a()
      {
        return Multimaps.g.this;
      }
      
      public final boolean contains(@Nullable Object paramObject)
      {
        if ((paramObject instanceof Multiset.Entry))
        {
          paramObject = (Multiset.Entry)paramObject;
          Collection localCollection = (Collection)Multimaps.g.this.b.asMap().get(((Multiset.Entry)paramObject).getElement());
          return (localCollection != null) && (localCollection.size() == ((Multiset.Entry)paramObject).getCount());
        }
        return false;
      }
      
      public final boolean isEmpty()
      {
        return Multimaps.g.this.b.isEmpty();
      }
      
      public final Iterator<Multiset.Entry<K>> iterator()
      {
        return Multimaps.g.this.a();
      }
      
      public final boolean remove(@Nullable Object paramObject)
      {
        if ((paramObject instanceof Multiset.Entry))
        {
          paramObject = (Multiset.Entry)paramObject;
          Collection localCollection = (Collection)Multimaps.g.this.b.asMap().get(((Multiset.Entry)paramObject).getElement());
          if ((localCollection != null) && (localCollection.size() == ((Multiset.Entry)paramObject).getCount()))
          {
            localCollection.clear();
            return true;
          }
        }
        return false;
      }
      
      public final int size()
      {
        return Multimaps.g.this.b();
      }
    }
  }
  
  static final class h<K, V>
    extends mx<K, V>
    implements SetMultimap<K, V>, Serializable
  {
    private static final long serialVersionUID = 7845222491160860175L;
    final Map<K, V> a;
    
    h(Map<K, V> paramMap)
    {
      this.a = ((Map)Preconditions.checkNotNull(paramMap));
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final boolean containsEntry(Object paramObject1, Object paramObject2)
    {
      return this.a.entrySet().contains(Maps.immutableEntry(paramObject1, paramObject2));
    }
    
    public final boolean containsKey(Object paramObject)
    {
      return this.a.containsKey(paramObject);
    }
    
    public final boolean containsValue(Object paramObject)
    {
      return this.a.containsValue(paramObject);
    }
    
    public final Set<Map.Entry<K, V>> entries()
    {
      return this.a.entrySet();
    }
    
    final Iterator<Map.Entry<K, V>> g()
    {
      return this.a.entrySet().iterator();
    }
    
    public final Set<V> get(final K paramK)
    {
      new Sets.f()
      {
        public final Iterator<V> iterator()
        {
          new Iterator()
          {
            int a;
            
            public final boolean hasNext()
            {
              return (this.a == 0) && (Multimaps.h.this.a.containsKey(Multimaps.h.1.this.a));
            }
            
            public final V next()
            {
              if (!hasNext()) {
                throw new NoSuchElementException();
              }
              this.a += 1;
              return (V)Multimaps.h.this.a.get(Multimaps.h.1.this.a);
            }
            
            public final void remove()
            {
              boolean bool = true;
              if (this.a == 1) {}
              for (;;)
              {
                Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
                this.a = -1;
                Multimaps.h.this.a.remove(Multimaps.h.1.this.a);
                return;
                bool = false;
              }
            }
          };
        }
        
        public final int size()
        {
          if (Multimaps.h.this.a.containsKey(paramK)) {
            return 1;
          }
          return 0;
        }
      };
    }
    
    final Map<K, Collection<V>> h()
    {
      return new Multimaps.a(this);
    }
    
    public final int hashCode()
    {
      return this.a.hashCode();
    }
    
    public final Set<K> keySet()
    {
      return this.a.keySet();
    }
    
    public final boolean put(K paramK, V paramV)
    {
      throw new UnsupportedOperationException();
    }
    
    public final boolean putAll(Multimap<? extends K, ? extends V> paramMultimap)
    {
      throw new UnsupportedOperationException();
    }
    
    public final boolean putAll(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public final boolean remove(Object paramObject1, Object paramObject2)
    {
      return this.a.entrySet().remove(Maps.immutableEntry(paramObject1, paramObject2));
    }
    
    public final Set<V> removeAll(Object paramObject)
    {
      HashSet localHashSet = new HashSet(2);
      if (!this.a.containsKey(paramObject)) {
        return localHashSet;
      }
      localHashSet.add(this.a.remove(paramObject));
      return localHashSet;
    }
    
    public final Set<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public final int size()
    {
      return this.a.size();
    }
    
    public final Collection<V> values()
    {
      return this.a.values();
    }
  }
  
  static final class i<K, V1, V2>
    extends Multimaps.j<K, V1, V2>
    implements ListMultimap<K, V2>
  {
    i(ListMultimap<K, V1> paramListMultimap, Maps.EntryTransformer<? super K, ? super V1, V2> paramEntryTransformer)
    {
      super(paramEntryTransformer);
    }
    
    private List<V2> b(K paramK, Collection<V1> paramCollection)
    {
      return Lists.transform((List)paramCollection, Maps.a(this.b, paramK));
    }
    
    public final List<V2> get(K paramK)
    {
      return b(paramK, this.a.get(paramK));
    }
    
    public final List<V2> removeAll(Object paramObject)
    {
      return b(paramObject, this.a.removeAll(paramObject));
    }
    
    public final List<V2> replaceValues(K paramK, Iterable<? extends V2> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
  }
  
  static class j<K, V1, V2>
    extends mx<K, V2>
  {
    final Multimap<K, V1> a;
    final Maps.EntryTransformer<? super K, ? super V1, V2> b;
    
    j(Multimap<K, V1> paramMultimap, Maps.EntryTransformer<? super K, ? super V1, V2> paramEntryTransformer)
    {
      this.a = ((Multimap)Preconditions.checkNotNull(paramMultimap));
      this.b = ((Maps.EntryTransformer)Preconditions.checkNotNull(paramEntryTransformer));
    }
    
    Collection<V2> a(K paramK, Collection<V1> paramCollection)
    {
      paramK = Maps.a(this.b, paramK);
      if ((paramCollection instanceof List)) {
        return Lists.transform((List)paramCollection, paramK);
      }
      return Collections2.transform(paramCollection, paramK);
    }
    
    public void clear()
    {
      this.a.clear();
    }
    
    public boolean containsKey(Object paramObject)
    {
      return this.a.containsKey(paramObject);
    }
    
    final Iterator<Map.Entry<K, V2>> g()
    {
      return Iterators.transform(this.a.entries().iterator(), Maps.b(this.b));
    }
    
    public Collection<V2> get(K paramK)
    {
      return a(paramK, this.a.get(paramK));
    }
    
    final Map<K, Collection<V2>> h()
    {
      Maps.transformEntries(this.a.asMap(), new Maps.EntryTransformer() {});
    }
    
    public boolean isEmpty()
    {
      return this.a.isEmpty();
    }
    
    final Collection<V2> k()
    {
      return Collections2.transform(this.a.entries(), Maps.a(this.b));
    }
    
    public Set<K> keySet()
    {
      return this.a.keySet();
    }
    
    public Multiset<K> keys()
    {
      return this.a.keys();
    }
    
    public boolean put(K paramK, V2 paramV2)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean putAll(Multimap<? extends K, ? extends V2> paramMultimap)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean putAll(K paramK, Iterable<? extends V2> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean remove(Object paramObject1, Object paramObject2)
    {
      return get(paramObject1).remove(paramObject2);
    }
    
    public Collection<V2> removeAll(Object paramObject)
    {
      return a(paramObject, this.a.removeAll(paramObject));
    }
    
    public Collection<V2> replaceValues(K paramK, Iterable<? extends V2> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public int size()
    {
      return this.a.size();
    }
  }
  
  static final class k<K, V>
    extends Multimaps.l<K, V>
    implements ListMultimap<K, V>
  {
    private static final long serialVersionUID = 0L;
    
    k(ListMultimap<K, V> paramListMultimap)
    {
      super();
    }
    
    public final List<V> get(K paramK)
    {
      return Collections.unmodifiableList(((ListMultimap)super.delegate()).get(paramK));
    }
    
    public final List<V> removeAll(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public final List<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
  }
  
  static class l<K, V>
    extends ForwardingMultimap<K, V>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Multimap<K, V> a;
    transient Collection<Map.Entry<K, V>> b;
    transient Multiset<K> c;
    transient Set<K> d;
    transient Collection<V> e;
    transient Map<K, Collection<V>> f;
    
    l(Multimap<K, V> paramMultimap)
    {
      this.a = ((Multimap)Preconditions.checkNotNull(paramMultimap));
    }
    
    public Map<K, Collection<V>> asMap()
    {
      Map localMap2 = this.f;
      Map localMap1 = localMap2;
      if (localMap2 == null)
      {
        localMap1 = Collections.unmodifiableMap(Maps.transformValues(this.a.asMap(), new Function() {}));
        this.f = localMap1;
      }
      return localMap1;
    }
    
    public void clear()
    {
      throw new UnsupportedOperationException();
    }
    
    protected Multimap<K, V> delegate()
    {
      return this.a;
    }
    
    public Collection<Map.Entry<K, V>> entries()
    {
      Collection localCollection2 = this.b;
      Collection localCollection1 = localCollection2;
      if (localCollection2 == null)
      {
        localCollection1 = Multimaps.b(this.a.entries());
        this.b = localCollection1;
      }
      return localCollection1;
    }
    
    public Collection<V> get(K paramK)
    {
      return Multimaps.a(this.a.get(paramK));
    }
    
    public Set<K> keySet()
    {
      Set localSet2 = this.d;
      Set localSet1 = localSet2;
      if (localSet2 == null)
      {
        localSet1 = Collections.unmodifiableSet(this.a.keySet());
        this.d = localSet1;
      }
      return localSet1;
    }
    
    public Multiset<K> keys()
    {
      Multiset localMultiset2 = this.c;
      Multiset localMultiset1 = localMultiset2;
      if (localMultiset2 == null)
      {
        localMultiset1 = Multisets.unmodifiableMultiset(this.a.keys());
        this.c = localMultiset1;
      }
      return localMultiset1;
    }
    
    public boolean put(K paramK, V paramV)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean putAll(Multimap<? extends K, ? extends V> paramMultimap)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean putAll(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public boolean remove(Object paramObject1, Object paramObject2)
    {
      throw new UnsupportedOperationException();
    }
    
    public Collection<V> removeAll(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public Collection<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public Collection<V> values()
    {
      Collection localCollection2 = this.e;
      Collection localCollection1 = localCollection2;
      if (localCollection2 == null)
      {
        localCollection1 = Collections.unmodifiableCollection(this.a.values());
        this.e = localCollection1;
      }
      return localCollection1;
    }
  }
  
  static class m<K, V>
    extends Multimaps.l<K, V>
    implements SetMultimap<K, V>
  {
    private static final long serialVersionUID = 0L;
    
    m(SetMultimap<K, V> paramSetMultimap)
    {
      super();
    }
    
    public SetMultimap<K, V> a()
    {
      return (SetMultimap)super.delegate();
    }
    
    public Set<Map.Entry<K, V>> entries()
    {
      return Maps.a(a().entries());
    }
    
    public Set<V> get(K paramK)
    {
      return Collections.unmodifiableSet(a().get(paramK));
    }
    
    public Set<V> removeAll(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public Set<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
  }
  
  static final class n<K, V>
    extends Multimaps.m<K, V>
    implements SortedSetMultimap<K, V>
  {
    private static final long serialVersionUID = 0L;
    
    n(SortedSetMultimap<K, V> paramSortedSetMultimap)
    {
      super();
    }
    
    public final SortedSet<V> get(K paramK)
    {
      return Collections.unmodifiableSortedSet(((SortedSetMultimap)super.a()).get(paramK));
    }
    
    public final SortedSet<V> removeAll(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public final SortedSet<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
    {
      throw new UnsupportedOperationException();
    }
    
    public final Comparator<? super V> valueComparator()
    {
      return ((SortedSetMultimap)super.a()).valueComparator();
    }
  }
}


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