/**

@Native public static final long MIN_VALUE = 0x8000000000000000L;

/**

@Native public static final long MAX_VALUE = 0x7fffffffffffffffL;

/**

@SuppressWarnings("unchecked")

public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");

/**

public static String toString(long i, int radix) {

if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)

radix = 10;

if (radix == 10)

return toString(i);

char[] buf = new char[65];

int charPos = 64;

boolean negative = (i < 0);

if (!negative) {

i = -i;

}

while (i <= -radix) {

buf[charPos--] = Integer.digits[(int)(-(i % radix))];

i = i / radix;

}

buf[charPos] = Integer.digits[(int)(-i)];

if (negative) {

buf[--charPos] = '-';

}

return new String(buf, charPos, (65 - charPos));

}

/**

public static String toUnsignedString(long i, int radix) {

if (i >= 0)

return toString(i, radix);

else {

switch (radix) {

case 2:

return toBinaryString(i);

case 4:

return toUnsignedString0(i, 2);

case 8:

return toOctalString(i);

case 10:

/*

long quot = (i >>> 1) / 5;

long rem = i - quot * 10;

return toString(quot) + rem;

case 16:

return toHexString(i);

case 32:

return toUnsignedString0(i, 5);

default:

return toUnsignedBigInteger(i).toString(radix);

}

}

}

/**

private static BigInteger toUnsignedBigInteger(long i) {

if (i >= 0L)

return BigInteger.valueOf(i);

else {

int upper = (int) (i >>> 32);

int lower = (int) i;

// return (upper << 32) + lower

return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).

add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));

}

}

/**

public static String toHexString(long i) {

return toUnsignedString0(i, 4);

}

/**

public static String toOctalString(long i) {

return toUnsignedString0(i, 3);

}

/**

public static String toBinaryString(long i) {

return toUnsignedString0(i, 1);

}

/**

static String toUnsignedString0(long val, int shift) {

// assert shift > 0 && shift <=5 : "Illegal shift value";

int mag = Long.SIZE - Long.numberOfLeadingZeros(val);

int chars = Math.max(((mag + (shift - 1)) / shift), 1);

char[] buf = new char[chars];

formatUnsignedLong(val, shift, buf, 0, chars);

return new String(buf, true);

}

/**

static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {

int charPos = len;

int radix = 1 << shift;

int mask = radix - 1;

do {

buf[offset + --charPos] = Integer.digits[((int) val) & mask];

val >>>= shift;

} while (val != 0 && charPos > 0);

return charPos;

}

/**

public static String toString(long i) {

if (i == Long.MIN_VALUE)

return "-9223372036854775808";

int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);

char[] buf = new char[size];

getChars(i, size, buf);

return new String(buf, true);

}

/**

public static String toUnsignedString(long i) {

return toUnsignedString(i, 10);

}

/**

static void getChars(long i, int index, char[] buf) {

long q;

int r;

int charPos = index;

char sign = 0;

if (i < 0) {

sign = '-';

i = -i;

}

// Get 2 digits/iteration using longs until quotient fits into an int

while (i > Integer.MAX_VALUE) {

q = i / 100;

// really: r = i - (q * 100);

r = (int)(i - ((q << 6) + (q << 5) + (q << 2)));

i = q;

buf[--charPos] = Integer.DigitOnes[r];

buf[--charPos] = Integer.DigitTens[r];

}

// Get 2 digits/iteration using ints

int q2;

int i2 = (int)i;

while (i2 >= 65536) {

q2 = i2 / 100;

// really: r = i2 - (q * 100);

r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2));

i2 = q2;

buf[--charPos] = Integer.DigitOnes[r];

buf[--charPos] = Integer.DigitTens[r];

}

// Fall thru to fast mode for smaller numbers

// assert(i2 <= 65536, i2);

for (;;) {

q2 = (i2 * 52429) >>> (16+3);

r = i2 - ((q2 << 3) + (q2 << 1)); // r = i2-(q2*10) ...

buf[--charPos] = Integer.digits[r];

i2 = q2;

if (i2 == 0) break;

}

if (sign != 0) {

buf[--charPos] = sign;

}

}

// Requires positive x

static int stringSize(long x) {

long p = 10;

for (int i=1; i<19; i++) {

if (x < p)

return i;

p = 10*p;

}

return 19;

}

/**

public static long parseLong(String s, int radix)

throws NumberFormatException

{

if (s == null) {

throw new NumberFormatException("null");

}

if (radix < Character.MIN_RADIX) {

throw new NumberFormatException("radix " + radix +

" less than Character.MIN_RADIX");

}

if (radix > Character.MAX_RADIX) {

throw new NumberFormatException("radix " + radix +

" greater than Character.MAX_RADIX");

}

long result = 0;

boolean negative = false;

int i = 0, len = s.length();

long limit = -Long.MAX_VALUE;

long multmin;

int digit;

if (len > 0) {

char firstChar = s.charAt(0);

if (firstChar < '0') { // Possible leading "+" or "-"

if (firstChar == '-') {

negative = true;

limit = Long.MIN_VALUE;

} else if (firstChar != '+')

throw NumberFormatException.forInputString(s);

if (len == 1) // Cannot have lone "+" or "-"

throw NumberFormatException.forInputString(s);

i++;

}

multmin = limit / radix;

while (i < len) {

// Accumulating negatively avoids surprises near MAX_VALUE

digit = Character.digit(s.charAt(i++),radix);

if (digit < 0) {

throw NumberFormatException.forInputString(s);

}

if (result < multmin) {

throw NumberFormatException.forInputString(s);

}

result *= radix;

if (result < limit + digit) {

throw NumberFormatException.forInputString(s);

}

result -= digit;

}

} else {

throw NumberFormatException.forInputString(s);

}

return negative ? result : -result;

}

/**

public static long parseLong(String s) throws NumberFormatException {

return parseLong(s, 10);

}

/**

public static long parseUnsignedLong(String s, int radix)

throws NumberFormatException {

if (s == null) {

throw new NumberFormatException("null");

}

int len = s.length();

if (len > 0) {

char firstChar = s.charAt(0);

if (firstChar == '-') {

throw new

NumberFormatException(String.format("Illegal leading minus sign " +

"on unsigned string %s.", s));

} else {

if (len <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits

(radix == 10 && len <= 18) ) { // Long.MAX_VALUE in base 10 is 19 digits

return parseLong(s, radix);

}

// No need for range checks on len due to testing above.

long first = parseLong(s.substring(0, len - 1), radix);

int second = Character.digit(s.charAt(len - 1), radix);

if (second < 0) {

throw new NumberFormatException("Bad digit at end of " + s);

}

long result = first * radix + second;

if (compareUnsigned(result, first) < 0) {

/*

throw new NumberFormatException(String.format("String value %s exceeds " +

"range of unsigned long.", s));

}

return result;

}

} else {

throw NumberFormatException.forInputString(s);

}

}

/**

public static long parseUnsignedLong(String s) throws NumberFormatException {

return parseUnsignedLong(s, 10);

}

/**

public static Long valueOf(String s, int radix) throws NumberFormatException {

return Long.valueOf(parseLong(s, radix));

}

/**

public static Long valueOf(String s) throws NumberFormatException

{

return Long.valueOf(parseLong(s, 10));

}

private static class LongCache {

private LongCache(){}

static final Long cache[] = new Long[-(-128) + 127 + 1];

static {

for(int i = 0; i < cache.length; i++)

cache[i] = new Long(i - 128);

}

}

/**

public static Long valueOf(long l) {

final int offset = 128;

if (l >= -128 && l <= 127) { // will cache

return LongCache.cache[(int)l + offset];

}

return new Long(l);

}

/**

public static Long decode(String nm) throws NumberFormatException {

int radix = 10;

int index = 0;

boolean negative = false;

Long result;

if (nm.length() == 0)

throw new NumberFormatException("Zero length string");

char firstChar = nm.charAt(0);

// Handle sign, if present

if (firstChar == '-') {

negative = true;

index++;

} else if (firstChar == '+')

index++;

// Handle radix specifier, if present

if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {

index += 2;

radix = 16;

}

else if (nm.startsWith("#", index)) {

index ++;

radix = 16;

}

else if (nm.startsWith("0", index) && nm.length() > 1 + index) {

index ++;

radix = 8;

}

if (nm.startsWith("-", index) || nm.startsWith("+", index))

throw new NumberFormatException("Sign character in wrong position");

try {

result = Long.valueOf(nm.substring(index), radix);

result = negative ? Long.valueOf(-result.longValue()) : result;

} catch (NumberFormatException e) {

// If number is Long.MIN_VALUE, we'll end up here. The next line

// handles this case, and causes any genuine format error to be

// rethrown.

String constant = negative ? ("-" + nm.substring(index))

: nm.substring(index);

result = Long.valueOf(constant, radix);

}

return result;

}

/**

private final long value;

/**

public Long(long value) {

this.value = value;

}

/**

public Long(String s) throws NumberFormatException {

this.value = parseLong(s, 10);

}

/**

public byte byteValue() {

return (byte)value;

}

/**

public short shortValue() {

return (short)value;

}

/**

public int intValue() {

return (int)value;

}

/**

public long longValue() {

return value;