package com.google.common.primitives;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.math.BigInteger;
import java.util.Comparator;
import ri;

@Beta
@GwtCompatible
public final class UnsignedLongs
{
  public static final long MAX_VALUE = -1L;
  private static final long[] a = new long[37];
  private static final int[] b = new int[37];
  private static final int[] c = new int[37];
  
  static
  {
    BigInteger localBigInteger = new BigInteger("10000000000000000", 16);
    int i = 2;
    while (i <= 36)
    {
      a[i] = divide(-1L, i);
      b[i] = ((int)remainder(-1L, i));
      c[i] = (localBigInteger.toString(i).length() - 1);
      i += 1;
    }
  }
  
  public static int compare(long paramLong1, long paramLong2)
  {
    return Longs.compare(paramLong1 ^ 0x8000000000000000, 0x8000000000000000 ^ paramLong2);
  }
  
  public static long decode(String paramString)
  {
    ri localri = ri.a(paramString);
    try
    {
      long l = parseUnsignedLong(localri.a, localri.b);
      return l;
    }
    catch (NumberFormatException localNumberFormatException)
    {
      paramString = String.valueOf(paramString);
      if (paramString.length() == 0) {}
    }
    for (paramString = "Error parsing value: ".concat(paramString);; paramString = new String("Error parsing value: "))
    {
      paramString = new NumberFormatException(paramString);
      paramString.initCause(localNumberFormatException);
      throw paramString;
    }
  }
  
  public static long divide(long paramLong1, long paramLong2)
  {
    int i = 1;
    if (paramLong2 < 0L)
    {
      if (compare(paramLong1, paramLong2) < 0) {
        return 0L;
      }
      return 1L;
    }
    if (paramLong1 >= 0L) {
      return paramLong1 / paramLong2;
    }
    long l = (paramLong1 >>> 1) / paramLong2 << 1;
    if (compare(paramLong1 - l * paramLong2, paramLong2) >= 0) {}
    for (;;)
    {
      return i + l;
      i = 0;
    }
  }
  
  public static String join(String paramString, long... paramVarArgs)
  {
    Preconditions.checkNotNull(paramString);
    if (paramVarArgs.length == 0) {
      return "";
    }
    StringBuilder localStringBuilder = new StringBuilder(paramVarArgs.length * 5);
    localStringBuilder.append(toString(paramVarArgs[0]));
    int i = 1;
    while (i < paramVarArgs.length)
    {
      localStringBuilder.append(paramString).append(toString(paramVarArgs[i]));
      i += 1;
    }
    return localStringBuilder.toString();
  }
  
  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] ^ 0x8000000000000000; i < paramVarArgs.length; l1 = l2)
      {
        long l3 = paramVarArgs[i] ^ 0x8000000000000000;
        l2 = l1;
        if (l3 > l1) {
          l2 = l3;
        }
        i += 1;
      }
    }
    return l1 ^ 0x8000000000000000;
  }
  
  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] ^ 0x8000000000000000; i < paramVarArgs.length; l1 = l2)
      {
        long l3 = paramVarArgs[i] ^ 0x8000000000000000;
        l2 = l1;
        if (l3 < l1) {
          l2 = l3;
        }
        i += 1;
      }
    }
    return l1 ^ 0x8000000000000000;
  }
  
  public static long parseUnsignedLong(String paramString)
  {
    return parseUnsignedLong(paramString, 10);
  }
  
  public static long parseUnsignedLong(String paramString, int paramInt)
  {
    Preconditions.checkNotNull(paramString);
    if (paramString.length() == 0) {
      throw new NumberFormatException("empty string");
    }
    if ((paramInt < 2) || (paramInt > 36)) {
      throw new NumberFormatException(26 + "illegal radix: " + paramInt);
    }
    int k = c[paramInt];
    int j = 0;
    long l = 0L;
    while (j < paramString.length())
    {
      int m = Character.digit(paramString.charAt(j), paramInt);
      if (m == -1) {
        throw new NumberFormatException(paramString);
      }
      if (j > k - 1)
      {
        int i;
        if (l >= 0L) {
          if (l < a[paramInt])
          {
            i = 0;
            if (i == 0) {
              break label212;
            }
            paramString = String.valueOf(paramString);
            if (paramString.length() == 0) {
              break label199;
            }
          }
        }
        label199:
        for (paramString = "Too large for unsigned long: ".concat(paramString);; paramString = new String("Too large for unsigned long: "))
        {
          throw new NumberFormatException(paramString);
          if ((l <= a[paramInt]) && (m <= b[paramInt]))
          {
            i = 0;
            break;
          }
          i = 1;
          break;
        }
      }
      label212:
      l = l * paramInt + m;
      j += 1;
    }
    return l;
  }
  
  public static long remainder(long paramLong1, long paramLong2)
  {
    if (paramLong2 < 0L)
    {
      if (compare(paramLong1, paramLong2) < 0) {
        return paramLong1;
      }
      return paramLong1 - paramLong2;
    }
    if (paramLong1 >= 0L) {
      return paramLong1 % paramLong2;
    }
    paramLong1 -= ((paramLong1 >>> 1) / paramLong2 << 1) * paramLong2;
    if (compare(paramLong1, paramLong2) >= 0) {}
    for (;;)
    {
      return paramLong1 - paramLong2;
      paramLong2 = 0L;
    }
  }
  
  public static String toString(long paramLong)
  {
    return toString(paramLong, 10);
  }
  
  public static String toString(long paramLong, int paramInt)
  {
    if ((paramInt >= 2) && (paramInt <= 36)) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "radix (%s) must be between Character.MIN_RADIX and Character.MAX_RADIX", new Object[] { Integer.valueOf(paramInt) });
      if (paramLong != 0L) {
        break;
      }
      return "0";
    }
    char[] arrayOfChar = new char[64];
    int i;
    if (paramLong < 0L)
    {
      long l = divide(paramLong, paramInt);
      arrayOfChar[63] = Character.forDigit((int)(paramLong - paramInt * l), paramInt);
      paramLong = l;
      i = 63;
    }
    for (;;)
    {
      if (paramLong > 0L)
      {
        i -= 1;
        arrayOfChar[i] = Character.forDigit((int)(paramLong % paramInt), paramInt);
        paramLong /= paramInt;
      }
      else
      {
        return new String(arrayOfChar, i, 64 - i);
        i = 64;
      }
    }
  }
  
  static enum a
    implements Comparator<long[]>
  {
    private a() {}
  }
}


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