import com.google.common.annotations.GwtCompatible;
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 com.google.common.collect.AbstractIterator;
import com.google.common.collect.Collections2;
import com.google.common.collect.ForwardingMapEntry;
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.Sets;
import com.google.common.collect.Sets.f;
import com.google.common.collect.Table.Cell;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;

@GwtCompatible
public class qe<R, C, V>
  extends nf<R, C, V>
  implements Serializable
{
  private static final long serialVersionUID = 0L;
  public final Map<R, Map<C, V>> a;
  final Supplier<? extends Map<C, V>> b;
  private transient Set<C> c;
  private transient Map<R, Map<C, V>> d;
  private transient qe<R, C, V>.e e;
  
  public qe(Map<R, Map<C, V>> paramMap, Supplier<? extends Map<C, V>> paramSupplier)
  {
    this.a = paramMap;
    this.b = paramSupplier;
  }
  
  private boolean a(Object paramObject1, Object paramObject2, Object paramObject3)
  {
    return (paramObject3 != null) && (paramObject3.equals(get(paramObject1, paramObject2)));
  }
  
  final Iterator<Table.Cell<R, C, V>> b()
  {
    return new qe.a((byte)0);
  }
  
  public Set<Table.Cell<R, C, V>> cellSet()
  {
    return super.cellSet();
  }
  
  public void clear()
  {
    this.a.clear();
  }
  
  public Map<R, V> column(C paramC)
  {
    return new qe.b(paramC);
  }
  
  public Set<C> columnKeySet()
  {
    Set localSet = this.c;
    Object localObject = localSet;
    if (localSet == null)
    {
      localObject = new qe.d((byte)0);
      this.c = ((Set)localObject);
    }
    return (Set<C>)localObject;
  }
  
  public Map<C, Map<R, V>> columnMap()
  {
    qe.e locale2 = this.e;
    qe.e locale1 = locale2;
    if (locale2 == null)
    {
      locale1 = new qe.e((byte)0);
      this.e = locale1;
    }
    return locale1;
  }
  
  public boolean contains(@Nullable Object paramObject1, @Nullable Object paramObject2)
  {
    return (paramObject1 != null) && (paramObject2 != null) && (super.contains(paramObject1, paramObject2));
  }
  
  public boolean containsColumn(@Nullable Object paramObject)
  {
    if (paramObject == null) {
      return false;
    }
    Iterator localIterator = this.a.values().iterator();
    while (localIterator.hasNext()) {
      if (Maps.b((Map)localIterator.next(), paramObject)) {
        return true;
      }
    }
    return false;
  }
  
  public boolean containsRow(@Nullable Object paramObject)
  {
    return (paramObject != null) && (Maps.b(this.a, paramObject));
  }
  
  public boolean containsValue(@Nullable Object paramObject)
  {
    return (paramObject != null) && (super.containsValue(paramObject));
  }
  
  Map<R, Map<C, V>> e()
  {
    return new qe.g();
  }
  
  protected Iterator<C> f()
  {
    return new qe.c((byte)0);
  }
  
  public V get(@Nullable Object paramObject1, @Nullable Object paramObject2)
  {
    if ((paramObject1 == null) || (paramObject2 == null)) {
      return null;
    }
    return (V)super.get(paramObject1, paramObject2);
  }
  
  public boolean isEmpty()
  {
    return this.a.isEmpty();
  }
  
  public V put(R paramR, C paramC, V paramV)
  {
    Preconditions.checkNotNull(paramR);
    Preconditions.checkNotNull(paramC);
    Preconditions.checkNotNull(paramV);
    Map localMap2 = (Map)this.a.get(paramR);
    Map localMap1 = localMap2;
    if (localMap2 == null)
    {
      localMap1 = (Map)this.b.get();
      this.a.put(paramR, localMap1);
    }
    return (V)localMap1.put(paramC, paramV);
  }
  
  public V remove(@Nullable Object paramObject1, @Nullable Object paramObject2)
  {
    if ((paramObject1 == null) || (paramObject2 == null)) {
      return null;
    }
    Map localMap = (Map)Maps.a(this.a, paramObject1);
    if (localMap == null) {
      return null;
    }
    paramObject2 = localMap.remove(paramObject2);
    if (localMap.isEmpty()) {
      this.a.remove(paramObject1);
    }
    return (V)paramObject2;
  }
  
  public Map<C, V> row(R paramR)
  {
    return new qe.f(paramR);
  }
  
  public Set<R> rowKeySet()
  {
    return rowMap().keySet();
  }
  
  public Map<R, Map<C, V>> rowMap()
  {
    Map localMap2 = this.d;
    Map localMap1 = localMap2;
    if (localMap2 == null)
    {
      localMap1 = e();
      this.d = localMap1;
    }
    return localMap1;
  }
  
  public int size()
  {
    Iterator localIterator = this.a.values().iterator();
    for (int i = 0; localIterator.hasNext(); i = ((Map)localIterator.next()).size() + i) {}
    return i;
  }
  
  public Collection<V> values()
  {
    return super.values();
  }
  
  final class a
    implements Iterator<Table.Cell<R, C, V>>
  {
    final Iterator<Map.Entry<R, Map<C, V>>> a = qe.this.a.entrySet().iterator();
    Map.Entry<R, Map<C, V>> b;
    Iterator<Map.Entry<C, V>> c = Iterators.a();
    
    private a() {}
    
    public final boolean hasNext()
    {
      return (this.a.hasNext()) || (this.c.hasNext());
    }
    
    public final void remove()
    {
      this.c.remove();
      if (((Map)this.b.getValue()).isEmpty()) {
        this.a.remove();
      }
    }
  }
  
  final class b
    extends Maps.m<R, V>
  {
    final C a;
    
    b()
    {
      Object localObject;
      this.a = Preconditions.checkNotNull(localObject);
    }
    
    final Set<Map.Entry<R, V>> a()
    {
      return new qe.b.a((byte)0);
    }
    
    final boolean a(Predicate<? super Map.Entry<R, V>> paramPredicate)
    {
      Iterator localIterator = qe.this.a.entrySet().iterator();
      boolean bool1;
      for (boolean bool2 = false; localIterator.hasNext(); bool2 = bool1)
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        Map localMap = (Map)localEntry.getValue();
        Object localObject = localMap.get(this.a);
        bool1 = bool2;
        if (localObject != null)
        {
          bool1 = bool2;
          if (paramPredicate.apply(Maps.immutableEntry(localEntry.getKey(), localObject)))
          {
            localMap.remove(this.a);
            bool2 = true;
            bool1 = bool2;
            if (localMap.isEmpty())
            {
              localIterator.remove();
              bool1 = bool2;
            }
          }
        }
      }
      return bool2;
    }
    
    final Collection<V> b_()
    {
      return new qe.b.d();
    }
    
    public final boolean containsKey(Object paramObject)
    {
      return qe.this.contains(paramObject, this.a);
    }
    
    final Set<R> e()
    {
      return new qe.b.c();
    }
    
    public final V get(Object paramObject)
    {
      return (V)qe.this.get(paramObject, this.a);
    }
    
    public final V put(R paramR, V paramV)
    {
      return (V)qe.this.put(paramR, this.a, paramV);
    }
    
    public final V remove(Object paramObject)
    {
      return (V)qe.this.remove(paramObject, this.a);
    }
    
    final class a
      extends Sets.f<Map.Entry<R, V>>
    {
      private a() {}
      
      public final void clear()
      {
        qe.b.this.a(Predicates.alwaysTrue());
      }
      
      public final boolean contains(Object paramObject)
      {
        if ((paramObject instanceof Map.Entry))
        {
          paramObject = (Map.Entry)paramObject;
          return qe.a(qe.this, ((Map.Entry)paramObject).getKey(), qe.b.this.a, ((Map.Entry)paramObject).getValue());
        }
        return false;
      }
      
      public final boolean isEmpty()
      {
        return !qe.this.containsColumn(qe.b.this.a);
      }
      
      public final Iterator<Map.Entry<R, V>> iterator()
      {
        return new qe.b.b(qe.b.this, (byte)0);
      }
      
      public final boolean remove(Object paramObject)
      {
        if ((paramObject instanceof Map.Entry))
        {
          paramObject = (Map.Entry)paramObject;
          return qe.b(qe.this, ((Map.Entry)paramObject).getKey(), qe.b.this.a, ((Map.Entry)paramObject).getValue());
        }
        return false;
      }
      
      public final boolean retainAll(Collection<?> paramCollection)
      {
        return qe.b.this.a(Predicates.not(Predicates.in(paramCollection)));
      }
      
      public final int size()
      {
        Iterator localIterator = qe.this.a.values().iterator();
        int i = 0;
        if (localIterator.hasNext())
        {
          if (!((Map)localIterator.next()).containsKey(qe.b.this.a)) {
            break label65;
          }
          i += 1;
        }
        label65:
        for (;;)
        {
          break;
          return i;
        }
      }
    }
    
    final class b
      extends AbstractIterator<Map.Entry<R, V>>
    {
      final Iterator<Map.Entry<R, Map<C, V>>> a = qe.this.a.entrySet().iterator();
      
      private b() {}
    }
    
    final class c
      extends Maps.n<R, V>
    {
      c()
      {
        super();
      }
      
      public final boolean contains(Object paramObject)
      {
        return qe.this.contains(paramObject, qe.b.this.a);
      }
      
      public final boolean remove(Object paramObject)
      {
        return qe.this.remove(paramObject, qe.b.this.a) != null;
      }
      
      public final boolean retainAll(Collection<?> paramCollection)
      {
        return qe.b.this.a(Maps.a(Predicates.not(Predicates.in(paramCollection))));
      }
    }
    
    final class d
      extends Maps.ac<R, V>
    {
      d()
      {
        super();
      }
      
      public final boolean remove(Object paramObject)
      {
        return (paramObject != null) && (qe.b.this.a(Maps.b(Predicates.equalTo(paramObject))));
      }
      
      public final boolean removeAll(Collection<?> paramCollection)
      {
        return qe.b.this.a(Maps.b(Predicates.in(paramCollection)));
      }
      
      public final boolean retainAll(Collection<?> paramCollection)
      {
        return qe.b.this.a(Maps.b(Predicates.not(Predicates.in(paramCollection))));
      }
    }
  }
  
  final class c
    extends AbstractIterator<C>
  {
    final Map<C, V> a = (Map)qe.this.b.get();
    final Iterator<Map<C, V>> b = qe.this.a.values().iterator();
    Iterator<Map.Entry<C, V>> c = Iterators.emptyIterator();
    
    private c() {}
    
    protected final C computeNext()
    {
      for (;;)
      {
        if (this.c.hasNext())
        {
          Map.Entry localEntry = (Map.Entry)this.c.next();
          if (!this.a.containsKey(localEntry.getKey()))
          {
            this.a.put(localEntry.getKey(), localEntry.getValue());
            return (C)localEntry.getKey();
          }
        }
        else
        {
          if (!this.b.hasNext()) {
            break;
          }
          this.c = ((Map)this.b.next()).entrySet().iterator();
        }
      }
      return (C)endOfData();
    }
  }
  
  final class d
    extends qe<R, C, V>.h<C>
  {
    private d()
    {
      super((byte)0);
    }
    
    public final boolean contains(Object paramObject)
    {
      return qe.this.containsColumn(paramObject);
    }
    
    public final Iterator<C> iterator()
    {
      return qe.this.f();
    }
    
    public final boolean remove(Object paramObject)
    {
      if (paramObject == null) {
        return false;
      }
      Iterator localIterator = qe.this.a.values().iterator();
      boolean bool1 = false;
      while (localIterator.hasNext())
      {
        Map localMap = (Map)localIterator.next();
        if (localMap.keySet().remove(paramObject))
        {
          boolean bool2 = true;
          bool1 = bool2;
          if (localMap.isEmpty())
          {
            localIterator.remove();
            bool1 = bool2;
          }
        }
      }
      return bool1;
    }
    
    public final boolean removeAll(Collection<?> paramCollection)
    {
      Preconditions.checkNotNull(paramCollection);
      Iterator localIterator = qe.this.a.values().iterator();
      boolean bool1 = false;
      while (localIterator.hasNext())
      {
        Map localMap = (Map)localIterator.next();
        if (Iterators.removeAll(localMap.keySet().iterator(), paramCollection))
        {
          boolean bool2 = true;
          bool1 = bool2;
          if (localMap.isEmpty())
          {
            localIterator.remove();
            bool1 = bool2;
          }
        }
      }
      return bool1;
    }
    
    public final boolean retainAll(Collection<?> paramCollection)
    {
      Preconditions.checkNotNull(paramCollection);
      Iterator localIterator = qe.this.a.values().iterator();
      boolean bool1 = false;
      while (localIterator.hasNext())
      {
        Map localMap = (Map)localIterator.next();
        if (localMap.keySet().retainAll(paramCollection))
        {
          boolean bool2 = true;
          bool1 = bool2;
          if (localMap.isEmpty())
          {
            localIterator.remove();
            bool1 = bool2;
          }
        }
      }
      return bool1;
    }
    
    public final int size()
    {
      return Iterators.size(iterator());
    }
  }
  
  final class e
    extends Maps.m<C, Map<R, V>>
  {
    private e() {}
    
    public final Map<R, V> a(Object paramObject)
    {
      if (qe.this.containsColumn(paramObject)) {
        return qe.this.column(paramObject);
      }
      return null;
    }
    
    public final Set<Map.Entry<C, Map<R, V>>> a()
    {
      return new qe.e.a();
    }
    
    final Collection<Map<R, V>> b_()
    {
      return new qe.e.b();
    }
    
    public final boolean containsKey(Object paramObject)
    {
      return qe.this.containsColumn(paramObject);
    }
    
    public final Set<C> keySet()
    {
      return qe.this.columnKeySet();
    }
    
    final class a
      extends qe<R, C, V>.h<Map.Entry<C, Map<R, V>>>
    {
      a()
      {
        super((byte)0);
      }
      
      public final boolean contains(Object paramObject)
      {
        if ((paramObject instanceof Map.Entry))
        {
          paramObject = (Map.Entry)paramObject;
          if (qe.this.containsColumn(((Map.Entry)paramObject).getKey()))
          {
            Object localObject = ((Map.Entry)paramObject).getKey();
            return qe.e.this.a(localObject).equals(((Map.Entry)paramObject).getValue());
          }
        }
        return false;
      }
      
      public final Iterator<Map.Entry<C, Map<R, V>>> iterator()
      {
        Maps.a(qe.this.columnKeySet(), new Function() {});
      }
      
      public final boolean remove(Object paramObject)
      {
        if (contains(paramObject))
        {
          paramObject = (Map.Entry)paramObject;
          qe.a(qe.this, ((Map.Entry)paramObject).getKey());
          return true;
        }
        return false;
      }
      
      public final boolean removeAll(Collection<?> paramCollection)
      {
        Preconditions.checkNotNull(paramCollection);
        return Sets.a(this, paramCollection.iterator());
      }
      
      public final boolean retainAll(Collection<?> paramCollection)
      {
        Preconditions.checkNotNull(paramCollection);
        boolean bool = false;
        Iterator localIterator = Lists.newArrayList(qe.this.columnKeySet().iterator()).iterator();
        while (localIterator.hasNext())
        {
          Object localObject = localIterator.next();
          if (!paramCollection.contains(Maps.immutableEntry(localObject, qe.this.column(localObject))))
          {
            qe.a(qe.this, localObject);
            bool = true;
          }
        }
        return bool;
      }
      
      public final int size()
      {
        return qe.this.columnKeySet().size();
      }
    }
    
    final class b
      extends Maps.ac<C, Map<R, V>>
    {
      b()
      {
        super();
      }
      
      public final boolean remove(Object paramObject)
      {
        Iterator localIterator = qe.e.this.entrySet().iterator();
        while (localIterator.hasNext())
        {
          Map.Entry localEntry = (Map.Entry)localIterator.next();
          if (((Map)localEntry.getValue()).equals(paramObject))
          {
            qe.a(qe.this, localEntry.getKey());
            return true;
          }
        }
        return false;
      }
      
      public final boolean removeAll(Collection<?> paramCollection)
      {
        Preconditions.checkNotNull(paramCollection);
        boolean bool = false;
        Iterator localIterator = Lists.newArrayList(qe.this.columnKeySet().iterator()).iterator();
        while (localIterator.hasNext())
        {
          Object localObject = localIterator.next();
          if (paramCollection.contains(qe.this.column(localObject)))
          {
            qe.a(qe.this, localObject);
            bool = true;
          }
        }
        return bool;
      }
      
      public final boolean retainAll(Collection<?> paramCollection)
      {
        Preconditions.checkNotNull(paramCollection);
        boolean bool = false;
        Iterator localIterator = Lists.newArrayList(qe.this.columnKeySet().iterator()).iterator();
        while (localIterator.hasNext())
        {
          Object localObject = localIterator.next();
          if (!paramCollection.contains(qe.this.column(localObject)))
          {
            qe.a(qe.this, localObject);
            bool = true;
          }
        }
        return bool;
      }
    }
  }
  
  public class f
    extends Maps.m<C, V>
  {
    protected final R a;
    protected Map<C, V> b;
    
    protected f()
    {
      Object localObject;
      this.a = Preconditions.checkNotNull(localObject);
    }
    
    protected final Set<Map.Entry<C, V>> a()
    {
      return new qe.f.a((byte)0);
    }
    
    protected Map<C, V> c()
    {
      if ((this.b == null) || ((this.b.isEmpty()) && (qe.this.a.containsKey(this.a))))
      {
        Map localMap = d();
        this.b = localMap;
        return localMap;
      }
      return this.b;
    }
    
    public void clear()
    {
      Map localMap = c();
      if (localMap != null) {
        localMap.clear();
      }
      f();
    }
    
    public boolean containsKey(Object paramObject)
    {
      Map localMap = c();
      return (paramObject != null) && (localMap != null) && (Maps.b(localMap, paramObject));
    }
    
    protected Map<C, V> d()
    {
      return (Map)qe.this.a.get(this.a);
    }
    
    protected void f()
    {
      if ((c() != null) && (this.b.isEmpty()))
      {
        qe.this.a.remove(this.a);
        this.b = null;
      }
    }
    
    public V get(Object paramObject)
    {
      Map localMap = c();
      if ((paramObject != null) && (localMap != null)) {
        return (V)Maps.a(localMap, paramObject);
      }
      return null;
    }
    
    public V put(C paramC, V paramV)
    {
      Preconditions.checkNotNull(paramC);
      Preconditions.checkNotNull(paramV);
      if ((this.b != null) && (!this.b.isEmpty())) {
        return (V)this.b.put(paramC, paramV);
      }
      return (V)qe.this.put(this.a, paramC, paramV);
    }
    
    public V remove(Object paramObject)
    {
      Map localMap = c();
      if (localMap == null) {
        return null;
      }
      paramObject = Maps.c(localMap, paramObject);
      f();
      return (V)paramObject;
    }
    
    final class a
      extends Maps.f<C, V>
    {
      private a() {}
      
      final Map<C, V> a()
      {
        return qe.f.this;
      }
      
      public final Iterator<Map.Entry<C, V>> iterator()
      {
        Map localMap = qe.f.this.c();
        if (localMap == null) {
          return Iterators.a();
        }
        new Iterator()
        {
          public final boolean hasNext()
          {
            return this.a.hasNext();
          }
          
          public final void remove()
          {
            this.a.remove();
            qe.f.this.f();
          }
        };
      }
      
      public final int size()
      {
        Map localMap = qe.f.this.c();
        if (localMap == null) {
          return 0;
        }
        return localMap.size();
      }
    }
  }
  
  class g
    extends Maps.m<R, Map<C, V>>
  {
    g() {}
    
    protected final Set<Map.Entry<R, Map<C, V>>> a()
    {
      return new qe.g.a();
    }
    
    public boolean containsKey(Object paramObject)
    {
      return qe.this.containsRow(paramObject);
    }
    
    final class a
      extends qe<R, C, V>.h<Map.Entry<R, Map<C, V>>>
    {
      a()
      {
        super((byte)0);
      }
      
      public final boolean contains(Object paramObject)
      {
        boolean bool2 = false;
        boolean bool1 = bool2;
        if ((paramObject instanceof Map.Entry))
        {
          paramObject = (Map.Entry)paramObject;
          bool1 = bool2;
          if (((Map.Entry)paramObject).getKey() != null)
          {
            bool1 = bool2;
            if ((((Map.Entry)paramObject).getValue() instanceof Map))
            {
              bool1 = bool2;
              if (Collections2.a(qe.this.a.entrySet(), paramObject)) {
                bool1 = true;
              }
            }
          }
        }
        return bool1;
      }
      
      public final Iterator<Map.Entry<R, Map<C, V>>> iterator()
      {
        Maps.a(qe.this.a.keySet(), new Function() {});
      }
      
      public final boolean remove(Object paramObject)
      {
        boolean bool2 = false;
        boolean bool1 = bool2;
        if ((paramObject instanceof Map.Entry))
        {
          paramObject = (Map.Entry)paramObject;
          bool1 = bool2;
          if (((Map.Entry)paramObject).getKey() != null)
          {
            bool1 = bool2;
            if ((((Map.Entry)paramObject).getValue() instanceof Map))
            {
              bool1 = bool2;
              if (qe.this.a.entrySet().remove(paramObject)) {
                bool1 = true;
              }
            }
          }
        }
        return bool1;
      }
      
      public final int size()
      {
        return qe.this.a.size();
      }
    }
  }
  
  abstract class h<T>
    extends Sets.f<T>
  {
    private h() {}
    
    public void clear()
    {
      qe.this.a.clear();
    }
    
    public boolean isEmpty()
    {
      return qe.this.a.isEmpty();
    }
  }
}


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