package java.lang;

import sun.misc.VM;

public final class Integer extends Number implements Comparable<Integer>
{
    public static final int MIN_VALUE = -2147483648;
    public static final int MAX_VALUE = 2147483647;
    public static final Class<Integer> TYPE;
    static final char[] digits;
    static final char[] DigitTens;
    static final char[] DigitOnes;
    static final int[] sizeTable;
    private final int value;
    public static final int SIZE = 32;
    private static final long serialVersionUID = 1360826667806852920L;
    
    public static String toString(int p0, int p1) {
        if (p1 < 2 || p1 > 36) {
            p1 = 10;
        }
        if (p1 == 10) {
            return toString(p0);
        }
        final char[] array = new char[33];
        final int num = (p0 >= 0) ? 0 : 1;
        int num2 = 32;
        if (num == 0) {
            p0 = -p0;
        }
        for (; p0 <= -p1; p0 = p0 / p1) {
            array[num2--] = Integer.digits[-(p0 % p1)];
        }
        array[num2] = Integer.digits[-p0];
        if (num != 0) {
            --num2;
            array[num2] = '-';
        }
        return new String(array, num2, 33 - num2);
    }
    
    public static String toHexString(int p0) {
        return toUnsignedString(p0, 4);
    }
    
    public static String toOctalString(int p0) {
        return toUnsignedString(p0, 3);
    }
    
    public static String toBinaryString(int p0) {
        return toUnsignedString(p0, 1);
    }
    
    private static String toUnsignedString(int p0, int p1) {
        final char[] array = new char[32];
        final int num = (1 << p1) - 1;
        int num2 = 0;
        do {
            --num2;
            array[num2] = Integer.digits[p0 & num];
            p0 = p0 >>> p1;
        }
        while (!(p0 == 0));
        return new String(array, num2, 32 - num2);
    }
    
    public static String toString(int p0) {
        if (p0 == -2147483648) {
            return "-2147483648";
        }
        final int num = (p0 >= 0) ? stringSize(p0) : (stringSize(-p0) + 1);
        final char[] array = new char[num];
        getChars(p0, num, array);
        return new String(0, num, array);
    }
    
    static void getChars(int p0, int p1, char[] p2) {
        int num = 0;
        if (p0 < 0) {
            num = 45;
            p0 = -p0;
        }
        int num2;
        int num3;
        int num4 = 0;
        for (; p0 >= 65536; p0 = num2, --num4, p2[num4] = Integer.DigitOnes[num3], --num4, p2[num4] = Integer.DigitTens[num3]) {
            num2 = p0 / 100;
            num3 = p0 - ((num2 << 6) + (num2 << 5) + (num2 << 2));
        }
        do {
            num2 = p0 * 52429 >>> 19;
            num3 = p0 - ((num2 << 3) + (num2 << 1));
            --num4;
            p2[num4] = Integer.digits[num3];
            p0 = num2;
        }
        while (!(p0 == 0));
        if (num != 0) {
            --num4;
            p2[num4] = num;
        }
    }
    
    static int stringSize(int p0) {
        int num = 0;
        while (p0 > Integer.sizeTable[num]) {
            ++num;
        }
        return num + 1;
    }
    
    public static int parseInt(String p0, int p1) throws NumberFormatException {
        if (p0 == null) {
            throw new NumberFormatException("null");
        }
        if (p1 < 2) {
            throw new NumberFormatException(new StringBuilder().append("radix ").append(p1).append(" less than Character.MIN_RADIX").toString());
        }
        if (p1 > 36) {
            throw new NumberFormatException(new StringBuilder().append("radix ").append(p1).append(" greater than Character.MAX_RADIX").toString());
        }
        int num = 0;
        int num2 = 0;
        int i = 0;
        final int length = p0.length();
        int num3 = -2147483647;
        if (length > 0) {
            final int char = p0.charAt(0);
            if (char < 48) {
                if (char == 45) {
                    num2 = 1;
                    num3 = -2147483648;
                }
                else {
                    if (char != 43) {
                        throw NumberFormatException.forInputString(p0);
                    }
                }
                if (length == 1) {
                    throw NumberFormatException.forInputString(p0);
                }
                ++i;
            }
            final int num4 = num3 / p1;
            while (i < length) {
                final int digit = Character.digit(p0.charAt(i++), p1);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(p0);
                }
                if (num < num4) {
                    throw NumberFormatException.forInputString(p0);
                }
                num = num * p1;
                if (num < num3 + digit) {
                    throw NumberFormatException.forInputString(p0);
                }
                num = num - digit;
            }
            return (num2 == 0) ? (-num) : num;
        }
        throw NumberFormatException.forInputString(p0);
    }
    
    public static int parseInt(String p0) throws NumberFormatException {
        return parseInt(p0, 10);
    }
    
    public static Integer valueOf(String p0, int p1) throws NumberFormatException {
        return valueOf(parseInt(p0, p1));
    }
    
    public static Integer valueOf(String p0) throws NumberFormatException {
        return valueOf(parseInt(p0, 10));
    }
    
    public static Integer valueOf(int p0) {
        if (!(Integer.$assertionsDisabled || IntegerCache.high >= 127)) {
            throw new AssertionError();
        }
        if (p0 >= -128 && p0 <= IntegerCache.high) {
            return IntegerCache.cache[p0 + 128];
        }
        return new Integer(p0);
    }
    
    public Integer(int p0) {
        super();
        this.value = p0;
    }
    
    public Integer(String p0) throws NumberFormatException {
        super();
        this.value = parseInt(p0, 10);
    }
    
    public byte byteValue() {
        return (byte)this.value;
    }
    
    public short shortValue() {
        return (short)this.value;
    }
    
    public int intValue() {
        return this.value;
    }
    
    public long longValue() {
        return (long)this.value;
    }
    
    public float floatValue() {
        return (float)this.value;
    }
    
    public double doubleValue() {
        return (double)this.value;
    }
    
    public String toString() {
        return toString(this.value);
    }
    
    public int hashCode() {
        return this.value;
    }
    
    public boolean equals(Object p0) {
        return p0 instanceof Integer && this.value == ((Integer)p0).intValue();
    }
    
    public static Integer getInteger(String p0) {
        return getInteger(p0, null);
    }
    
    public static Integer getInteger(String p0, int p1) {
        final Integer integer = getInteger(p0, null);
        return (integer != null) ? integer : valueOf(p1);
    }
    
    public static Integer getInteger(String p0, Integer p1) {
        String property = null;
        try {
            try {
                property = System.getProperty(p0);
            }
            catch (NullPointerException) {
            }
        }
        catch (IllegalArgumentException $3_10$_0A) {
        }
        if (property != null) {
            try {
                return decode(property);
            }
            catch (NumberFormatException $3_10$_0A) {
            }
        }
        return p1;
    }
    
    public static Integer decode(String p0) throws NumberFormatException {
        int num = 10;
        int num2 = 0;
        int num3 = 0;
        if (p0.length() == 0) {
            throw new NumberFormatException("Zero length string");
        }
        final int char = p0.charAt(0);
        if (char == 45) {
            num3 = 1;
            ++num2;
        }
        else {
            if (char == 43) {
                ++num2;
            }
        }
        if (p0.startsWith("0x", num2) || p0.startsWith("0X", num2)) {
            num2 += 2;
            num = 16;
        }
        else {
            if (p0.startsWith("#", num2)) {
                ++num2;
                num = 16;
            }
            else {
                if (p0.startsWith("0", num2) && p0.length() > 1 + num2) {
                    ++num2;
                    num = 8;
                }
            }
        }
        if (p0.startsWith("-", num2) || p0.startsWith("+", num2)) {
            throw new NumberFormatException("Sign character in wrong position");
        }
        Integer num4;
        try {
            num4 = valueOf(p0.substring(num2), num);
            num4 = ((num3 == 0) ? num4 : valueOf(-num4.intValue()));
        }
        catch (NumberFormatException $6_194$_C2) {
            num4 = valueOf((num3 == 0) ? p0.substring(num2) : new StringBuilder().append("-").append(p0.substring(num2)).toString(), num);
        }
        return num4;
    }
    
    public int compareTo(Integer p0) {
        return compare(this.value, p0.value);
    }
    
    public static int compare(int p0, int p1) {
        return (p0 >= p1) ? ((p0 != p1) ? 1 : 0) : -1;
    }
    
    public static int highestOneBit(int p0) {
        p0 = (p0 | p0 >> 1);
        p0 = (p0 | p0 >> 2);
        p0 = (p0 | p0 >> 4);
        p0 = (p0 | p0 >> 8);
        p0 = (p0 | p0 >> 16);
        return p0 - (p0 >>> 1);
    }
    
    public static int lowestOneBit(int p0) {
        return p0 & -p0;
    }
    
    public static int numberOfLeadingZeros(int p0) {
        if (p0 == 0) {
            return 32;
        }
        int num = 1;
        if (p0 >>> 16 == 0) {
            num += 16;
            p0 = p0 << 16;
        }
        if (p0 >>> 24 == 0) {
            num += 8;
            p0 = p0 << 8;
        }
        if (p0 >>> 28 == 0) {
            num += 4;
            p0 = p0 << 4;
        }
        if (p0 >>> 30 == 0) {
            num += 2;
            p0 = p0 << 2;
        }
        return num - (p0 >>> 31);
    }
    
    public static int numberOfTrailingZeros(int p0) {
        if (p0 == 0) {
            return 32;
        }
        int num = 31;
        int num2 = p0 << 16;
        if (num2 != 0) {
            num = num - 16;
            p0 = num2;
        }
        num2 = p0 << 8;
        if (num2 != 0) {
            num = num - 8;
            p0 = num2;
        }
        num2 = p0 << 4;
        if (num2 != 0) {
            num = num - 4;
            p0 = num2;
        }
        num2 = p0 << 2;
        if (num2 != 0) {
            num = num - 2;
            p0 = num2;
        }
        return num - (p0 << 1 >>> 31);
    }
    
    public static int bitCount(int p0) {
        p0 = p0 - (p0 >>> 1 & 1431655765);
        p0 = (p0 & 858993459) + (p0 >>> 2 & 858993459);
        p0 = (p0 + (p0 >>> 4) & 252645135);
        p0 = p0 + (p0 >>> 8);
        p0 = p0 + (p0 >>> 16);
        return p0 & 63;
    }
    
    public static int rotateLeft(int p0, int p1) {
        return p0 << p1 | p0 >>> -p1;
    }
    
    public static int rotateRight(int p0, int p1) {
        return p0 >>> p1 | p0 << -p1;
    }
    
    public static int reverse(int p0) {
        p0 = ((p0 & 1431655765) << 1 | (p0 >>> 1 & 1431655765));
        p0 = ((p0 & 858993459) << 2 | (p0 >>> 2 & 858993459));
        p0 = ((p0 & 252645135) << 4 | (p0 >>> 4 & 252645135));
        p0 = (p0 << 24 | (p0 & 65280) << 8 | (p0 >>> 8 & 65280) | p0 >>> 24);
        return p0;
    }
    
    public static int signum(int p0) {
        return p0 >> 31 | -p0 >>> 31;
    }
    
    public static int reverseBytes(int p0) {
        return p0 >>> 24 | (p0 >> 8 & 65280) | (p0 << 8 & 16711680) | p0 << 24;
    }
    
    static {
        final boolean b = Integer.$assertionsDisabled = !Integer.class.desiredAssertionStatus();
        Integer.TYPE = Class.getPrimitiveClass("int");
        Integer.digits = new char[] {
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            'a',
            'b',
            'c',
            'd',
            'e',
            'f',
            'g',
            'h',
            'i',
            'j',
            'k',
            'l',
            'm',
            'n',
            'o',
            'p',
            'q',
            'r',
            's',
            't',
            'u',
            'v',
            'w',
            'x',
            'y',
            'z'
        };
        Integer.DigitTens = new char[] {
            '0',
            '0',
            '0',
            '0',
            '0',
            '0',
            '0',
            '0',
            '0',
            '0',
            '1',
            '1',
            '1',
            '1',
            '1',
            '1',
            '1',
            '1',
            '1',
            '1',
            '2',
            '2',
            '2',
            '2',
            '2',
            '2',
            '2',
            '2',
            '2',
            '2',
            '3',
            '3',
            '3',
            '3',
            '3',
            '3',
            '3',
            '3',
            '3',
            '3',
            '4',
            '4',
            '4',
            '4',
            '4',
            '4',
            '4',
            '4',
            '4',
            '4',
            '5',
            '5',
            '5',
            '5',
            '5',
            '5',
            '5',
            '5',
            '5',
            '5',
            '6',
            '6',
            '6',
            '6',
            '6',
            '6',
            '6',
            '6',
            '6',
            '6',
            '7',
            '7',
            '7',
            '7',
            '7',
            '7',
            '7',
            '7',
            '7',
            '7',
            '8',
            '8',
            '8',
            '8',
            '8',
            '8',
            '8',
            '8',
            '8',
            '8',
            '9',
            '9',
            '9',
            '9',
            '9',
            '9',
            '9',
            '9',
            '9',
            '9'
        };
        Integer.DigitOnes = new char[] {
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',
            '0',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9'
        };
        Integer.sizeTable = new int[] {
            9,
            99,
            999,
            9999,
            99999,
            999999,
            9999999,
            99999999,
            999999999,
            2147483647
        };
    }
    
    static class IntegerCache
    {
        static final int low = -128;
        static final int high;
        static final Integer[] cache;
        
        private IntegerCache() {
            super();
        }
        
        static {
            int min = 127;
            final String savedProperty = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (savedProperty != null) {
                min = Math.min(Math.max(Integer.parseInt(savedProperty), 127), 2147483519);
            }
            IntegerCache.high = min;
            IntegerCache.cache = new Integer[IntegerCache.high - -128 + 1];
            int num = -128;
            for (int i = 0; i < IntegerCache.cache.length; ++i) {
                IntegerCache.cache[i] = new Integer(num++);
            }
        }
    }
}