Something

public class cypher {
    private int cvar1;
    private int cvar2;
    private int cvar3;
    private int offset;
    private int[] variants = new int[256];
    private int[] cyphers = new int[256];

    public cypher(int[] is) {
        for (int i = 0; is.length > i; i++)
            variants[i] = is[i];
        init();
    }

    private void init() {
        anInt651++;
        int byte2;
        int byte3;
        int byte4;
        int byte5;
        int byte6;
        int byte7;
        int byte8;
        int byte1 = byte2 = byte3 = byte4 = byte5 = byte6 = byte7 = byte8 = -1640531527;

        for (int i = 0; i < 4; i++) {
            byte1 ^= byte2 << 11;
            byte4 += byte1;
            byte2 += byte3;
            byte2 ^= byte3 >>> 2;
            byte5 += byte2;
            byte3 += byte4;
            byte3 ^= byte4 << 8;
            byte6 += byte3;
            byte4 += byte5;
            byte4 ^= byte5 >>> 16;
            byte5 += byte6;
            byte7 += byte4;
            byte5 ^= byte6 << 10;
            byte8 += byte5;
            byte6 += byte7;
            byte6 ^= byte7 >>> 4;
            byte1 += byte6;
            byte7 += byte8;
            byte7 ^= byte8 << 8;
            byte8 += byte1;
            byte2 += byte7;
            byte8 ^= byte1 >>> 9;
            byte3 += byte8;
            byte1 += byte2;
        }

        for (int i = 0; i < 256; i += 8) {
            byte1 += variants[i];
            byte2 += variants[i + 1];
            byte3 += variants[i + 2];
            byte4 += variants[i + 3];
            byte5 += variants[i + 4];
            byte6 += variants[i + 5];
            byte7 += variants[i + 6];
            byte8 += variants[i + 7];
            byte1 ^= byte2 << 11;
            byte2 += byte3;
            byte4 += byte1;
            byte2 ^= byte3 >>> 2;
            byte3 += byte4;
            byte3 ^= byte4 << 8;
            byte6 += byte3;
            byte5 += byte2;
            byte4 += byte5;
            byte4 ^= byte5 >>> 16;
            byte7 += byte4;
            byte5 += byte6;
            byte5 ^= byte6 << 10;
            byte8 += byte5;
            byte6 += byte7;
            byte6 ^= byte7 >>> 4;
            byte7 += byte8;
            byte7 ^= byte8 << 8;
            byte1 += byte6;
            byte2 += byte7;
            byte8 += byte1;
            byte8 ^= byte1 >>> 9;
            byte3 += byte8;
            byte1 += byte2;
            cyphers[i] = byte1;
            cyphers[i + 1] = byte2;
            cyphers[i + 2] = byte3;
            cyphers[i + 3] = byte4;
            cyphers[i + 4] = byte5;
            cyphers[i + 5] = byte6;
            cyphers[i + 6] = byte7;
            cyphers[i + 7] = byte8;
        }

        for (int i = 0; i < 256; i += 8) {
            byte1 += cyphers[i];
            byte2 += cyphers[i + 1];
            byte3 += cyphers[i + 2];
            byte4 += cyphers[i + 3];
            byte5 += cyphers[i + 4];
            byte6 += cyphers[i + 5];
            byte7 += cyphers[i + 6];
            byte8 += cyphers[i + 7];
            byte1 ^= byte2 << 11;
            byte2 += byte3;
            byte4 += byte1;
            byte2 ^= byte3 >>> 2;
            byte3 += byte4;
            byte3 ^= byte4 << 8;
            byte5 += byte2;
            byte4 += byte5;
            byte4 ^= byte5 >>> 16;
            byte7 += byte4;
            byte6 += byte3;
            byte5 += byte6;
            byte5 ^= byte6 << 10;
            byte8 += byte5;
            byte6 += byte7;
            byte6 ^= byte7 >>> 4;
            byte7 += byte8;
            byte7 ^= byte8 << 8;
            byte1 += byte6;
            byte2 += byte7;
            byte8 += byte1;
            byte8 ^= byte1 >>> 9;
            byte1 += byte2;
            byte3 += byte8;
            cyphers[i] = byte1;
            cyphers[i + 1] = byte2;
            cyphers[i + 2] = byte3;
            cyphers[i + 3] = byte4;
            cyphers[i + 4] = byte5;
            cyphers[i + 5] = byte6;
            cyphers[i + 6] = byte7;
            cyphers[i + 7] = byte8;
        }

        next();
        offset = 256;
    }

    public int getkey() {
        anInt661++;
        if (offset-- == 0) {
            next();
            offset = 255;
        }
        return variants[offset];
    }

    private void next() {
        anInt647++;
        cvar2 += ++cvar3;

        for (int i = 0; i < 256; i++) {
            int variant = cyphers[i];
            if ((i & 0x2) == 0) {
                if ((i & 0x1) == 0)
                    cvar1 ^= cvar1 << 13;
                else
                    cvar1 ^= cvar1 >>> 6;
            } else {
                if ((i & 0x1) == 0)
                    cvar1 ^= cvar1 << 2;
                else
                    cvar1 ^= cvar1 >>> 16;
            }
            cvar1 += cyphers[0xff & i + 128];
            int cypher;
            cyphers[i] = cypher = cvar1 + cyphers[(variant >> 2) & 0xff] + cvar2;
            variants[i] = cvar2 = cyphers[(cypher >> 8 >> 2) & 0xff] + variant;
        }
    }
}