package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.Set;
import javax.annotation.Nullable;
import ny;
import oo;
import os;
import pm;
import pw;

@GwtCompatible(emulated=true, serializable=true)
public abstract class ImmutableSet<E>
  extends ImmutableCollection<E>
  implements Set<E>
{
  @VisibleForTesting
  private static int a(int paramInt)
  {
    int j;
    if (paramInt < 751619276)
    {
      int i = Integer.highestOneBit(paramInt - 1) << 1;
      for (;;)
      {
        j = i;
        if (i * 0.7D >= paramInt) {
          break;
        }
        i <<= 1;
      }
    }
    if (paramInt < 1073741824) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "collection too large");
      j = 1073741824;
      return j;
    }
  }
  
  private static <E> ImmutableSet<E> b(int paramInt, Object... paramVarArgs)
  {
    int j = paramInt;
    int n;
    Object[] arrayOfObject;
    int i1;
    int k;
    int i;
    label50:
    Object localObject1;
    int m;
    label81:
    Object localObject2;
    switch (j)
    {
    default: 
      n = a(j);
      arrayOfObject = new Object[n];
      i1 = n - 1;
      k = 0;
      paramInt = 0;
      i = 0;
      if (k < j)
      {
        localObject1 = ObjectArrays.a(paramVarArgs[k], k);
        int i2 = localObject1.hashCode();
        m = oo.a(i2);
        int i3 = m & i1;
        localObject2 = arrayOfObject[i3];
        if (localObject2 == null)
        {
          m = paramInt + 1;
          paramVarArgs[paramInt] = localObject1;
          arrayOfObject[i3] = localObject1;
          i += i2;
          paramInt = m;
        }
      }
      break;
    }
    for (;;)
    {
      k += 1;
      break label50;
      return of();
      return of(paramVarArgs[0]);
      if (!localObject2.equals(localObject1))
      {
        m += 1;
        break label81;
        Arrays.fill(paramVarArgs, paramInt, j, null);
        if (paramInt == 1) {
          return new pw(paramVarArgs[0], i);
        }
        if (n != a(paramInt))
        {
          j = paramInt;
          break;
        }
        localObject1 = paramVarArgs;
        if (paramInt < paramVarArgs.length) {
          localObject1 = ObjectArrays.a(paramVarArgs, paramInt);
        }
        return new pm((Object[])localObject1, i, arrayOfObject, i1);
      }
    }
  }
  
  public static <E> Builder<E> builder()
  {
    return new Builder();
  }
  
  public static <E> ImmutableSet<E> copyOf(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof Collection)) {
      return copyOf((Collection)paramIterable);
    }
    return copyOf(paramIterable.iterator());
  }
  
  public static <E> ImmutableSet<E> copyOf(Collection<? extends E> paramCollection)
  {
    if (((paramCollection instanceof ImmutableSet)) && (!(paramCollection instanceof ImmutableSortedSet)))
    {
      ImmutableSet localImmutableSet = (ImmutableSet)paramCollection;
      if (!localImmutableSet.a()) {
        return localImmutableSet;
      }
    }
    else if ((paramCollection instanceof EnumSet))
    {
      return os.a(EnumSet.copyOf((EnumSet)paramCollection));
    }
    paramCollection = paramCollection.toArray();
    return b(paramCollection.length, paramCollection);
  }
  
  public static <E> ImmutableSet<E> copyOf(Iterator<? extends E> paramIterator)
  {
    if (!paramIterator.hasNext()) {
      return of();
    }
    Object localObject = paramIterator.next();
    if (!paramIterator.hasNext()) {
      return of(localObject);
    }
    return new Builder().add(localObject).addAll(paramIterator).build();
  }
  
  public static <E> ImmutableSet<E> copyOf(E[] paramArrayOfE)
  {
    switch (paramArrayOfE.length)
    {
    default: 
      return b(paramArrayOfE.length, (Object[])paramArrayOfE.clone());
    case 0: 
      return of();
    }
    return of(paramArrayOfE[0]);
  }
  
  public static <E> ImmutableSet<E> of()
  {
    return ny.a;
  }
  
  public static <E> ImmutableSet<E> of(E paramE)
  {
    return new pw(paramE);
  }
  
  public static <E> ImmutableSet<E> of(E paramE1, E paramE2)
  {
    return b(2, new Object[] { paramE1, paramE2 });
  }
  
  public static <E> ImmutableSet<E> of(E paramE1, E paramE2, E paramE3)
  {
    return b(3, new Object[] { paramE1, paramE2, paramE3 });
  }
  
  public static <E> ImmutableSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4)
  {
    return b(4, new Object[] { paramE1, paramE2, paramE3, paramE4 });
  }
  
  public static <E> ImmutableSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5)
  {
    return b(5, new Object[] { paramE1, paramE2, paramE3, paramE4, paramE5 });
  }
  
  public static <E> ImmutableSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5, E paramE6, E... paramVarArgs)
  {
    Object[] arrayOfObject = new Object[paramVarArgs.length + 6];
    arrayOfObject[0] = paramE1;
    arrayOfObject[1] = paramE2;
    arrayOfObject[2] = paramE3;
    arrayOfObject[3] = paramE4;
    arrayOfObject[4] = paramE5;
    arrayOfObject[5] = paramE6;
    System.arraycopy(paramVarArgs, 0, arrayOfObject, 6, paramVarArgs.length);
    return b(arrayOfObject.length, arrayOfObject);
  }
  
  protected boolean c_()
  {
    return false;
  }
  
  public boolean equals(@Nullable Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    if (((paramObject instanceof ImmutableSet)) && (c_()) && (((ImmutableSet)paramObject).c_()) && (hashCode() != paramObject.hashCode())) {
      return false;
    }
    return Sets.a(this, paramObject);
  }
  
  public int hashCode()
  {
    return Sets.a(this);
  }
  
  public abstract UnmodifiableIterator<E> iterator();
  
  public Object writeReplace()
  {
    return new a(toArray());
  }
  
  public static class Builder<E>
    extends ImmutableCollection.a<E>
  {
    public Builder()
    {
      this((byte)0);
    }
    
    private Builder(byte paramByte)
    {
      super();
    }
    
    public Builder<E> add(E paramE)
    {
      super.add(paramE);
      return this;
    }
    
    public Builder<E> add(E... paramVarArgs)
    {
      super.add(paramVarArgs);
      return this;
    }
    
    public Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      super.addAll(paramIterable);
      return this;
    }
    
    public Builder<E> addAll(Iterator<? extends E> paramIterator)
    {
      super.addAll(paramIterator);
      return this;
    }
    
    public ImmutableSet<E> build()
    {
      ImmutableSet localImmutableSet = ImmutableSet.a(this.b, this.a);
      this.b = localImmutableSet.size();
      return localImmutableSet;
    }
  }
  
  static final class a
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Object[] a;
    
    a(Object[] paramArrayOfObject)
    {
      this.a = paramArrayOfObject;
    }
    
    final Object readResolve()
    {
      return ImmutableSet.copyOf(this.a);
    }
  }
}


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