z8B = IntsTo32bits(z, 0x8);        zCF = IntsTo32bits(z, 0xC);        x03 = z8B ^S5[z[0x5]] ^S6[z[0x7]] ^S7[z[0x4]] ^S8[z[0x6]] ^S7[z[0x0]];        Bits32ToInts(x03, x, 0x0);        x47 = z03 ^S5[x[0x0]] ^S6[x[0x2]] ^S7[x[0x1]] ^S8[x[0x3]] ^S8[z[0x2]];        Bits32ToInts(x47, x, 0x4);        x8B = z47 ^S5[x[0x7]] ^S6[x[0x6]] ^S7[x[0x5]] ^S8[x[0x4]] ^S5[z[0x1]];        Bits32ToInts(x8B, x, 0x8);        xCF = zCF ^S5[x[0xA]] ^S6[x[0x9]] ^S7[x[0xB]] ^S8[x[0x8]] ^S6[z[0x3]];        Bits32ToInts(xCF, x, 0xC);        _Kr[13]=(S5[x[0x8]]^S6[x[0x9]]^S7[x[0x7]]^S8[x[0x6]]^S5[x[0x3]])&0x1f;        _Kr[14]=(S5[x[0xA]]^S6[x[0xB]]^S7[x[0x5]]^S8[x[0x4]]^S6[x[0x7]])&0x1f;        _Kr[15]=(S5[x[0xC]]^S6[x[0xD]]^S7[x[0x3]]^S8[x[0x2]]^S7[x[0x8]])&0x1f;        _Kr[16]=(S5[x[0xE]]^S6[x[0xF]]^S7[x[0x1]]^S8[x[0x0]]^S8[x[0xD]])&0x1f;    }    /**     * Encrypt the given input starting at the given offset and place     * the result in the provided buffer starting at the given offset.     *     * @param src        The plaintext buffer     * @param srcIndex    An offset into src     * @param dst        The ciphertext buffer     * @param dstIndex    An offset into dst     */    protected int encryptBlock(        byte[] src,         int srcIndex,        byte[] dst,        int dstIndex)    {        int  result[] = new int[2];        // process the input block         // batch the units up into a 32 bit chunk and go for it        // the array is in bytes, the increment is 8x8 bits = 64        int L0 = BytesTo32bits(src, srcIndex);        int R0 = BytesTo32bits(src, srcIndex + 4);        CAST_Encipher(L0, R0, result);        // now stuff them into the destination block        Bits32ToBytes(result[0], dst, dstIndex);        Bits32ToBytes(result[1], dst, dstIndex + 4);        return BLOCK_SIZE;    }    /**     * Decrypt the given input starting at the given offset and place     * the result in the provided buffer starting at the given offset.     *     * @param src        The plaintext buffer     * @param srcIndex    An offset into src     * @param dst        The ciphertext buffer     * @param dstIndex    An offset into dst     */    protected int decryptBlock(        byte[] src,         int srcIndex,        byte[] dst,        int dstIndex)    {        int  result[] = new int[2];        // process the input block        // batch the units up into a 32 bit chunk and go for it        // the array is in bytes, the increment is 8x8 bits = 64        int L16 = BytesTo32bits(src, srcIndex);        int R16 = BytesTo32bits(src, srcIndex+4);        CAST_Decipher(L16, R16, result);        // now stuff them into the destination block        Bits32ToBytes(result[0], dst, dstIndex);        Bits32ToBytes(result[1], dst, dstIndex+4);        return BLOCK_SIZE;    }    /**     * The first of the three processing functions for the     * encryption and decryption.     *     * @param D            the input to be processed     * @param Kmi        the mask to be used from Km[n]     * @param Kri        the rotation value to be used     *     */    protected final int F1(int D, int Kmi, int Kri)    {        int I = Kmi + D;        I = I << Kri | I >>> (32-Kri);        return ((S1[(I>>>24)&0xff]^S2[(I>>>16)&0xff])-S3[(I>>> 8)&0xff])+                 S4[I & 0xff];    }    /**     * The second of the three processing functions for the     * encryption and decryption.     *     * @param D            the input to be processed     * @param Kmi        the mask to be used from Km[n]     * @param Kri        the rotation value to be used     *     */    protected final int F2(int D, int Kmi, int Kri)    {        int I = Kmi ^ D;        I = I << Kri | I >>> (32-Kri);        return ((S1[(I>>>24)&0xff]-S2[(I>>>16)&0xff])+S3[(I>>> 8)&0xff])^                 S4[I & 0xff];    }    /**     * The third of the three processing functions for the     * encryption and decryption.     *     * @param D            the input to be processed     * @param Kmi        the mask to be used from Km[n]     * @param Kri        the rotation value to be used     *     */    protected final int F3(int D, int Kmi, int Kri)    {        int I = Kmi - D;        I = I << Kri | I >>> (32-Kri);        return ((S1[(I>>>24)&0xff]+S2[(I>>>16)&0xff])^S3[(I>>> 8)&0xff])-                 S4[I & 0xff];    }    /**     * Does the 16 rounds to encrypt the block.     *      * @param L0    the LH-32bits of the plaintext block     * @param R0    the RH-32bits of the plaintext block     */    protected final void CAST_Encipher(int L0, int R0, int result[])    {        int Lp = L0;        // the previous value, equiv to L[i-1]        int Rp = R0;        // equivalent to R[i-1]        /*          * numbering consistent with paper to make         * checking and validating easier         */        int Li = L0, Ri = R0;        for (int i = 1; i<=_rounds ; i++)        {            Lp = Li;            Rp = Ri;            Li = Rp;            switch (i)            {                case  1:                case  4:                case  7:                case 10:                case 13:                case 16:                    Ri = Lp ^ F1(Rp, _Km[i], _Kr[i]);                    break;                case  2:                case  5:                case  8:                case 11:                case 14:                    Ri = Lp ^ F2(Rp, _Km[i], _Kr[i]);                    break;                case  3:                case  6:                case  9:                case 12:                case 15:                    Ri = Lp ^ F3(Rp, _Km[i], _Kr[i]);                    break;            }        }        result[0] = Ri;        result[1] = Li;        return;    }    protected final void CAST_Decipher(int L16, int R16, int result[])    {        int Lp = L16;        // the previous value, equiv to L[i-1]        int Rp = R16;        // equivalent to R[i-1]        /*          * numbering consistent with paper to make         * checking and validating easier         */        int Li = L16, Ri = R16;        for (int i = _rounds; i > 0; i--)        {            Lp = Li;            Rp = Ri;            Li = Rp;            switch (i)            {                case  1:                case  4:                case  7:                case 10:                case 13:                case 16:                    Ri = Lp ^ F1(Rp, _Km[i], _Kr[i]);                    break;                case  2:                case  5:                case  8:                case 11:                case 14:                    Ri = Lp ^ F2(Rp, _Km[i], _Kr[i]);                    break;                case  3:                case  6:                case  9:                case 12:                case 15:                    Ri = Lp ^ F3(Rp, _Km[i], _Kr[i]);                    break;            }        }        result[0] = Ri;        result[1] = Li;        return;    }    protected final void Bits32ToInts(int in,  int[] b, int offset)    {        b[offset + 3] = (in & 0xff);        b[offset + 2] = ((in >>> 8) & 0xff);        b[offset + 1] = ((in >>> 16) & 0xff);        b[offset]     = ((in >>> 24) & 0xff);    }    protected final int IntsTo32bits(int[] b, int i)    {        int rv = 0;        rv = ((b[i]   & 0xff) << 24) |              ((b[i+1] & 0xff) << 16) |             ((b[i+2] & 0xff) << 8) |             ((b[i+3] & 0xff));        return rv;    }    protected final void Bits32ToBytes(int in,  byte[] b, int offset)    {        b[offset + 3] = (byte)in;        b[offset + 2] = (byte)(in >>> 8);        b[offset + 1] = (byte)(in >>> 16);        b[offset]     = (byte)(in >>> 24);    }    protected final int BytesTo32bits(byte[] b, int i)    {        return ((b[i]   & 0xff) << 24) |             ((b[i+1] & 0xff) << 16) |            ((b[i+2] & 0xff) << 8) |            ((b[i+3] & 0xff));    }}