package com.google.common.primitives;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Converter;
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.Comparator;
import java.util.List;
import java.util.RandomAccess;

@GwtCompatible
public final class Longs
{
  public static final int BYTES = 8;
  public static final long MAX_POWER_OF_TWO = 4611686018427387904L;
  
  public static List<Long> asList(long... paramVarArgs)
  {
    if (paramVarArgs.length == 0) {
      return Collections.emptyList();
    }
    return new b(paramVarArgs);
  }
  
  private static int c(long[] paramArrayOfLong, long paramLong, int paramInt1, int paramInt2)
  {
    while (paramInt1 < paramInt2)
    {
      if (paramArrayOfLong[paramInt1] == paramLong) {
        return paramInt1;
      }
      paramInt1 += 1;
    }
    return -1;
  }
  
  public static int compare(long paramLong1, long paramLong2)
  {
    if (paramLong1 < paramLong2) {
      return -1;
    }
    if (paramLong1 > paramLong2) {
      return 1;
    }
    return 0;
  }
  
  public static long[] concat(long[]... paramVarArgs)
  {
    int k = paramVarArgs.length;
    int i = 0;
    int j = 0;
    while (i < k)
    {
      j += paramVarArgs[i].length;
      i += 1;
    }
    long[] arrayOfLong1 = new long[j];
    k = paramVarArgs.length;
    j = 0;
    i = 0;
    while (i < k)
    {
      long[] arrayOfLong2 = paramVarArgs[i];
      System.arraycopy(arrayOfLong2, 0, arrayOfLong1, j, arrayOfLong2.length);
      j += arrayOfLong2.length;
      i += 1;
    }
    return arrayOfLong1;
  }
  
  public static boolean contains(long[] paramArrayOfLong, long paramLong)
  {
    boolean bool2 = false;
    int j = paramArrayOfLong.length;
    int i = 0;
    for (;;)
    {
      boolean bool1 = bool2;
      if (i < j)
      {
        if (paramArrayOfLong[i] == paramLong) {
          bool1 = true;
        }
      }
      else {
        return bool1;
      }
      i += 1;
    }
  }
  
  private static int d(long[] paramArrayOfLong, long paramLong, int paramInt1, int paramInt2)
  {
    paramInt2 -= 1;
    while (paramInt2 >= paramInt1)
    {
      if (paramArrayOfLong[paramInt2] == paramLong) {
        return paramInt2;
      }
      paramInt2 -= 1;
    }
    return -1;
  }
  
  public static long[] ensureCapacity(long[] paramArrayOfLong, 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) });
      long[] arrayOfLong = paramArrayOfLong;
      if (paramArrayOfLong.length < paramInt1)
      {
        paramInt1 += paramInt2;
        arrayOfLong = new long[paramInt1];
        System.arraycopy(paramArrayOfLong, 0, arrayOfLong, 0, Math.min(paramArrayOfLong.length, paramInt1));
      }
      return arrayOfLong;
      bool = false;
      break;
    }
  }
  
  public static long fromByteArray(byte[] paramArrayOfByte)
  {
    if (paramArrayOfByte.length >= 8) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "array too small: %s < %s", new Object[] { Integer.valueOf(paramArrayOfByte.length), Integer.valueOf(8) });
      return fromBytes(paramArrayOfByte[0], paramArrayOfByte[1], paramArrayOfByte[2], paramArrayOfByte[3], paramArrayOfByte[4], paramArrayOfByte[5], paramArrayOfByte[6], paramArrayOfByte[7]);
    }
  }
  
  public static long fromBytes(byte paramByte1, byte paramByte2, byte paramByte3, byte paramByte4, byte paramByte5, byte paramByte6, byte paramByte7, byte paramByte8)
  {
    return (paramByte1 & 0xFF) << 56 | (paramByte2 & 0xFF) << 48 | (paramByte3 & 0xFF) << 40 | (paramByte4 & 0xFF) << 32 | (paramByte5 & 0xFF) << 24 | (paramByte6 & 0xFF) << 16 | (paramByte7 & 0xFF) << 8 | paramByte8 & 0xFF;
  }
  
  public static int hashCode(long paramLong)
  {
    return (int)(paramLong >>> 32 ^ paramLong);
  }
  
  public static int indexOf(long[] paramArrayOfLong, long paramLong)
  {
    return c(paramArrayOfLong, paramLong, 0, paramArrayOfLong.length);
  }
  
  public static int indexOf(long[] paramArrayOfLong1, long[] paramArrayOfLong2)
  {
    Preconditions.checkNotNull(paramArrayOfLong1, "array");
    Preconditions.checkNotNull(paramArrayOfLong2, "target");
    if (paramArrayOfLong2.length == 0) {
      return 0;
    }
    int i = 0;
    while (i < paramArrayOfLong1.length - paramArrayOfLong2.length + 1)
    {
      int j = 0;
      while (j < paramArrayOfLong2.length)
      {
        if (paramArrayOfLong1[(i + j)] != paramArrayOfLong2[j]) {
          break label63;
        }
        j += 1;
      }
      return i;
      label63:
      i += 1;
    }
    return -1;
  }
  
  public static String join(String paramString, long... paramVarArgs)
  {
    Preconditions.checkNotNull(paramString);
    if (paramVarArgs.length == 0) {
      return "";
    }
    StringBuilder localStringBuilder = new StringBuilder(paramVarArgs.length * 10);
    localStringBuilder.append(paramVarArgs[0]);
    int i = 1;
    while (i < paramVarArgs.length)
    {
      localStringBuilder.append(paramString).append(paramVarArgs[i]);
      i += 1;
    }
    return localStringBuilder.toString();
  }
  
  public static int lastIndexOf(long[] paramArrayOfLong, long paramLong)
  {
    return d(paramArrayOfLong, paramLong, 0, paramArrayOfLong.length);
  }
  
  public static Comparator<long[]> lexicographicalComparator()
  {
    return a.a;
  }
  
  public static long max(long... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    long l1;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      long l2;
      for (l1 = paramVarArgs[0]; i < paramVarArgs.length; l1 = l2)
      {
        l2 = l1;
        if (paramVarArgs[i] > l1) {
          l2 = paramVarArgs[i];
        }
        i += 1;
      }
    }
    return l1;
  }
  
  public static long min(long... paramVarArgs)
  {
    int i = 1;
    if (paramVarArgs.length > 0) {}
    long l1;
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      long l2;
      for (l1 = paramVarArgs[0]; i < paramVarArgs.length; l1 = l2)
      {
        l2 = l1;
        if (paramVarArgs[i] < l1) {
          l2 = paramVarArgs[i];
        }
        i += 1;
      }
    }
    return l1;
  }
  
  @Beta
  public static Converter<String, Long> stringConverter()
  {
    return c.a;
  }
  
  public static long[] toArray(Collection<? extends Number> paramCollection)
  {
    int i = 0;
    if ((paramCollection instanceof b))
    {
      paramCollection = (b)paramCollection;
      i = paramCollection.size();
      arrayOfLong = new long[i];
      System.arraycopy(paramCollection.a, paramCollection.b, arrayOfLong, 0, i);
      return arrayOfLong;
    }
    paramCollection = paramCollection.toArray();
    int j = paramCollection.length;
    long[] arrayOfLong = new long[j];
    while (i < j)
    {
      arrayOfLong[i] = ((Number)Preconditions.checkNotNull(paramCollection[i])).longValue();
      i += 1;
    }
    return arrayOfLong;
  }
  
  public static byte[] toByteArray(long paramLong)
  {
    byte[] arrayOfByte = new byte[8];
    int i = 7;
    while (i >= 0)
    {
      arrayOfByte[i] = ((byte)(int)(0xFF & paramLong));
      paramLong >>= 8;
      i -= 1;
    }
    return arrayOfByte;
  }
  
  @Beta
  public static Long tryParse(String paramString)
  {
    if (((String)Preconditions.checkNotNull(paramString)).isEmpty()) {
      return null;
    }
    int i;
    if (paramString.charAt(0) == '-')
    {
      i = 1;
      if (i == 0) {
        break label48;
      }
    }
    label48:
    for (int j = 1;; j = 0)
    {
      if (j != paramString.length()) {
        break label53;
      }
      return null;
      i = 0;
      break;
    }
    label53:
    int k = j + 1;
    j = paramString.charAt(j) - '0';
    if ((j < 0) || (j > 9)) {
      return null;
    }
    long l = -j;
    j = k;
    while (j < paramString.length())
    {
      k = paramString.charAt(j) - '0';
      if ((k < 0) || (k > 9) || (l < -922337203685477580L)) {
        return null;
      }
      l *= 10L;
      if (l < k - Long.MIN_VALUE) {
        return null;
      }
      l -= k;
      j += 1;
    }
    if (i != 0) {
      return Long.valueOf(l);
    }
    if (l == Long.MIN_VALUE) {
      return null;
    }
    return Long.valueOf(-l);
  }
  
  static enum a
    implements Comparator<long[]>
  {
    private a() {}
  }
  
  @GwtCompatible
  static final class b
    extends AbstractList<Long>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final long[] a;
    final int b;
    final int c;
    
    b(long[] paramArrayOfLong)
    {
      this(paramArrayOfLong, 0, paramArrayOfLong.length);
    }
    
    private b(long[] paramArrayOfLong, int paramInt1, int paramInt2)
    {
      this.a = paramArrayOfLong;
      this.b = paramInt1;
      this.c = paramInt2;
    }
    
    public final boolean contains(Object paramObject)
    {
      return ((paramObject instanceof Long)) && (Longs.a(this.a, ((Long)paramObject).longValue(), this.b, this.c) != -1);
    }
    
    public final boolean equals(Object paramObject)
    {
      if (paramObject == this) {}
      for (;;)
      {
        return true;
        if (!(paramObject instanceof b)) {
          break;
        }
        paramObject = (b)paramObject;
        int j = size();
        if (((b)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 + Longs.hashCode(this.a[i]);
        i += 1;
      }
      return j;
    }
    
    public final int indexOf(Object paramObject)
    {
      if ((paramObject instanceof Long))
      {
        int i = Longs.a(this.a, ((Long)paramObject).longValue(), 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 Long))
      {
        int i = Longs.b(this.a, ((Long)paramObject).longValue(), 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<Long> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      if (paramInt1 == paramInt2) {
        return Collections.emptyList();
      }
      return new b(this.a, this.b + paramInt1, this.b + paramInt2);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder(size() * 10);
      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 ']';
    }
  }
  
  static final class c
    extends Converter<String, Long>
    implements Serializable
  {
    static final c a = new c();
    private static final long serialVersionUID = 1L;
    
    private Object readResolve()
    {
      return a;
    }
    
    public final String toString()
    {
      return "Longs.stringConverter()";
    }
  }
}


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