// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.util;

public abstract class Pack
{
    public static short bigEndianToShort(final byte[] array, int n) {
        return (short)((array[n] & 0xFF) << 8 | (array[++n] & 0xFF));
    }
    
    public static int bigEndianToInt(final byte[] array, int n) {
        return array[n] << 24 | (array[++n] & 0xFF) << 16 | (array[++n] & 0xFF) << 8 | (array[++n] & 0xFF);
    }
    
    public static void bigEndianToInt(final byte[] array, int n, final int[] array2) {
        for (int i = 0; i < array2.length; ++i) {
            array2[i] = bigEndianToInt(array, n);
            n += 4;
        }
    }
    
    public static void bigEndianToInt(final byte[] array, int n, final int[] array2, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array2[n2 + i] = bigEndianToInt(array, n);
            n += 4;
        }
    }
    
    public static byte[] intToBigEndian(final int n) {
        final byte[] array = new byte[4];
        intToBigEndian(n, array, 0);
        return array;
    }
    
    public static void intToBigEndian(final int n, final byte[] array, int n2) {
        array[n2] = (byte)(n >>> 24);
        array[++n2] = (byte)(n >>> 16);
        array[++n2] = (byte)(n >>> 8);
        array[++n2] = (byte)n;
    }
    
    public static byte[] intToBigEndian(final int[] array) {
        final byte[] array2 = new byte[4 * array.length];
        intToBigEndian(array, array2, 0);
        return array2;
    }
    
    public static void intToBigEndian(final int[] array, final byte[] array2, int n) {
        for (int i = 0; i < array.length; ++i) {
            intToBigEndian(array[i], array2, n);
            n += 4;
        }
    }
    
    public static void intToBigEndian(final int[] array, final int n, final int n2, final byte[] array2, int n3) {
        for (int i = 0; i < n2; ++i) {
            intToBigEndian(array[n + i], array2, n3);
            n3 += 4;
        }
    }
    
    public static long bigEndianToLong(final byte[] array, final int n) {
        return ((long)bigEndianToInt(array, n) & 0xFFFFFFFFL) << 32 | ((long)bigEndianToInt(array, n + 4) & 0xFFFFFFFFL);
    }
    
    public static void bigEndianToLong(final byte[] array, int n, final long[] array2) {
        for (int i = 0; i < array2.length; ++i) {
            array2[i] = bigEndianToLong(array, n);
            n += 8;
        }
    }
    
    public static void bigEndianToLong(final byte[] array, int n, final long[] array2, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array2[n2 + i] = bigEndianToLong(array, n);
            n += 8;
        }
    }
    
    public static long bigEndianToLong(final byte[] array, final int n, final int n2) {
        long n3 = 0L;
        for (int i = 0; i < n2; ++i) {
            n3 |= ((long)array[i + n] & 0xFFL) << (7 - i << 3);
        }
        return n3;
    }
    
    public static byte[] longToBigEndian(final long n) {
        final byte[] array = new byte[8];
        longToBigEndian(n, array, 0);
        return array;
    }
    
    public static void longToBigEndian(final long n, final byte[] array, final int n2) {
        intToBigEndian((int)(n >>> 32), array, n2);
        intToBigEndian((int)(n & 0xFFFFFFFFL), array, n2 + 4);
    }
    
    public static byte[] longToBigEndian(final long[] array) {
        final byte[] array2 = new byte[8 * array.length];
        longToBigEndian(array, array2, 0);
        return array2;
    }
    
    public static void longToBigEndian(final long[] array, final byte[] array2, int n) {
        for (int i = 0; i < array.length; ++i) {
            longToBigEndian(array[i], array2, n);
            n += 8;
        }
    }
    
    public static void longToBigEndian(final long[] array, final int n, final int n2, final byte[] array2, int n3) {
        for (int i = 0; i < n2; ++i) {
            longToBigEndian(array[n + i], array2, n3);
            n3 += 8;
        }
    }
    
    @Deprecated
    public static void longToBigEndian(long n, final byte[] array, final int n2, final int n3) {
        for (int i = n3 - 1; i >= 0; --i) {
            array[i + n2] = (byte)(n & 0xFFL);
            n >>>= 8;
        }
    }
    
    public static short littleEndianToShort(final byte[] array, int n) {
        return (short)((array[n] & 0xFF) | (array[++n] & 0xFF) << 8);
    }
    
    public static void littleEndianToShort(final byte[] array, int n, final short[] array2, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array2[n2 + i] = littleEndianToShort(array, n);
            n += 2;
        }
    }
    
    public static int littleEndianToInt(final byte[] array, int n) {
        return (array[n] & 0xFF) | (array[++n] & 0xFF) << 8 | (array[++n] & 0xFF) << 16 | array[++n] << 24;
    }
    
    public static int littleEndianToInt_High(final byte[] array, final int n, final int n2) {
        return littleEndianToInt_Low(array, n, n2) << (4 - n2 << 3);
    }
    
    public static int littleEndianToInt_Low(final byte[] array, final int n, final int n2) {
        int n3 = array[n] & 0xFF;
        int n4 = 0;
        for (int i = 1; i < n2; ++i) {
            n4 += 8;
            n3 |= (array[n + i] & 0xFF) << n4;
        }
        return n3;
    }
    
    public static void littleEndianToInt(final byte[] array, int n, final int[] array2) {
        for (int i = 0; i < array2.length; ++i) {
            array2[i] = littleEndianToInt(array, n);
            n += 4;
        }
    }
    
    public static void littleEndianToInt(final byte[] array, int n, final int[] array2, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array2[n2 + i] = littleEndianToInt(array, n);
            n += 4;
        }
    }
    
    public static int[] littleEndianToInt(final byte[] array, int n, final int n2) {
        final int[] array2 = new int[n2];
        for (int i = 0; i < array2.length; ++i) {
            array2[i] = littleEndianToInt(array, n);
            n += 4;
        }
        return array2;
    }
    
    public static byte[] shortToLittleEndian(final short n) {
        final byte[] array = new byte[2];
        shortToLittleEndian(n, array, 0);
        return array;
    }
    
    public static void shortToLittleEndian(final short n, final byte[] array, int n2) {
        array[n2] = (byte)n;
        array[++n2] = (byte)(n >>> 8);
    }
    
    public static void shortToLittleEndian(final short[] array, final int n, final int n2, final byte[] array2, int n3) {
        for (int i = 0; i < n2; ++i) {
            shortToLittleEndian(array[n + i], array2, n3);
            n3 += 2;
        }
    }
    
    public static byte[] shortToBigEndian(final short n) {
        final byte[] array = new byte[2];
        shortToBigEndian(n, array, 0);
        return array;
    }
    
    public static void shortToBigEndian(final short n, final byte[] array, int n2) {
        array[n2] = (byte)(n >>> 8);
        array[++n2] = (byte)n;
    }
    
    public static byte[] intToLittleEndian(final int n) {
        final byte[] array = new byte[4];
        intToLittleEndian(n, array, 0);
        return array;
    }
    
    public static void intToLittleEndian(final int n, final byte[] array, int n2) {
        array[n2] = (byte)n;
        array[++n2] = (byte)(n >>> 8);
        array[++n2] = (byte)(n >>> 16);
        array[++n2] = (byte)(n >>> 24);
    }
    
    public static byte[] intToLittleEndian(final int[] array) {
        final byte[] array2 = new byte[4 * array.length];
        intToLittleEndian(array, array2, 0);
        return array2;
    }
    
    public static void intToLittleEndian(final int[] array, final byte[] array2, int n) {
        for (int i = 0; i < array.length; ++i) {
            intToLittleEndian(array[i], array2, n);
            n += 4;
        }
    }
    
    public static void intToLittleEndian(final int[] array, final int n, final int n2, final byte[] array2, int n3) {
        for (int i = 0; i < n2; ++i) {
            intToLittleEndian(array[n + i], array2, n3);
            n3 += 4;
        }
    }
    
    public static long littleEndianToLong(final byte[] array, final int n) {
        return ((long)littleEndianToInt(array, n + 4) & 0xFFFFFFFFL) << 32 | ((long)littleEndianToInt(array, n) & 0xFFFFFFFFL);
    }
    
    public static void littleEndianToLong(final byte[] array, int n, final long[] array2) {
        for (int i = 0; i < array2.length; ++i) {
            array2[i] = littleEndianToLong(array, n);
            n += 8;
        }
    }
    
    public static long littleEndianToLong(final byte[] array, final int n, final int n2) {
        long n3 = 0L;
        for (int i = 0; i < n2; ++i) {
            n3 |= ((long)array[n + i] & 0xFFL) << (i << 3);
        }
        return n3;
    }
    
    public static void littleEndianToLong(final byte[] array, int n, final long[] array2, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array2[n2 + i] = littleEndianToLong(array, n);
            n += 8;
        }
    }
    
    public static void longToLittleEndian_High(final long n, final byte[] array, final int n2, final int n3) {
        int n4 = 56;
        array[n2] = (byte)(n >>> n4);
        for (int i = 1; i < n3; ++i) {
            n4 -= 8;
            array[n2 + i] = (byte)(n >>> n4);
        }
    }
    
    public static void longToLittleEndian(final long n, final byte[] array, final int n2, final int n3) {
        for (int i = 0; i < n3; ++i) {
            array[n2 + i] = (byte)(n >>> (i << 3));
        }
    }
    
    public static long littleEndianToLong_High(final byte[] array, final int n, final int n2) {
        return littleEndianToLong_Low(array, n, n2) << (8 - n2 << 3);
    }
    
    public static long littleEndianToLong_Low(final byte[] array, final int n, final int n2) {
        long n3 = array[n] & 0xFF;
        for (int i = 1; i < n2; ++i) {
            n3 = (n3 << 8 | (long)(array[n + i] & 0xFF));
        }
        return n3;
    }
    
    public static byte[] longToLittleEndian(final long n) {
        final byte[] array = new byte[8];
        longToLittleEndian(n, array, 0);
        return array;
    }
    
    public static void longToLittleEndian(final long n, final byte[] array, final int n2) {
        intToLittleEndian((int)(n & 0xFFFFFFFFL), array, n2);
        intToLittleEndian((int)(n >>> 32), array, n2 + 4);
    }
    
    public static byte[] longToLittleEndian(final long[] array) {
        final byte[] array2 = new byte[8 * array.length];
        longToLittleEndian(array, array2, 0);
        return array2;
    }
    
    public static void longToLittleEndian(final long[] array, final byte[] array2, int n) {
        for (int i = 0; i < array.length; ++i) {
            longToLittleEndian(array[i], array2, n);
            n += 8;
        }
    }
    
    public static void longToLittleEndian(final long[] array, final int n, final int n2, final byte[] array2, int n3) {
        for (int i = 0; i < n2; ++i) {
            longToLittleEndian(array[n + i], array2, n3);
            n3 += 8;
        }
    }
}