import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.ForwardingCollection;
import com.google.common.collect.ForwardingList;
import com.google.common.collect.ForwardingListIterator;
import com.google.common.collect.ForwardingSet;
import com.google.common.collect.ForwardingSortedSet;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedSet;

@GwtCompatible
public final class no
{
  public static <E> Collection<E> a(Collection<E> paramCollection, nn<E> paramnn)
  {
    if ((paramCollection instanceof SortedSet)) {
      return a((SortedSet)paramCollection, paramnn);
    }
    if ((paramCollection instanceof Set)) {
      return new no.e((Set)paramCollection, paramnn);
    }
    if ((paramCollection instanceof List)) {
      return a((List)paramCollection, paramnn);
    }
    return new no.a(paramCollection, paramnn);
  }
  
  public static <E> List<E> a(List<E> paramList, nn<? super E> paramnn)
  {
    if ((paramList instanceof RandomAccess)) {
      return new no.d(paramList, paramnn);
    }
    return new no.b(paramList, paramnn);
  }
  
  public static <E> SortedSet<E> a(SortedSet<E> paramSortedSet, nn<? super E> paramnn)
  {
    return new no.f(paramSortedSet, paramnn);
  }
  
  static final class a<E>
    extends ForwardingCollection<E>
  {
    private final Collection<E> a;
    private final nn<? super E> b;
    
    public a(Collection<E> paramCollection, nn<? super E> paramnn)
    {
      this.a = ((Collection)Preconditions.checkNotNull(paramCollection));
      this.b = ((nn)Preconditions.checkNotNull(paramnn));
    }
    
    public final boolean add(E paramE)
    {
      this.b.a(paramE);
      return this.a.add(paramE);
    }
    
    public final boolean addAll(Collection<? extends E> paramCollection)
    {
      return this.a.addAll(no.b(paramCollection, this.b));
    }
    
    protected final Collection<E> delegate()
    {
      return this.a;
    }
  }
  
  @GwtCompatible
  static class b<E>
    extends ForwardingList<E>
  {
    final List<E> a;
    final nn<? super E> b;
    
    b(List<E> paramList, nn<? super E> paramnn)
    {
      this.a = ((List)Preconditions.checkNotNull(paramList));
      this.b = ((nn)Preconditions.checkNotNull(paramnn));
    }
    
    public void add(int paramInt, E paramE)
    {
      this.b.a(paramE);
      this.a.add(paramInt, paramE);
    }
    
    public boolean add(E paramE)
    {
      this.b.a(paramE);
      return this.a.add(paramE);
    }
    
    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      return this.a.addAll(paramInt, no.b(paramCollection, this.b));
    }
    
    public boolean addAll(Collection<? extends E> paramCollection)
    {
      return this.a.addAll(no.b(paramCollection, this.b));
    }
    
    protected List<E> delegate()
    {
      return this.a;
    }
    
    public ListIterator<E> listIterator()
    {
      return no.a(this.a.listIterator(), this.b);
    }
    
    public ListIterator<E> listIterator(int paramInt)
    {
      return no.a(this.a.listIterator(paramInt), this.b);
    }
    
    public E set(int paramInt, E paramE)
    {
      this.b.a(paramE);
      return (E)this.a.set(paramInt, paramE);
    }
    
    public List<E> subList(int paramInt1, int paramInt2)
    {
      return no.a(this.a.subList(paramInt1, paramInt2), this.b);
    }
  }
  
  static final class c<E>
    extends ForwardingListIterator<E>
  {
    private final ListIterator<E> a;
    private final nn<? super E> b;
    
    public c(ListIterator<E> paramListIterator, nn<? super E> paramnn)
    {
      this.a = paramListIterator;
      this.b = paramnn;
    }
    
    public final void add(E paramE)
    {
      this.b.a(paramE);
      this.a.add(paramE);
    }
    
    protected final ListIterator<E> delegate()
    {
      return this.a;
    }
    
    public final void set(E paramE)
    {
      this.b.a(paramE);
      this.a.set(paramE);
    }
  }
  
  static final class d<E>
    extends no.b<E>
    implements RandomAccess
  {
    d(List<E> paramList, nn<? super E> paramnn)
    {
      super(paramnn);
    }
  }
  
  static final class e<E>
    extends ForwardingSet<E>
  {
    private final Set<E> a;
    private final nn<? super E> b;
    
    public e(Set<E> paramSet, nn<? super E> paramnn)
    {
      this.a = ((Set)Preconditions.checkNotNull(paramSet));
      this.b = ((nn)Preconditions.checkNotNull(paramnn));
    }
    
    public final boolean add(E paramE)
    {
      this.b.a(paramE);
      return this.a.add(paramE);
    }
    
    public final boolean addAll(Collection<? extends E> paramCollection)
    {
      return this.a.addAll(no.b(paramCollection, this.b));
    }
    
    protected final Set<E> delegate()
    {
      return this.a;
    }
  }
  
  static final class f<E>
    extends ForwardingSortedSet<E>
  {
    final SortedSet<E> a;
    final nn<? super E> b;
    
    f(SortedSet<E> paramSortedSet, nn<? super E> paramnn)
    {
      this.a = ((SortedSet)Preconditions.checkNotNull(paramSortedSet));
      this.b = ((nn)Preconditions.checkNotNull(paramnn));
    }
    
    public final boolean add(E paramE)
    {
      this.b.a(paramE);
      return this.a.add(paramE);
    }
    
    public final boolean addAll(Collection<? extends E> paramCollection)
    {
      return this.a.addAll(no.b(paramCollection, this.b));
    }
    
    protected final SortedSet<E> delegate()
    {
      return this.a;
    }
    
    public final SortedSet<E> headSet(E paramE)
    {
      return no.a(this.a.headSet(paramE), this.b);
    }
    
    public final SortedSet<E> subSet(E paramE1, E paramE2)
    {
      return no.a(this.a.subSet(paramE1, paramE2), this.b);
    }
    
    public final SortedSet<E> tailSet(E paramE)
    {
      return no.a(this.a.tailSet(paramE), this.b);
    }
  }
}


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