package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import java.io.Serializable;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.annotation.Nullable;
import ms;
import ni;
import os;
import qf;

@GwtCompatible(emulated=true)
public final class Sets
{
  public static int a(Set<?> paramSet)
  {
    paramSet = paramSet.iterator();
    int i = 0;
    if (paramSet.hasNext())
    {
      Object localObject = paramSet.next();
      if (localObject != null) {}
      for (int j = localObject.hashCode();; j = 0)
      {
        i = i + j ^ 0xFFFFFFFF ^ 0xFFFFFFFF;
        break;
      }
    }
    return i;
  }
  
  private static <E extends Enum<E>> EnumSet<E> a(Collection<E> paramCollection, Class<E> paramClass)
  {
    paramClass = EnumSet.allOf(paramClass);
    paramClass.removeAll(paramCollection);
    return paramClass;
  }
  
  public static boolean a(Set<?> paramSet, @Nullable Object paramObject)
  {
    if (paramSet == paramObject) {}
    for (;;)
    {
      return true;
      if ((paramObject instanceof Set))
      {
        paramObject = (Set)paramObject;
        try
        {
          if (paramSet.size() == ((Set)paramObject).size())
          {
            boolean bool = paramSet.containsAll((Collection)paramObject);
            if (bool) {}
          }
          else
          {
            return false;
          }
        }
        catch (NullPointerException paramSet)
        {
          return false;
        }
        catch (ClassCastException paramSet)
        {
          return false;
        }
      }
    }
    return false;
  }
  
  public static boolean a(Set<?> paramSet, Collection<?> paramCollection)
  {
    Preconditions.checkNotNull(paramCollection);
    Object localObject = paramCollection;
    if ((paramCollection instanceof Multiset)) {
      localObject = ((Multiset)paramCollection).elementSet();
    }
    if (((localObject instanceof Set)) && (((Collection)localObject).size() > paramSet.size())) {
      return Iterators.removeAll(paramSet.iterator(), (Collection)localObject);
    }
    return a(paramSet, ((Collection)localObject).iterator());
  }
  
  public static boolean a(Set<?> paramSet, Iterator<?> paramIterator)
  {
    boolean bool = false;
    while (paramIterator.hasNext()) {
      bool |= paramSet.remove(paramIterator.next());
    }
    return bool;
  }
  
  public static <B> Set<List<B>> cartesianProduct(List<? extends Set<? extends B>> paramList)
  {
    return a.a(paramList);
  }
  
  public static <B> Set<List<B>> cartesianProduct(Set<? extends B>... paramVarArgs)
  {
    return cartesianProduct(Arrays.asList(paramVarArgs));
  }
  
  public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> paramCollection)
  {
    if ((paramCollection instanceof EnumSet)) {
      return EnumSet.complementOf((EnumSet)paramCollection);
    }
    if (!paramCollection.isEmpty()) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "collection is empty; use the other version of this method");
      return a(paramCollection, ((Enum)paramCollection.iterator().next()).getDeclaringClass());
    }
  }
  
  public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> paramCollection, Class<E> paramClass)
  {
    Preconditions.checkNotNull(paramCollection);
    if ((paramCollection instanceof EnumSet)) {
      return EnumSet.complementOf((EnumSet)paramCollection);
    }
    return a(paramCollection, paramClass);
  }
  
  public static <E> SetView<E> difference(Set<E> paramSet, final Set<?> paramSet1)
  {
    Preconditions.checkNotNull(paramSet, "set1");
    Preconditions.checkNotNull(paramSet1, "set2");
    new SetView(paramSet)
    {
      public final boolean contains(Object paramAnonymousObject)
      {
        return (this.a.contains(paramAnonymousObject)) && (!paramSet1.contains(paramAnonymousObject));
      }
      
      public final boolean isEmpty()
      {
        return paramSet1.containsAll(this.a);
      }
      
      public final Iterator<E> iterator()
      {
        return Iterators.filter(this.a.iterator(), this.b);
      }
      
      public final int size()
      {
        return Iterators.size(iterator());
      }
    };
  }
  
  @GwtIncompatible("NavigableSet")
  public static <E> NavigableSet<E> filter(NavigableSet<E> paramNavigableSet, Predicate<? super E> paramPredicate)
  {
    if ((paramNavigableSet instanceof d))
    {
      paramNavigableSet = (d)paramNavigableSet;
      paramPredicate = Predicates.and(paramNavigableSet.b, paramPredicate);
      return new c((NavigableSet)paramNavigableSet.a, paramPredicate);
    }
    return new c((NavigableSet)Preconditions.checkNotNull(paramNavigableSet), (Predicate)Preconditions.checkNotNull(paramPredicate));
  }
  
  public static <E> Set<E> filter(Set<E> paramSet, Predicate<? super E> paramPredicate)
  {
    if ((paramSet instanceof SortedSet)) {
      return filter((SortedSet)paramSet, paramPredicate);
    }
    if ((paramSet instanceof d))
    {
      paramSet = (d)paramSet;
      paramPredicate = Predicates.and(paramSet.b, paramPredicate);
      return new d((Set)paramSet.a, paramPredicate);
    }
    return new d((Set)Preconditions.checkNotNull(paramSet), (Predicate)Preconditions.checkNotNull(paramPredicate));
  }
  
  public static <E> SortedSet<E> filter(SortedSet<E> paramSortedSet, Predicate<? super E> paramPredicate)
  {
    if ((paramSortedSet instanceof NavigableSet)) {
      return filter((NavigableSet)paramSortedSet, paramPredicate);
    }
    if ((paramSortedSet instanceof d))
    {
      paramSortedSet = (d)paramSortedSet;
      paramPredicate = Predicates.and(paramSortedSet.b, paramPredicate);
      return new e((SortedSet)paramSortedSet.a, paramPredicate);
    }
    return new e((SortedSet)Preconditions.checkNotNull(paramSortedSet), (Predicate)Preconditions.checkNotNull(paramPredicate));
  }
  
  @GwtCompatible(serializable=true)
  public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(E paramE, E... paramVarArgs)
  {
    return os.a(EnumSet.of(paramE, paramVarArgs));
  }
  
  @GwtCompatible(serializable=true)
  public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(Iterable<E> paramIterable)
  {
    if ((paramIterable instanceof os)) {
      return (os)paramIterable;
    }
    if ((paramIterable instanceof Collection))
    {
      paramIterable = (Collection)paramIterable;
      if (paramIterable.isEmpty()) {
        return ImmutableSet.of();
      }
      return os.a(EnumSet.copyOf(paramIterable));
    }
    paramIterable = paramIterable.iterator();
    if (paramIterable.hasNext())
    {
      EnumSet localEnumSet = EnumSet.of((Enum)paramIterable.next());
      Iterators.addAll(localEnumSet, paramIterable);
      return os.a(localEnumSet);
    }
    return ImmutableSet.of();
  }
  
  public static <E> SetView<E> intersection(Set<E> paramSet, final Set<?> paramSet1)
  {
    Preconditions.checkNotNull(paramSet, "set1");
    Preconditions.checkNotNull(paramSet1, "set2");
    new SetView(paramSet)
    {
      public final boolean contains(Object paramAnonymousObject)
      {
        return (this.a.contains(paramAnonymousObject)) && (paramSet1.contains(paramAnonymousObject));
      }
      
      public final boolean containsAll(Collection<?> paramAnonymousCollection)
      {
        return (this.a.containsAll(paramAnonymousCollection)) && (paramSet1.containsAll(paramAnonymousCollection));
      }
      
      public final boolean isEmpty()
      {
        return !iterator().hasNext();
      }
      
      public final Iterator<E> iterator()
      {
        return Iterators.filter(this.a.iterator(), this.b);
      }
      
      public final int size()
      {
        return Iterators.size(iterator());
      }
    };
  }
  
  public static <E> Set<E> newConcurrentHashSet()
  {
    return newSetFromMap(new ConcurrentHashMap());
  }
  
  public static <E> Set<E> newConcurrentHashSet(Iterable<? extends E> paramIterable)
  {
    Set localSet = newConcurrentHashSet();
    Iterables.addAll(localSet, paramIterable);
    return localSet;
  }
  
  @GwtIncompatible("CopyOnWriteArraySet")
  public static <E> CopyOnWriteArraySet<E> newCopyOnWriteArraySet()
  {
    return new CopyOnWriteArraySet();
  }
  
  @GwtIncompatible("CopyOnWriteArraySet")
  public static <E> CopyOnWriteArraySet<E> newCopyOnWriteArraySet(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof Collection)) {}
    for (paramIterable = Collections2.a(paramIterable);; paramIterable = Lists.newArrayList(paramIterable)) {
      return new CopyOnWriteArraySet(paramIterable);
    }
  }
  
  public static <E extends Enum<E>> EnumSet<E> newEnumSet(Iterable<E> paramIterable, Class<E> paramClass)
  {
    paramClass = EnumSet.noneOf(paramClass);
    Iterables.addAll(paramClass, paramIterable);
    return paramClass;
  }
  
  public static <E> HashSet<E> newHashSet()
  {
    return new HashSet();
  }
  
  public static <E> HashSet<E> newHashSet(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof Collection)) {
      return new HashSet(Collections2.a(paramIterable));
    }
    return newHashSet(paramIterable.iterator());
  }
  
  public static <E> HashSet<E> newHashSet(Iterator<? extends E> paramIterator)
  {
    HashSet localHashSet = newHashSet();
    Iterators.addAll(localHashSet, paramIterator);
    return localHashSet;
  }
  
  public static <E> HashSet<E> newHashSet(E... paramVarArgs)
  {
    HashSet localHashSet = newHashSetWithExpectedSize(paramVarArgs.length);
    Collections.addAll(localHashSet, paramVarArgs);
    return localHashSet;
  }
  
  public static <E> HashSet<E> newHashSetWithExpectedSize(int paramInt)
  {
    return new HashSet(Maps.a(paramInt));
  }
  
  public static <E> Set<E> newIdentityHashSet()
  {
    return newSetFromMap(Maps.newIdentityHashMap());
  }
  
  public static <E> LinkedHashSet<E> newLinkedHashSet()
  {
    return new LinkedHashSet();
  }
  
  public static <E> LinkedHashSet<E> newLinkedHashSet(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof Collection)) {
      return new LinkedHashSet(Collections2.a(paramIterable));
    }
    LinkedHashSet localLinkedHashSet = newLinkedHashSet();
    Iterables.addAll(localLinkedHashSet, paramIterable);
    return localLinkedHashSet;
  }
  
  public static <E> LinkedHashSet<E> newLinkedHashSetWithExpectedSize(int paramInt)
  {
    return new LinkedHashSet(Maps.a(paramInt));
  }
  
  public static <E> Set<E> newSetFromMap(Map<E, Boolean> paramMap)
  {
    return Collections.newSetFromMap(paramMap);
  }
  
  public static <E extends Comparable> TreeSet<E> newTreeSet()
  {
    return new TreeSet();
  }
  
  public static <E extends Comparable> TreeSet<E> newTreeSet(Iterable<? extends E> paramIterable)
  {
    TreeSet localTreeSet = newTreeSet();
    Iterables.addAll(localTreeSet, paramIterable);
    return localTreeSet;
  }
  
  public static <E> TreeSet<E> newTreeSet(Comparator<? super E> paramComparator)
  {
    return new TreeSet((Comparator)Preconditions.checkNotNull(paramComparator));
  }
  
  @GwtCompatible(serializable=false)
  public static <E> Set<Set<E>> powerSet(Set<E> paramSet)
  {
    return new g(paramSet);
  }
  
  public static <E> SetView<E> symmetricDifference(Set<? extends E> paramSet1, Set<? extends E> paramSet2)
  {
    Preconditions.checkNotNull(paramSet1, "set1");
    Preconditions.checkNotNull(paramSet2, "set2");
    return difference(union(paramSet1, paramSet2), intersection(paramSet1, paramSet2));
  }
  
  @GwtIncompatible("NavigableSet")
  public static <E> NavigableSet<E> synchronizedNavigableSet(NavigableSet<E> paramNavigableSet)
  {
    return qf.a(paramNavigableSet, null);
  }
  
  public static <E> SetView<E> union(Set<? extends E> paramSet1, final Set<? extends E> paramSet2)
  {
    Preconditions.checkNotNull(paramSet1, "set1");
    Preconditions.checkNotNull(paramSet2, "set2");
    new SetView(paramSet1)
    {
      public final boolean contains(Object paramAnonymousObject)
      {
        return (this.a.contains(paramAnonymousObject)) || (paramSet2.contains(paramAnonymousObject));
      }
      
      public final <S extends Set<E>> S copyInto(S paramAnonymousS)
      {
        paramAnonymousS.addAll(this.a);
        paramAnonymousS.addAll(paramSet2);
        return paramAnonymousS;
      }
      
      public final ImmutableSet<E> immutableCopy()
      {
        return new ImmutableSet.Builder().addAll(this.a).addAll(paramSet2).build();
      }
      
      public final boolean isEmpty()
      {
        return (this.a.isEmpty()) && (paramSet2.isEmpty());
      }
      
      public final Iterator<E> iterator()
      {
        return Iterators.unmodifiableIterator(Iterators.concat(this.a.iterator(), this.b.iterator()));
      }
      
      public final int size()
      {
        return this.a.size() + this.b.size();
      }
    };
  }
  
  @GwtIncompatible("NavigableSet")
  public static <E> NavigableSet<E> unmodifiableNavigableSet(NavigableSet<E> paramNavigableSet)
  {
    if (((paramNavigableSet instanceof ImmutableSortedSet)) || ((paramNavigableSet instanceof i))) {
      return paramNavigableSet;
    }
    return new i(paramNavigableSet);
  }
  
  public static abstract class SetView<E>
    extends AbstractSet<E>
  {
    public <S extends Set<E>> S copyInto(S paramS)
    {
      paramS.addAll(this);
      return paramS;
    }
    
    public ImmutableSet<E> immutableCopy()
    {
      return ImmutableSet.copyOf(this);
    }
  }
  
  static final class a<E>
    extends ForwardingCollection<List<E>>
    implements Set<List<E>>
  {
    private final transient ImmutableList<ImmutableSet<E>> a;
    private final transient ni<E> b;
    
    private a(ImmutableList<ImmutableSet<E>> paramImmutableList, ni<E> paramni)
    {
      this.a = paramImmutableList;
      this.b = paramni;
    }
    
    static <E> Set<List<E>> a(List<? extends Set<? extends E>> paramList)
    {
      ImmutableList.Builder localBuilder = new ImmutableList.Builder(paramList.size());
      paramList = paramList.iterator();
      while (paramList.hasNext())
      {
        ImmutableSet localImmutableSet = ImmutableSet.copyOf((Set)paramList.next());
        if (localImmutableSet.isEmpty()) {
          return ImmutableSet.of();
        }
        localBuilder.add(localImmutableSet);
      }
      paramList = localBuilder.build();
      new a(paramList, new ni(new ImmutableList()
      {
        final boolean a()
        {
          return true;
        }
        
        public final int size()
        {
          return this.a.size();
        }
      }));
    }
    
    protected final Collection<List<E>> delegate()
    {
      return this.b;
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      if ((paramObject instanceof a))
      {
        paramObject = (a)paramObject;
        return this.a.equals(((a)paramObject).a);
      }
      return super.equals(paramObject);
    }
    
    public final int hashCode()
    {
      int i = size() - 1;
      int j = 0;
      while (j < this.a.size())
      {
        i = i * 31 ^ 0xFFFFFFFF ^ 0xFFFFFFFF;
        j += 1;
      }
      Iterator localIterator = this.a.iterator();
      Set localSet;
      int k;
      for (j = 1; localIterator.hasNext(); j = localSet.hashCode() * k + j * 31 ^ 0xFFFFFFFF ^ 0xFFFFFFFF)
      {
        localSet = (Set)localIterator.next();
        k = size() / localSet.size();
      }
      return j + i ^ 0xFFFFFFFF ^ 0xFFFFFFFF;
    }
  }
  
  @GwtIncompatible("NavigableSet")
  static class b<E>
    extends ForwardingNavigableSet<E>
  {
    private final NavigableSet<E> a;
    
    b(NavigableSet<E> paramNavigableSet)
    {
      this.a = paramNavigableSet;
    }
    
    public E ceiling(E paramE)
    {
      return (E)this.a.floor(paramE);
    }
    
    public Comparator<? super E> comparator()
    {
      Comparator localComparator = this.a.comparator();
      if (localComparator == null) {
        return Ordering.natural().reverse();
      }
      return Ordering.from(localComparator).reverse();
    }
    
    protected NavigableSet<E> delegate()
    {
      return this.a;
    }
    
    public Iterator<E> descendingIterator()
    {
      return this.a.iterator();
    }
    
    public NavigableSet<E> descendingSet()
    {
      return this.a;
    }
    
    public E first()
    {
      return (E)this.a.last();
    }
    
    public E floor(E paramE)
    {
      return (E)this.a.ceiling(paramE);
    }
    
    public NavigableSet<E> headSet(E paramE, boolean paramBoolean)
    {
      return this.a.tailSet(paramE, paramBoolean).descendingSet();
    }
    
    public SortedSet<E> headSet(E paramE)
    {
      return standardHeadSet(paramE);
    }
    
    public E higher(E paramE)
    {
      return (E)this.a.lower(paramE);
    }
    
    public Iterator<E> iterator()
    {
      return this.a.descendingIterator();
    }
    
    public E last()
    {
      return (E)this.a.first();
    }
    
    public E lower(E paramE)
    {
      return (E)this.a.higher(paramE);
    }
    
    public E pollFirst()
    {
      return (E)this.a.pollLast();
    }
    
    public E pollLast()
    {
      return (E)this.a.pollFirst();
    }
    
    public NavigableSet<E> subSet(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2)
    {
      return this.a.subSet(paramE2, paramBoolean2, paramE1, paramBoolean1).descendingSet();
    }
    
    public SortedSet<E> subSet(E paramE1, E paramE2)
    {
      return standardSubSet(paramE1, paramE2);
    }
    
    public NavigableSet<E> tailSet(E paramE, boolean paramBoolean)
    {
      return this.a.headSet(paramE, paramBoolean).descendingSet();
    }
    
    public SortedSet<E> tailSet(E paramE)
    {
      return standardTailSet(paramE);
    }
    
    public Object[] toArray()
    {
      return standardToArray();
    }
    
    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return standardToArray(paramArrayOfT);
    }
    
    public String toString()
    {
      return standardToString();
    }
  }
  
  @GwtIncompatible("NavigableSet")
  static final class c<E>
    extends Sets.e<E>
    implements NavigableSet<E>
  {
    c(NavigableSet<E> paramNavigableSet, Predicate<? super E> paramPredicate)
    {
      super(paramPredicate);
    }
    
    public final E ceiling(E paramE)
    {
      return (E)Iterables.getFirst(tailSet(paramE, true), null);
    }
    
    public final Iterator<E> descendingIterator()
    {
      return Iterators.filter(((NavigableSet)this.a).descendingIterator(), this.b);
    }
    
    public final NavigableSet<E> descendingSet()
    {
      return Sets.filter(((NavigableSet)this.a).descendingSet(), this.b);
    }
    
    @Nullable
    public final E floor(E paramE)
    {
      return (E)Iterators.getNext(headSet(paramE, true).descendingIterator(), null);
    }
    
    public final NavigableSet<E> headSet(E paramE, boolean paramBoolean)
    {
      return Sets.filter(((NavigableSet)this.a).headSet(paramE, paramBoolean), this.b);
    }
    
    public final E higher(E paramE)
    {
      return (E)Iterables.getFirst(tailSet(paramE, false), null);
    }
    
    public final E last()
    {
      return (E)descendingIterator().next();
    }
    
    @Nullable
    public final E lower(E paramE)
    {
      return (E)Iterators.getNext(headSet(paramE, false).descendingIterator(), null);
    }
    
    public final E pollFirst()
    {
      return (E)Iterables.a((NavigableSet)this.a, this.b);
    }
    
    public final E pollLast()
    {
      return (E)Iterables.a(((NavigableSet)this.a).descendingSet(), this.b);
    }
    
    public final NavigableSet<E> subSet(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2)
    {
      return Sets.filter(((NavigableSet)this.a).subSet(paramE1, paramBoolean1, paramE2, paramBoolean2), this.b);
    }
    
    public final NavigableSet<E> tailSet(E paramE, boolean paramBoolean)
    {
      return Sets.filter(((NavigableSet)this.a).tailSet(paramE, paramBoolean), this.b);
    }
  }
  
  static class d<E>
    extends Collections2.a<E>
    implements Set<E>
  {
    d(Set<E> paramSet, Predicate<? super E> paramPredicate)
    {
      super(paramPredicate);
    }
    
    public boolean equals(@Nullable Object paramObject)
    {
      return Sets.a(this, paramObject);
    }
    
    public int hashCode()
    {
      return Sets.a(this);
    }
  }
  
  static class e<E>
    extends Sets.d<E>
    implements SortedSet<E>
  {
    e(SortedSet<E> paramSortedSet, Predicate<? super E> paramPredicate)
    {
      super(paramPredicate);
    }
    
    public Comparator<? super E> comparator()
    {
      return ((SortedSet)this.a).comparator();
    }
    
    public E first()
    {
      return (E)iterator().next();
    }
    
    public SortedSet<E> headSet(E paramE)
    {
      return new e(((SortedSet)this.a).headSet(paramE), this.b);
    }
    
    public E last()
    {
      Object localObject;
      for (SortedSet localSortedSet = (SortedSet)this.a;; localSortedSet = localSortedSet.headSet(localObject))
      {
        localObject = localSortedSet.last();
        if (this.b.apply(localObject)) {
          return (E)localObject;
        }
      }
    }
    
    public SortedSet<E> subSet(E paramE1, E paramE2)
    {
      return new e(((SortedSet)this.a).subSet(paramE1, paramE2), this.b);
    }
    
    public SortedSet<E> tailSet(E paramE)
    {
      return new e(((SortedSet)this.a).tailSet(paramE), this.b);
    }
  }
  
  public static abstract class f<E>
    extends AbstractSet<E>
  {
    public boolean removeAll(Collection<?> paramCollection)
    {
      return Sets.a(this, paramCollection);
    }
    
    public boolean retainAll(Collection<?> paramCollection)
    {
      return super.retainAll((Collection)Preconditions.checkNotNull(paramCollection));
    }
  }
  
  static final class g<E>
    extends AbstractSet<Set<E>>
  {
    final ImmutableMap<E, Integer> a;
    
    g(Set<E> paramSet)
    {
      ImmutableMap.Builder localBuilder = ImmutableMap.builder();
      paramSet = ((Set)Preconditions.checkNotNull(paramSet)).iterator();
      int i = 0;
      while (paramSet.hasNext())
      {
        localBuilder.put(paramSet.next(), Integer.valueOf(i));
        i += 1;
      }
      this.a = localBuilder.build();
      if (this.a.size() <= 30) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "Too many elements to create power set: %s > 30", new Object[] { Integer.valueOf(this.a.size()) });
        return;
      }
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Set))
      {
        paramObject = (Set)paramObject;
        return this.a.keySet().containsAll((Collection)paramObject);
      }
      return false;
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      if ((paramObject instanceof g))
      {
        paramObject = (g)paramObject;
        return this.a.equals(((g)paramObject).a);
      }
      return super.equals(paramObject);
    }
    
    public final int hashCode()
    {
      return this.a.keySet().hashCode() << this.a.size() - 1;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final Iterator<Set<E>> iterator()
    {
      new ms(size()) {};
    }
    
    public final int size()
    {
      return 1 << this.a.size();
    }
    
    public final String toString()
    {
      String str = String.valueOf(String.valueOf(this.a));
      return str.length() + 10 + "powerSet(" + str + ")";
    }
  }
  
  static final class h<E>
    extends AbstractSet<E>
  {
    private final ImmutableMap<E, Integer> a;
    private final int b;
    
    h(ImmutableMap<E, Integer> paramImmutableMap, int paramInt)
    {
      this.a = paramImmutableMap;
      this.b = paramInt;
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      paramObject = (Integer)this.a.get(paramObject);
      if (paramObject != null)
      {
        int i = this.b;
        if ((1 << ((Integer)paramObject).intValue() & i) != 0) {
          return true;
        }
      }
      return false;
    }
    
    public final Iterator<E> iterator()
    {
      new UnmodifiableIterator()
      {
        final ImmutableList<E> a = Sets.h.a(Sets.h.this).keySet().asList();
        int b = Sets.h.b(Sets.h.this);
        
        public final boolean hasNext()
        {
          return this.b != 0;
        }
        
        public final E next()
        {
          int i = Integer.numberOfTrailingZeros(this.b);
          if (i == 32) {
            throw new NoSuchElementException();
          }
          this.b &= (1 << i ^ 0xFFFFFFFF);
          return (E)this.a.get(i);
        }
      };
    }
    
    public final int size()
    {
      return Integer.bitCount(this.b);
    }
  }
  
  @GwtIncompatible("NavigableSet")
  static final class i<E>
    extends ForwardingSortedSet<E>
    implements Serializable, NavigableSet<E>
  {
    private static final long serialVersionUID = 0L;
    private final NavigableSet<E> a;
    private transient i<E> b;
    
    i(NavigableSet<E> paramNavigableSet)
    {
      this.a = ((NavigableSet)Preconditions.checkNotNull(paramNavigableSet));
    }
    
    public final E ceiling(E paramE)
    {
      return (E)this.a.ceiling(paramE);
    }
    
    protected final SortedSet<E> delegate()
    {
      return Collections.unmodifiableSortedSet(this.a);
    }
    
    public final Iterator<E> descendingIterator()
    {
      return Iterators.unmodifiableIterator(this.a.descendingIterator());
    }
    
    public final NavigableSet<E> descendingSet()
    {
      i locali2 = this.b;
      i locali1 = locali2;
      if (locali2 == null)
      {
        locali1 = new i(this.a.descendingSet());
        this.b = locali1;
        locali1.b = this;
      }
      return locali1;
    }
    
    public final E floor(E paramE)
    {
      return (E)this.a.floor(paramE);
    }
    
    public final NavigableSet<E> headSet(E paramE, boolean paramBoolean)
    {
      return Sets.unmodifiableNavigableSet(this.a.headSet(paramE, paramBoolean));
    }
    
    public final E higher(E paramE)
    {
      return (E)this.a.higher(paramE);
    }
    
    public final E lower(E paramE)
    {
      return (E)this.a.lower(paramE);
    }
    
    public final E pollFirst()
    {
      throw new UnsupportedOperationException();
    }
    
    public final E pollLast()
    {
      throw new UnsupportedOperationException();
    }
    
    public final NavigableSet<E> subSet(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2)
    {
      return Sets.unmodifiableNavigableSet(this.a.subSet(paramE1, paramBoolean1, paramE2, paramBoolean2));
    }
    
    public final NavigableSet<E> tailSet(E paramE, boolean paramBoolean)
    {
      return Sets.unmodifiableNavigableSet(this.a.tailSet(paramE, paramBoolean));
    }
  }
}


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