package com.google.common.primitives;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.RandomAccess;

@GwtCompatible
public final class Bytes
{
  public static List<Byte> asList(byte... paramVarArgs)
  {
    if (paramVarArgs.length == 0) {
      return Collections.emptyList();
    }
    return new a(paramVarArgs);
  }
  
  private static int c(byte[] paramArrayOfByte, byte paramByte, int paramInt1, int paramInt2)
  {
    while (paramInt1 < paramInt2)
    {
      if (paramArrayOfByte[paramInt1] == paramByte) {
        return paramInt1;
      }
      paramInt1 += 1;
    }
    return -1;
  }
  
  public static byte[] concat(byte[]... paramVarArgs)
  {
    int k = paramVarArgs.length;
    int i = 0;
    int j = 0;
    while (i < k)
    {
      j += paramVarArgs[i].length;
      i += 1;
    }
    byte[] arrayOfByte1 = new byte[j];
    k = paramVarArgs.length;
    j = 0;
    i = 0;
    while (i < k)
    {
      byte[] arrayOfByte2 = paramVarArgs[i];
      System.arraycopy(arrayOfByte2, 0, arrayOfByte1, j, arrayOfByte2.length);
      j += arrayOfByte2.length;
      i += 1;
    }
    return arrayOfByte1;
  }
  
  public static boolean contains(byte[] paramArrayOfByte, byte paramByte)
  {
    boolean bool2 = false;
    int j = paramArrayOfByte.length;
    int i = 0;
    for (;;)
    {
      boolean bool1 = bool2;
      if (i < j)
      {
        if (paramArrayOfByte[i] == paramByte) {
          bool1 = true;
        }
      }
      else {
        return bool1;
      }
      i += 1;
    }
  }
  
  private static int d(byte[] paramArrayOfByte, byte paramByte, int paramInt1, int paramInt2)
  {
    paramInt2 -= 1;
    while (paramInt2 >= paramInt1)
    {
      if (paramArrayOfByte[paramInt2] == paramByte) {
        return paramInt2;
      }
      paramInt2 -= 1;
    }
    return -1;
  }
  
  public static byte[] ensureCapacity(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    if (paramInt1 >= 0)
    {
      bool = true;
      Preconditions.checkArgument(bool, "Invalid minLength: %s", new Object[] { Integer.valueOf(paramInt1) });
      if (paramInt2 < 0) {
        break label86;
      }
    }
    label86:
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Invalid padding: %s", new Object[] { Integer.valueOf(paramInt2) });
      byte[] arrayOfByte = paramArrayOfByte;
      if (paramArrayOfByte.length < paramInt1)
      {
        paramInt1 += paramInt2;
        arrayOfByte = new byte[paramInt1];
        System.arraycopy(paramArrayOfByte, 0, arrayOfByte, 0, Math.min(paramArrayOfByte.length, paramInt1));
      }
      return arrayOfByte;
      bool = false;
      break;
    }
  }
  
  public static int hashCode(byte paramByte)
  {
    return paramByte;
  }
  
  public static int indexOf(byte[] paramArrayOfByte, byte paramByte)
  {
    return c(paramArrayOfByte, paramByte, 0, paramArrayOfByte.length);
  }
  
  public static int indexOf(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2)
  {
    Preconditions.checkNotNull(paramArrayOfByte1, "array");
    Preconditions.checkNotNull(paramArrayOfByte2, "target");
    if (paramArrayOfByte2.length == 0) {
      return 0;
    }
    int i = 0;
    while (i < paramArrayOfByte1.length - paramArrayOfByte2.length + 1)
    {
      int j = 0;
      while (j < paramArrayOfByte2.length)
      {
        if (paramArrayOfByte1[(i + j)] != paramArrayOfByte2[j]) {
          break label62;
        }
        j += 1;
      }
      return i;
      label62:
      i += 1;
    }
    return -1;
  }
  
  public static int lastIndexOf(byte[] paramArrayOfByte, byte paramByte)
  {
    return d(paramArrayOfByte, paramByte, 0, paramArrayOfByte.length);
  }
  
  public static byte[] toArray(Collection<? extends Number> paramCollection)
  {
    int i = 0;
    if ((paramCollection instanceof a))
    {
      paramCollection = (a)paramCollection;
      i = paramCollection.size();
      arrayOfByte = new byte[i];
      System.arraycopy(paramCollection.a, paramCollection.b, arrayOfByte, 0, i);
      return arrayOfByte;
    }
    paramCollection = paramCollection.toArray();
    int j = paramCollection.length;
    byte[] arrayOfByte = new byte[j];
    while (i < j)
    {
      arrayOfByte[i] = ((Number)Preconditions.checkNotNull(paramCollection[i])).byteValue();
      i += 1;
    }
    return arrayOfByte;
  }
  
  @GwtCompatible
  static final class a
    extends AbstractList<Byte>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final byte[] a;
    final int b;
    final int c;
    
    a(byte[] paramArrayOfByte)
    {
      this(paramArrayOfByte, 0, paramArrayOfByte.length);
    }
    
    private a(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
    {
      this.a = paramArrayOfByte;
      this.b = paramInt1;
      this.c = paramInt2;
    }
    
    public final boolean contains(Object paramObject)
    {
      return ((paramObject instanceof Byte)) && (Bytes.a(this.a, ((Byte)paramObject).byteValue(), this.b, this.c) != -1);
    }
    
    public final boolean equals(Object paramObject)
    {
      if (paramObject == this) {}
      for (;;)
      {
        return true;
        if (!(paramObject instanceof a)) {
          break;
        }
        paramObject = (a)paramObject;
        int j = size();
        if (((a)paramObject).size() != j) {
          return false;
        }
        int i = 0;
        while (i < j)
        {
          if (this.a[(this.b + i)] != paramObject.a[(paramObject.b + i)]) {
            return false;
          }
          i += 1;
        }
      }
      return super.equals(paramObject);
    }
    
    public final int hashCode()
    {
      int j = 1;
      int i = this.b;
      while (i < this.c)
      {
        j = j * 31 + Bytes.hashCode(this.a[i]);
        i += 1;
      }
      return j;
    }
    
    public final int indexOf(Object paramObject)
    {
      if ((paramObject instanceof Byte))
      {
        int i = Bytes.a(this.a, ((Byte)paramObject).byteValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final int lastIndexOf(Object paramObject)
    {
      if ((paramObject instanceof Byte))
      {
        int i = Bytes.b(this.a, ((Byte)paramObject).byteValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final int size()
    {
      return this.c - this.b;
    }
    
    public final List<Byte> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      if (paramInt1 == paramInt2) {
        return Collections.emptyList();
      }
      return new a(this.a, this.b + paramInt1, this.b + paramInt2);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder(size() * 5);
      localStringBuilder.append('[').append(this.a[this.b]);
      int i = this.b + 1;
      while (i < this.c)
      {
        localStringBuilder.append(", ").append(this.a[i]);
        i += 1;
      }
      return ']';
    }
  }
}


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