Page 1 of 2 12 LastLast
Results 1 to 10 of 14

Thread: Urgent: NDS system was piracy and Here's your version Khurzmih

  1. #1

    Thumbs up Urgent: NDS system was piracy and Here's your version Khurzmih

    Greetings
    Latest news to you our solidarity NDS has been piracy
    By italian hack team
    And this topic is the algorithm for lovers of programming
    algorithms

    #include

    #define KEYLEN 4
    #define DATLEN 8
    #define TABLEN_64 64
    #define TABLEN_96 96
    #define TABLEN_128 128

    typedef unsigned char byte;
    typedef unsigned long word;

    byte hop0[7] = { 2, 6, 3, 7, 4, 1, 5 };
    byte hop1[7] = { 7, 1, 4, 5, 3, 2, 6 }; //adjusted for algo_1
    byte hop2[5] = { 2, 7, 4, 1, 3 }; //adjusted for algo_2

    //byte hop1[7] = { 1, 7, 6, 2, 3, 5, 4 };
    // 2 1
    // 9 8 7 6 5 4 3
    // ... 11 10
    //byte hop2[5] = { 3, 1, 4, 7, 2 };
    // 5 4 3 2 1
    // ... 6

    byte box_id_0[4] = { 0x01,0x02,0x03,0x04 };
    byte cw_0[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
    byte cw_2[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };

    byte box_id_1[4] = { 0x01,0x02,0x03,0x04 };
    byte cw_1[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
    byte cw_3[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };

    byte box_id[4] = { 0x01,0x02,0x03,0x04 };
    byte cw[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };

    byte tab_0[TABLEN_64] =
    {
    0x39,0x9E,0x97,0x55,0x10,0x66,0xBD,0x04,0x42,0xBF, 0x3B,0x28,0x71,0x20,0xB3,0x7F,
    0x1A,0xD1,0xBE,0xFE,0x9D,0x8F,0x03,0x9E,0x10,0x0A, 0xC0,0xE6,0x40,0x17,0x15,0xE9,
    0xE9,0x87,0xCD,0xA1,0xDF,0xE1,0xD7,0x72,0xDD,0xDB, 0x52,0x0A,0x36,0xA2,0xC1,0xB1,
    0xAD,0x43,0x0F,0x70,0xAC,0xCB,0x26,0x61,0x7E,0xAC, 0xBD,0x29,0xBE,0x01,0x00,0x01
    };

    byte tab_1[TABLEN_64] =
    {
    0xC1,0x7A,0x12,0xD2,0x17,0xE8,0x44,0x4B,0x63,0x02, 0x72,0x59,0x4A,0x54,0x6F,0x01,
    0x65,0x5D,0x9D,0xD5,0xB7,0x7A,0xBD,0x83,0xA5,0xF9, 0x6E,0xF7,0x84,0x69,0x7B,0x47,
    0x9C,0x1A,0xB0,0xDB,0x41,0x4C,0xA4,0xA3,0x3F,0x92, 0x59,0x30,0xD3,0x64,0x76,0x5F,
    0xF8,0x24,0xE6,0x3E,0x0E,0x02,0x2B,0x16,0xD1,0x1D, 0xF5,0xA9,0x88,0x01,0x00,0x01
    };

    byte tab_2[TABLEN_64] =
    {
    0x81,0x57,0xF8,0x61,0x83,0x5A,0xB9,0xE5,0xDB,0x8B, 0x3E,0x7D,0x21,0x0D,0x90,0x9F,
    0x26,0xF0,0x07,0x2E,0xB0,0xB6,0x70,0x00,0xA1,0x92, 0xA4,0x1E,0x69,0xEF,0xEA,0xA3,
    0xAE,0xF3,0xD7,0x40,0xB6,0x73,0x55,0x11,0xA1,0xD4, 0x06,0xC0,0x96,0x37,0x5D,0x80,
    0x47,0x91,0x45,0x20,0x99,0x46,0x66,0x3D,0x05,0xFA, 0xA4,0xB6,0x3D,0x01,0x00,0x01
    };

    byte tab_3[TABLEN_64] =
    {
    0x25,0xE7,0x7E,0x0D,0x2D,0x82,0x1B,0xF6,0x72,0xEA, 0xC8,0x26,0xBA,0xF5,0x55,0xB8,
    0x3B,0xEB,0xA8,0xB4,0x38,0x83,0x36,0x4D,0xD7,0xB8, 0xF1,0x54,0x0F,0x4D,0x1A,0x37,
    0x82,0x8E,0xD2,0xB9,0x9C,0x17,0x6D,0x8C,0x7E,0xA6, 0x61,0x0A,0x31,0x45,0xA3,0x29,
    0x69,0x22,0xB7,0x29,0xF0,0x35,0xC7,0x62,0x54,0x23, 0xF2,0x3F,0xDD,0x01,0x00,0x01
    };


    byte tab_4[TABLEN_64] =
    {
    0xC9,0x79,0xCB,0x88,0xDD,0xEE,0xDE,0x8B,0x10,0x19, 0x28,0xD4,0xB6,0xA2,0x48,0x9F,
    0xF2,0x68,0x5B,0x8A,0xDC,0x02,0x48,0xC4,0x2B,0xFE, 0xD2,0xC7,0xDC,0x6E,0x30,0x5D,
    0x11,0x81,0x55,0xE9,0xE9,0x6D,0x43,0x5D,0x0F,0x45, 0x70,0x5C,0x72,0x57,0xFE,0xDF,
    0x54,0xE6,0xC1,0x76,0x32,0x98,0xF4,0xD5,0x27,0x6E, 0xBE,0x40,0xA0,0x01,0x00,0x01
    };

    byte tab_5[TABLEN_64] =
    {
    0xF9,0x0C,0x1C,0xFB,0xE0,0x3B,0xBF,0xE9,0x44,0xD1, 0x6B,0x60,0x27,0xF8,0x9F,0xDF,
    0xAE,0xEB,0xFB,0xD4,0x1F,0x87,0x1F,0x54,0xFD,0x40, 0xED,0x11,0x7D,0xEF,0x1C,0x72,
    0x7C,0x8D,0xFF,0xCE,0x59,0x04,0x60,0xB4,0x2E,0x30, 0x42,0x65,0xF0,0x10,0x5F,0x52,
    0x7D,0x2B,0x9A,0x42,0xF3,0xAD,0x3C,0xD9,0xDD,0x49, 0x07,0x41,0x36,0x01,0x00,0x01
    };

    byte tab_6[TABLEN_64] =
    {
    0x11,0x89,0x79,0x12,0x7D,0xD8,0xA8,0x89,0x2F,0x62, 0x54,0x20,0x2F,0xEE,0xDD,0x64,
    0xB6,0x61,0x93,0xE7,0xFD,0xF8,0xFD,0xE1,0x20,0x84, 0x0D,0x91,0x52,0x0E,0xA4,0xFA,
    0xD3,0xD3,0x0A,0x0A,0x8B,0x7C,0xDC,0xCB,0x70,0x1E, 0xE1,0x04,0xE8,0x33,0xC7,0x00,
    0x1E,0x38,0xD4,0x2A,0xDD,0x5A,0x00,0x27,0xCC,0xDE, 0xB9,0xF8,0xCD,0x01,0x00,0x01
    };

    byte tab_7[TABLEN_64] =
    {
    0x21,0xD9,0xD6,0xC0,0x0D,0x31,0xBE,0x77,0xC2,0xCD, 0xBE,0xF8,0xE3,0xB2,0x2B,0xF7,
    0x16,0x07,0x83,0x57,0x5F,0x1A,0x68,0xB5,0xAF,0xE9, 0xEF,0x45,0x6C,0x09,0xFF,0x3A,
    0x00,0xD7,0x5C,0xB8,0x04,0x58,0x81,0x24,0x68,0xFB, 0x1E,0xDD,0x15,0x3B,0x0A,0xBD,
    0x0E,0xE7,0x03,0xF8,0x3F,0x0D,0x0C,0x2E,0xDF,0x7F, 0x8B,0x9B,0x52,0x01,0x00,0x01
    };

    byte tab_8[TABLEN_96] =
    {
    0x75,0x46,0xB3,0xD1,0xF3,0x2C,0xA0,0x0C,0xD8,0x2D, 0x7C,0x40,0xE0,0x99,0x36,0x76,
    0x23,0xF9,0x47,0x30,0x3F,0x8D,0x26,0x1B,0x0F,0x20, 0x43,0x60,0x15,0x67,0xAE,0xB4,
    0x6D,0x99,0xAA,0x5D,0x95,0x11,0xCF,0xFE,0xDB,0x54, 0xD1,0x7C,0x7B,0x51,0x26,0xD3,
    0x9F,0xAD,0x2E,0x44,0xC4,0x25,0xEE,0xB3,0x06,0x12, 0x88,0x7A,0x4E,0x19,0x23,0xA9,
    0xF5,0x33,0x2A,0xFE,0xB6,0xD9,0xFA,0xC0,0xE7,0x76, 0xD1,0xCD,0xC5,0xAF,0x71,0x68,
    0x34,0xE9,0xC8,0x3A,0x4E,0x4D,0xF6,0xE7,0xF3,0x99, 0x60,0xFC,0x80,0x01,0x00,0x01
    };

    byte tab_9[TABLEN_96] =
    {
    0x31,0x27,0xEB,0x22,0x37,0xD5,0x38,0xAB,0x33,0x29, 0xFD,0x5E,0x26,0x22,0xAE,0xF6,
    0x8F,0xE5,0xED,0x3E,0xB5,0xFB,0x95,0xDA,0x49,0x92, 0xD6,0xEB,0xE0,0xD2,0x26,0x43,
    0x7C,0x0F,0x62,0x3D,0xD9,0xCF,0xA7,0x47,0x63,0x2E, 0x03,0xDA,0xE3,0xAD,0x58,0x52,
    0xBB,0xDD,0xC4,0x10,0x6E,0x52,0xF0,0x71,0xC3,0xCE, 0x5D,0x93,0x11,0x03,0x89,0x84,
    0x07,0x68,0x32,0x5C,0x2F,0xB3,0x81,0x0F,0x25,0x29, 0x1A,0x19,0xB1,0xC8,0xA4,0xE8,
    0x61,0xF1,0x98,0xEA,0x70,0x4F,0xEB,0xB8,0xB4,0xF3, 0xB8,0x06,0x7F,0x01,0x00,0x01
    };

    byte tab_a[TABLEN_96] =
    {
    0x21,0x14,0x39,0xA6,0x78,0xF5,0x70,0xD1,0xEC,0xE2, 0x5A,0xBE,0x4A,0x5C,0x4F,0xD7,
    0xB4,0x33,0x25,0x93,0x7F,0x23,0x2F,0xD6,0x7A,0xCC, 0x6F,0xE7,0xE8,0x18,0x02,0x25,
    0x16,0x2C,0x07,0x3E,0xD3,0x62,0x61,0xA3,0x13,0x03, 0x29,0xE4,0x8D,0xBB,0x6F,0x66,
    0xF2,0x91,0xDE,0xDD,0xCD,0x59,0x61,0x94,0x90,0x0A, 0x53,0x67,0x2B,0x44,0x8A,0xD0,
    0x2F,0x11,0x1A,0x34,0xB2,0x07,0xDF,0x6B,0x9F,0xE9, 0x07,0x0B,0x22,0xB5,0x17,0x11,
    0x7A,0xCD,0x94,0xE4,0xAE,0x7F,0xEC,0x20,0xF0,0xCC, 0xFC,0x4F,0x97,0x01,0x00,0x01
    };

    byte tab_b[TABLEN_96] =
    {
    0x11,0xBA,0x15,0x2C,0x56,0xB9,0xBD,0x5F,0xA3,0x2C, 0x75,0x5D,0x2D,0x9A,0x11,0x8A,
    0xFA,0x71,0x70,0x64,0x82,0x1E,0x46,0xDB,0x3C,0xE9, 0x9D,0xFE,0xE6,0x26,0xBC,0xFE,
    0xEF,0x1C,0x7A,0x8C,0x9A,0x02,0xEB,0xF4,0xF6,0xE8, 0x6D,0x27,0xF0,0x8C,0xB2,0x4C,
    0x10,0xD5,0xD7,0xC7,0xD9,0x8A,0x35,0x70,0x97,0x43, 0x7D,0x9B,0xA9,0x2E,0x14,0x64,
    0x1C,0x10,0x3D,0xF9,0x19,0x96,0xFF,0xCD,0xA4,0xEA, 0x33,0xA7,0x8F,0x25,0x3D,0x37,
    0x0C,0xFB,0x74,0x1E,0xBF,0x74,0xC2,0x7E,0x54,0x7B, 0xDB,0xCF,0x43,0x01,0x00,0x01
    };

    byte tab_c[TABLEN_96] =
    {
    0x29,0xCC,0x51,0xC2,0xEE,0x5F,0x9F,0xEF,0x4B,0x0A, 0x92,0xEF,0x44,0x5C,0xC2,0xA7,
    0xBF,0xDE,0x0A,0x23,0x58,0x4F,0xBA,0xBC,0xBB,0x5A, 0x7E,0x5A,0x6F,0xCA,0xAC,0x9E,
    0x4B,0x48,0x8B,0x9F,0x8D,0x86,0xEC,0x7F,0x64,0xB0, 0xE1,0xEC,0x7F,0x80,0xAA,0x03,
    0x31,0x48,0x8D,0x2A,0x3C,0x1D,0xF2,0x75,0x75,0xFF, 0xEC,0x77,0xF1,0xD3,0x7D,0xAC,
    0xD0,0x06,0x49,0xD2,0x35,0x7E,0x10,0xB0,0x7C,0x2E, 0x07,0x0A,0x1A,0xCF,0x70,0x06,
    0x23,0x88,0xEC,0xFA,0xCB,0x9C,0x98,0x68,0x71,0xA0, 0x82,0xEE,0x2B,0x01,0x00,0x01
    };

    byte tab_d[TABLEN_96] =
    {
    0x0D,0xF9,0x08,0xEF,0xD4,0xD9,0x05,0x62,0x7C,0x92, 0x04,0x85,0x40,0x27,0x88,0x7B,
    0x60,0xC2,0xBB,0x10,0x61,0x32,0x0A,0x04,0xA4,0xFE, 0xEC,0x1C,0x2D,0x3C,0x62,0x4A,
    0xC2,0xB6,0xDA,0x88,0x90,0x25,0x24,0xD4,0x0E,0xBA, 0xEC,0x31,0xAA,0x19,0x1F,0x97,
    0x45,0xF5,0x6A,0x3C,0x1A,0xA9,0xA7,0xCF,0xC5,0x7C, 0xD2,0xE5,0x46,0x10,0xF6,0x99,
    0x57,0x90,0x54,0x00,0x45,0x87,0x79,0xD3,0xA1,0x25, 0x8D,0x8A,0xC1,0x17,0xE1,0x70,
    0x27,0x28,0x4A,0xE3,0xDA,0x5E,0xA9,0x41,0xA1,0x8F, 0xFD,0x1D,0x31,0x01,0x00,0x01
    };

    byte tab_e[TABLEN_96] =
    {
    0x45,0xEF,0xED,0xAC,0x77,0xA8,0x3D,0xA1,0x66,0x6C, 0x58,0xBD,0xD1,0x80,0x16,0x29,
    0x38,0x7C,0xE7,0x03,0xB0,0xD1,0x5E,0x89,0xC7,0xE7, 0xA3,0x77,0x50,0x35,0x8F,0xB7,
    0xA5,0x0C,0x70,0x79,0xAF,0x63,0xAD,0xF0,0x39,0xA1, 0xA6,0xEF,0x55,0x17,0x97,0x48,
    0x76,0xE1,0xB4,0x74,0xAA,0x6C,0x9A,0x32,0xDB,0xF1, 0xEC,0x70,0xC6,0x8B,0x96,0x78,
    0x69,0x70,0x13,0x0B,0x49,0x20,0xFE,0x69,0xDD,0x0F, 0x08,0x42,0x8F,0x04,0x45,0xEC,
    0x5D,0x48,0xAF,0x42,0x57,0x8C,0x27,0x62,0xB8,0xB7, 0x7F,0x34,0xC0,0x01,0x00,0x01
    };

    byte tab_f[TABLEN_96] =
    {
    0xE5,0xCD,0xA7,0x08,0xF9,0x82,0x2F,0x61,0x40,0xA0, 0xFA,0xF8,0x94,0x66,0xE5,0xDC,
    0xA6,0xFB,0x4F,0x53,0x24,0x20,0x2F,0xD3,0x43,0x4D, 0x73,0xA0,0x66,0x08,0x6A,0x94,
    0xAD,0x8D,0x51,0xFA,0x48,0x9D,0xA7,0xE8,0xB8,0xC8, 0xCB,0x94,0x6E,0x17,0x0C,0x21,
    0x4C,0xB6,0x7F,0xCC,0x59,0x4C,0x9C,0x9E,0xB5,0x86, 0x94,0xAA,0xDA,0xF3,0x79,0x69,
    0x34,0x8D,0xA5,0x55,0xD2,0xDE,0x0D,0x22,0xB9,0x49, 0x5C,0x88,0x96,0x7C,0x23,0x66,
    0xDE,0xA7,0x47,0x27,0xD3,0x42,0xC6,0x9B,0x58,0x04, 0xC9,0x07,0x35,0x01,0x00,0x01
    };

    byte tab_10[TABLEN_128] =
    {
    0x31,0x22,0x5C,0xB4,0x4A,0x6A,0xE2,0x0E,0x05,0x32, 0xC7,0x48,0x90,0xB3,0xB7,0x70,
    0xE1,0xA7,0x5E,0x19,0xB8,0x51,0xE1,0x67,0xD8,0xA3, 0xE5,0x68,0xCD,0x84,0x08,0x3D,
    0x25,0x8A,0xC7,0xA6,0x43,0x73,0x0F,0x53,0x7C,0xE4, 0xED,0x72,0x52,0x0A,0x8E,0x17,
    0x83,0x08,0xE2,0x64,0x4C,0xA6,0xF0,0x00,0xE3,0x4C, 0xFD,0xAB,0x20,0x88,0x8D,0xD5,
    0x39,0x9E,0x97,0x55,0x10,0x66,0xBD,0x04,0x42,0xBF, 0x3B,0x28,0x71,0x20,0xB3,0x7F,
    0x1A,0xD1,0xBE,0xFE,0x9D,0x8F,0x03,0x9E,0x10,0x0A, 0xC0,0xE6,0x40,0x17,0x15,0xE9,
    0xE9,0x87,0xCD,0xA1,0xDF,0xE1,0xD7,0x72,0xDD,0xDB, 0x52,0x0A,0x36,0xA2,0xC1,0xB1,
    0xAD,0x43,0x0F,0x70,0xAC,0xCB,0x26,0x61,0x7E,0xAC, 0xBD,0x29,0xBE,0x01,0x00,0x01
    };

    byte tab_11[TABLEN_128] =
    {
    0xF1,0xC2,0x43,0xDD,0x90,0x2D,0xC7,0x8E,0xEF,0x03, 0x16,0x7E,0x0E,0x13,0x5B,0x56,
    0xE2,0xB9,0x34,0xE8,0xF0,0xC5,0x20,0xA0,0x14,0x5D, 0x57,0xC2,0xE1,0x98,0xB1,0xBA,
    0x5B,0x72,0x80,0xEF,0xB3,0x20,0xFB,0xBA,0x93,0x49, 0xBA,0x67,0xE5,0x1E,0x2C,0x4A,
    0xE7,0xD3,0x6F,0x7F,0x60,0x4C,0x89,0x75,0x03,0x3E, 0x42,0x82,0x70,0xA9,0xA8,0x82,
    0xC1,0x7A,0x12,0xD2,0x17,0xE8,0x44,0x4B,0x63,0x02, 0x72,0x59,0x4A,0x54,0x6F,0x01,
    0x65,0x5D,0x9D,0xD5,0xB7,0x7A,0xBD,0x83,0xA5,0xF9, 0x6E,0xF7,0x84,0x69,0x7B,0x47,
    0x9C,0x1A,0xB0,0xDB,0x41,0x4C,0xA4,0xA3,0x3F,0x92, 0x59,0x30,0xD3,0x64,0x76,0x5F,
    0xF8,0x24,0xE6,0x3E,0x0E,0x02,0x2B,0x16,0xD1,0x1D, 0xF5,0xA9,0x88,0x01,0x00,0x01
    };

    byte tab_12[TABLEN_128] =
    {
    0xE9,0x46,0x96,0x7E,0xA9,0xE9,0x18,0x1B,0x01,0x0A, 0x26,0x93,0xAE,0xC3,0xE9,0x7E,
    0x41,0x39,0xEA,0xE6,0xE5,0xAF,0xBA,0xC2,0xD7,0x0B, 0xBB,0x22,0xA8,0x28,0x71,0xF0,
    0x99,0x4E,0x87,0xF7,0x6C,0xF5,0x43,0x4B,0x2B,0x2A, 0x5D,0x53,0x85,0xFB,0x3E,0xA3,
    0x84,0x77,0xD1,0xF7,0xF8,0xA3,0x6F,0x8A,0x2F,0xD5, 0x46,0x67,0xE1,0x61,0x94,0xDB,
    0x81,0x57,0xF8,0x61,0x83,0x5A,0xB9,0xE5,0xDB,0x8B, 0x3E,0x7D,0x21,0x0D,0x90,0x9F,
    0x26,0xF0,0x07,0x2E,0xB0,0xB6,0x70,0x00,0xA1,0x92, 0xA4,0x1E,0x69,0xEF,0xEA,0xA3,
    0xAE,0xF3,0xD7,0x40,0xB6,0x73,0x55,0x11,0xA1,0xD4, 0x06,0xC0,0x96,0x37,0x5D,0x80,
    0x47,0x91,0x45,0x20,0x99,0x46,0x66,0x3D,0x05,0xFA, 0xA4,0xB6,0x3D,0x01,0x00,0x01
    };

    byte tab_13[TABLEN_128] =
    {
    0x89,0x85,0x20,0x21,0x63,0x33,0x87,0xF1,0xD4,0x17, 0x2E,0x61,0xEC,0x16,0x5D,0xB2,
    0xDE,0x4D,0x8A,0x15,0xFF,0xD4,0x0F,0x18,0x5C,0x43, 0x9F,0xBC,0x8D,0xAF,0x83,0x22,
    0xEC,0x04,0x98,0x10,0x5C,0xE2,0xCE,0xB0,0xDB,0x7B, 0xD4,0x1B,0x85,0x47,0x16,0x05,
    0xC1,0x8A,0x2D,0xD1,0xB7,0x1E,0x5A,0x01,0x39,0xFF, 0xF8,0xA2,0x0B,0x2B,0xC2,0xDD,
    0x25,0xE7,0x7E,0x0D,0x2D,0x82,0x1B,0xF6,0x72,0xEA, 0xC8,0x26,0xBA,0xF5,0x55,0xB8,
    0x3B,0xEB,0xA8,0xB4,0x38,0x83,0x36,0x4D,0xD7,0xB8, 0xF1,0x54,0x0F,0x4D,0x1A,0x37,
    0x82,0x8E,0xD2,0xB9,0x9C,0x17,0x6D,0x8C,0x7E,0xA6, 0x61,0x0A,0x31,0x45,0xA3,0x29,
    0x69,0x22,0xB7,0x29,0xF0,0x35,0xC7,0x62,0x54,0x23, 0xF2,0x3F,0xDD,0x01,0x00,0x01
    };

    byte tab_HU_0[TABLEN_64] = //tab_H_0
    {
    0xB1,0xB5,0x0A,0x49,0x47,0x5A,0x3B,0xA5,0x6D,0x28, 0xE0,0x04,0xC2,0x3A,0x56,0xF7,
    0xE6,0x38,0xCE,0xE7,0x8B,0xE1,0xAD,0x8C,0x61,0x09, 0x06,0xDB,0xFE,0x11,0x4A,0xE3,
    0x6E,0x83,0xEF,0x57,0x49,0x61,0xFF,0x69,0x8F,0x61, 0xCD,0xD1,0x1E,0x9D,0x9C,0x16,
    0x72,0x72,0xE6,0x1D,0xF0,0x84,0x4F,0x4A,0x77,0x02, 0xD7,0xE8,0x39,0x01,0x00,0x01
    };

    byte tab_HU_1[TABLEN_64] = //tab_H_1
    {
    0x2D,0xE7,0x03,0xD1,0x83,0xB4,0xE1,0xC8,0x77,0xF0, 0x4A,0xF5,0xE4,0x9E,0x13,0xD5,
    0xCC,0xFD,0x63,0x19,0x13,0xDE,0xB5,0x1F,0x8B,0x31, 0xB0,0x4A,0x4A,0x8C,0x25,0x74,
    0x09,0x26,0x43,0xE5,0x3C,0xF4,0x45,0xD3,0xD8,0x28, 0xCE,0x0B,0xF5,0xC5,0x60,0x59,
    0x3D,0x97,0x27,0x8A,0x59,0x76,0x2D,0xD0,0xC2,0xC9, 0xCD,0x68,0xD4,0x01,0x00,0x01
    };

    byte tab_HU_2[TABLEN_64] =
    {
    0x11,0x90,0xA6,0x92,0x67,0xDB,0x0D,0xC1,0xFD,0x4B, 0x57,0xFA,0x31,0x3D,0x6C,0xCB,
    0x73,0x0E,0xA5,0xF6,0x81,0x3D,0xFA,0xE1,0x61,0x16, 0x4F,0x1A,0x9D,0xFD,0xDD,0x5D,
    0xC4,0xEF,0x6A,0x12,0x42,0xE9,0x3F,0x8B,0x31,0x4F, 0xB1,0x8A,0x77,0xF7,0x90,0xAE,
    0x04,0x9F,0xED,0xD6,0x12,0x26,0x7F,0xEC,0xAE,0xFC, 0x45,0x01,0x74,0x01,0x00,0x01
    };

    byte tab_HU_3[TABLEN_64] =
    {
    0x39,0xD7,0x88,0xAB,0x7B,0x31,0xF5,0xE2,0x7D,0x6B, 0x5A,0xCA,0xBB,0x9D,0xAC,0xE8,
    0x68,0xAC,0x05,0xEE,0x6A,0x3A,0x21,0x12,0x0C,0x05, 0x47,0x66,0x83,0x8D,0x5F,0xF0,
    0x6E,0x4F,0x9E,0x65,0x45,0x44,0x6E,0xF7,0x68,0xEE, 0x72,0x89,0x78,0xF4,0xE9,0x7D,
    0x41,0x68,0x4A,0x30,0x45,0x5D,0x6B,0x42,0xD1,0x02, 0x45,0x14,0x94,0x01,0x00,0x01
    };

    void print(byte *buf, int len);
    void cardcrypt(byte *key, byte *dat, byte *tab, byte TABLEN);
    void icamcrypt(byte *key, byte *dat, byte *tab, byte TABLEN);
    void scardcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN);
    void scamcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN);

    void print(byte *buf, int len)
    {
    int i;
    for (i = 0; i < len; i++) printf("%02X ", buf[i]); printf(" ");
    // printf("\n");
    }

    void cardcrypt(byte *key, byte *dat, byte *tab, byte TABLEN)
    {
    int i, j, k;
    byte index;

    for (i = 0; i < KEYLEN * 8; i++)
    {
    // print(key, KEYLEN); printf("* ");
    // print(dat, DATLEN); printf("\n");

    dat[(i+1) % DATLEN] += key[i % KEYLEN];

    index = dat[i % DATLEN] - key[(i+1) % KEYLEN];
    dat[(i+1) % DATLEN] ^= tab[index % TABLEN];

    index = (dat[i % DATLEN] ^ key[(i+1) % KEYLEN]) >> 2;
    dat[(i+1) % DATLEN] += (tab[index % TABLEN] << 1);


    //MSB of IRD[3] came into LSB of IRD[0]

    // rotate key[] 1 bit to left
    // +------------------+
    // +-- 39,38,37,36 <--+

    j = key[KEYLEN - 1];
    for (k = KEYLEN - 1; k >= 1; k--) key[k] = (key[k] << 1) + (key[k-1] >> 7);
    key[0] = (key[0] << 1) + (j >> 7);

    }
    }

    void icamcrypt(byte *key, byte *dat, byte *tab, byte TABLEN)
    {
    int i, j, k;
    byte index;

    for (i = (KEYLEN * 8) - 1; i >= 0; i--)
    {

    // rotate key[] 1 bit to right
    // +------------------+
    // +--> 39,38,37,36 --+

    j = key[0];
    for (k = 0; k < KEYLEN - 1; k++) key[k] = (key[k] >> 1) + (key[k+1] << 7);
    key[KEYLEN - 1] = (key[KEYLEN - 1] >> 1) + (j << 7);

    index = (dat[i % DATLEN] ^ key[(i+1) % KEYLEN]) >> 2;
    dat[(i+1) % DATLEN] -= (tab[index % TABLEN] << 1);

    index = dat[i % DATLEN] - key[(i+1) % KEYLEN];
    dat[(i+1) % DATLEN] ^= tab[index % TABLEN];

    dat[(i+1) % DATLEN] -= key[i % KEYLEN];

    // print(key, KEYLEN); printf("* ");
    // print(dat, DATLEN); printf("\n");
    }
    }


    ================================================== ================================================== ====

    algorithms

    void scardcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN)
    {
    int h = 62;
    int i, j, k, L, m, n, nn, hh;
    byte index, x, y, z;

    for (j = 0; j < KEYLEN; j++)
    {
    for (i = 0; i < DATLEN; i++)
    {
    if (algo == 0) nn = 2;
    if (algo == 1) nn = 3;
    if (algo == 2) nn = 1;
    n = (i + j + nn) % DATLEN;
    m = (i + j + 1) % KEYLEN;

    index = dat[i] + key[m];
    if (algo == 0) index = index >> 1;

    x = tab[index % TABLEN];
    index = dat[i] ^ x;
    y = tab[index % TABLEN];

    if (algo == 0) hh = hop0[h % 7];
    if (algo == 1) hh = hop1[h % 7];
    if (algo == 2) hh = hop2[h % 5];
    h++;
    z = ((y << hh) | (x >> (8 - hh))) & 0xFF;

    if (algo == 0) hh = hop0[h % 7];
    if (algo == 1) hh = hop1[h % 7];
    if (algo == 2) hh = hop2[h % 5];
    h++;
    x = ((x << hh) | (y >> (8 - hh))) & 0xFF;

    h -= 4;

    if (algo == 2) dat[n] ^= (x - z + i) & 0xFF;
    else dat[n] ^= (x - z) & 0xFF;

    L = key[KEYLEN - 1];
    for (k = KEYLEN - 1; k >= 1; k--) key[k] = (key[k] << 3) + (key[k-1] >> 5);
    key[0] = (key[0] << 3) + (L >> 5);
    }
    }//j
    }

    void scamcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN)
    {
    int h = 0; //algo_0/1/2, adjusted for algo_1/2
    int i, j, k, L, m, n, nn, hh;
    byte index, x, y, z;

    for (j = 3; j >= 0; j--)
    {
    for (i = 7; i >= 0; i--)
    {
    L = key[0];
    for (k = 0; k < KEYLEN - 1; k++) key[k] = (key[k] >> 3) + (key[k+1] << 5);
    key[KEYLEN - 1] = (key[KEYLEN - 1] >> 3) + (L << 5);

    if (algo == 0) nn = 2;
    if (algo == 1) nn = 3;
    if (algo == 2) nn = 1;
    n = (i + j + nn) % DATLEN;
    m = (i + j + 1) % KEYLEN;

    index = dat[i] + key[m];
    if (algo == 0) index = index >> 1;

    x = tab[index % TABLEN];
    index = dat[i] ^ x;
    y = tab[index % TABLEN];

    if (algo == 0) hh = hop0[h % 7];
    if (algo == 1) hh = hop1[h % 7];
    if (algo == 2) hh = hop2[h % 5];
    h++;
    z = ((y << hh) | (x >> (8 - hh))) & 0xFF;

    if (algo == 0) hh = hop0[h % 7];
    if (algo == 1) hh = hop1[h % 7];
    if (algo == 2) hh = hop2[h % 5];
    h++;
    x = ((x << hh) | (y >> (8 - hh))) & 0xFF;

    if (algo == 2) dat[n] ^= (x - z + i) & 0xFF;
    else dat[n] ^= (x - z) & 0xFF;
    }
    }
    }

    void main()
    {
    // int i;
    // byte b = tab_HU_2[62];
    // for (i = 0; i < 0x40; i++) printf("%02X ", tab_HU_2[i] ^ b);
    // return;

    // cardcrypt(box_id, cw, tab_HU_0, TABLEN_64);
    // printf("\n**************************************** ****\n");
    // print(box_id, KEYLEN); printf("* ");
    // print(cw, DATLEN); printf("\n");
    // printf("****************************************** **\n\n");
    // icamcrypt(box_id, cw, tab_HU_0, TABLEN_64);

    int algo = 2; //using algo_0/1/2

    scamcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
    printf("\n**************************************** ****\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_0, DATLEN); printf("\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_2, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_1, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_3, DATLEN); printf("\n");
    printf("****************************************** **\n");
    scardcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
    scardcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
    scardcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
    scardcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
    printf("\n**************************************** ****\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_0, DATLEN); printf("\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_2, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_1, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_3, DATLEN); printf("\n");
    printf("****************************************** **\n");
    scamcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
    scamcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
    printf("\n**************************************** ****\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_0, DATLEN); printf("\n");
    print(box_id_0, KEYLEN); printf("*0* ");
    print(cw_2, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_1, DATLEN); printf("\n");
    print(box_id_1, KEYLEN); printf("*1* ");
    print(cw_3, DATLEN); printf("\n");
    printf("****************************************** **\n");


    scardcrypt(algo, box_id, cw, tab_0, TABLEN_64);
    printf("\n**************************************** ****\n");
    print(box_id, KEYLEN); printf("*0* ");
    print(cw, DATLEN); printf("\n");
    printf("****************************************** **\n");
    scamcrypt(algo, box_id, cw, tab_0, TABLEN_64);
    printf("\n**************************************** ****\n");
    print(box_id, KEYLEN); printf("*0* ");
    print(cw, DATLEN); printf("\n");
    printf("****************************************** **\n");


    // printf("\n**************************************** ****\n");
    // print(box_id_0, KEYLEN); printf("*0* ");
    // print(cw_0, DATLEN); printf("\n");
    // print(box_id_1, KEYLEN); printf("*1* ");
    // print(cw_1, DATLEN); printf("\n");
    // printf("****************************************** **\n");


    }

    /*
    ;Wptr is -#9 by routine and -#4 by call
    ;+++++++++++++++++++++++++++++++++++++++++++++
    ;#0 : x: init with 1, then (-= 3 => -2; +7 => 5); 1 5 2 6 3 0 7 4
    ;#1 : i: 7..0
    ;#2 : m = (i+j+1) & 3, then value TAB[x]
    ;#3 : (CW[i] ^ TAB[x]) & $3F, then TAB[y]
    ;#4 : IRD_ID copied here
    ;#5 : TAB[y]
    ;#6 : n = (i+j+2) & 7
    ;#7 : j: 3..0
    ;#8 : PTR to table_?
    ;#9 : old Iptr
    ;#A : A = RAM base ?
    ;#B : B = ??? (encrypted CW)
    ;#C : C = PTR to IRD_ID
    ;#D - #0 : RAM start = 13C0
    ;#E - #1 : table_ID copied here
    ;#F - #2 : PTR to buffer (encrypted CW copied here)
    ;+++++++++++++++++++++++++++++++++++++++++++++



    000E18DD 60B7 sub_000E18DD: ajw -#9
    000E18DF 7D ldl #D
    000E18E0 53 ldnlp #3 ;13CC
    000E18E1 2CFA ls ;B = load sixteen = max LEN = $14
    000E18E3 7E ldl #E ;A = table_ID
    000E18E4 F9 gt ;A = TRUE if B > A
    000E18E5 21AF cj loc_E1906 ;jump if false (only 20 tables)
    000E18E7 7E ldl #E ;table_ID
    000E18E8 4C ldc #C ;size of each block in dwords
    000E18E9 F8 prod ;B: table_ID * 12
    000E18EA 7D ldl #D ;RAM start
    000E18EB 32 ldnl #2 ;A: PTR to 1000
    000E18EC FA wsub ;A=A+B*4
    000E18ED 35 ldnl #5 ;PTR to table_?
    000E18EE D8 stl #8
    000E18EF 7B ldl #B ;copy encrypted CW
    000E18F0 7F ldl #F ;to PTR in #F
    000E18F1 48 ldc #8
    000E18F2 24FA move
    000E18F4 7C ldl #C ;copy IRD_ID
    000E18F5 14 ldlp #4 ;to #4
    000E18F6 44 ldc #4
    000E18F7 24FA move
    000E18F9 43 ldc #3
    000E18FA D7 stl #7 ;j = 3
    000E18FB 41 ldc #1
    000E18FC D0 stl #0
    000E1909 47 loc_E1909: ldc #7
    000E190A D1 stl #1 ;i = 7
    000E1911 43 loc_E1911: ldc #3 ;C: 3
    000E1912 14 ldlp #4 ;B: IRD_ID
    000E1913 7A ldl #A ;A: RAM base
    000E1914 6C9E call sub_E1854 ;rotate IRD_ID

    000E1916 71 ldl #1 ;i
    000E1917 77 ldl #7 ;j
    000E1918 F2 bsub ;A=A+B
    000E1919 82 adc #2
    000E191A 47 ldc #7
    000E191B 24F6 and
    000E191D 2FF8 xsword ;sign extend 16 to 32
    000E191F D6 stl #6 ;n = (i+j+2) & 7

    000E1920 71 ldl #1 ;i
    000E1921 77 ldl #7 ;j
    000E1922 F2 bsub ;A=A+B
    000E1923 81 adc #1
    000E1924 43 ldc #3
    000E1925 24F6 and
    000E1927 2FF8 xsword
    000E1929 25FA dup
    000E192B D2 stl #2 ;m = (i+j+1) & 3

    000E192C 14 ldlp #4 ;IRD_ID
    000E192D F2 bsub
    000E192E F1 lb ;IRD[m]
    000E192F 71 ldl #1 ;i
    000E1930 7F ldl #F ;PTR to CW
    000E1931 F2 bsub
    000E1932 F1 lb ;CW[i]
    000E1933 F2 bsub ;A=A+B IRD[m] + CW[i]
    000E1934 42 ldc #2
    000E1935 24F6 and ;false if bit 1 is zero
    000E1937 21AE cj loc_E1957 ;jump if false
    000E1939 72 ldl #2 ;m
    000E193A 14 ldlp #4
    000E193B F2 bsub
    000E193C F1 lb ;IRD[m]
    000E193D 71 ldl #1
    000E193E 7F ldl #F
    000E193F F2 bsub
    000E1940 F1 lb ;CW[i]
    000E1941 F2 bsub ;A=A+B IRD[m] + CW[i]
    000E1942 41 ldc #1
    000E1943 24F0 shr ;>> 1
    000E1945 234F ldc #3F
    000E1947 24F6 and ;& $3F
    000E1949 41 ldc #1
    000E194A 24F0 shr ;>> 1 (this is nothing)
    000E194C 78 ldl #8 ;PTR to table_?
    000E194D 2CF1 ssub ;16 subscript
    000E194F 2CFA ls ;load 16
    000E1951 48 ldc #8
    000E1952 24F0 shr ;>>8
    000E1954 D2 stl #2 ;MSB
    000E1955 2109 j loc_E1970
    000E1957 72 loc_E1957: ldl #2 ;m
    000E1958 14 ldlp #4
    000E1959 F2 bsub
    000E195A F1 lb ;IRD[m]
    000E195B 71 ldl #1
    000E195C 7F ldl #F
    000E195D F2 bsub
    000E195E F1 lb ;CW[i]
    000E195F F2 bsub ;A=A+B IRD[m] + CW[i]
    000E1960 41 ldc #1
    000E1961 24F0 shr ;>> 1
    000E1963 234F ldc #3F
    000E1965 24F6 and ;& $3F
    000E1967 41 ldc #1
    000E1968 24F0 shr ;>> 1 (this is nothing)
    000E196A 78 ldl #8 ;PTR to table_?
    000E196B 2CF1 ssub ;16 subscript
    000E196D 2CFA ls ;load 16
    000E196F D2 stl #2 ;LSB
    000E1970 72 loc_E1970: ldl #2 ;TAB[x]
    000E1971 2F4F ldc #FF
    000E1973 24F6 and
    000E1975 D2 stl #2
    000E1976 71 ldl #1 ;i
    000E1977 7F ldl #F ;PTR to CW
    000E1978 F2 bsub
    000E1979 F1 lb ;CW[i]
    000E197A 72 ldl #2
    000E197B 23F3 xor ;^ TAB[x]
    000E197D 234F ldc #3F
    000E197F 24F6 and ;& $3F
    000E1981 25FA dup
    000E1983 D3 stl #3 ;(CW[i] ^ TAB[x]) & $3F
    000E1984 41 ldc #1 ;bit 0
    000E1985 24F6 and
    000E1987 AF cj loc_E1997 ;jump if bit 0 is zero
    000E1988 73 ldl #3 ;(CW[i] ^ TAB[x]) & $3F
    000E1989 41 ldc #1 ;(this is nothing)
    000E198A 24F0 shr
    000E198C 78 ldl #8 ;PTR to table_?
    000E198D 2CF1 ssub
    000E198F 2CFA ls
    000E1991 48 ldc #8
    000E1992 24F0 shr
    000E1994 D3 stl #3 ;MSB
    000E1995 0B j loc_E19A1
    000E1997 73 loc_E1997: ldl #3
    000E1998 41 ldc #1
    000E1999 24F0 shr ;(this is nothing)
    000E199B 78 ldl #8 ;PTR to table_?
    000E199C 2CF1 ssub
    000E199E 2CFA ls
    000E19A0 D3 stl #3 ;LSB
    000E19A1 73 loc_E19A1: ldl #3 ;TAB[y]
    000E19A2 2F4F ldc #FF
    000E19A4 24F6 and
    000E19A6 25FA dup
    000E19A8 D5 stl #5 ;store here
    000E19A9 70 ldl #0 ;was init with 1
    000E19AA 81 adc #1 ;+1
    000E19AB 24F1 shl ;TAB[y] << 2
    000E19AD 47 ldc #7
    000E19AE 70 ldl #0 ;still 1
    000E19AF F4 diff ;A=7-A => 6
    000E19B0 72 ldl #2 ;TAB[x]
    000E19B1 F0 rev ;swap A <-> B
    000E19B2 24F0 shr ;TAB[x] >> 6
    000E19B4 24FB or ;+
    000E19B6 2F4F ldc #FF
    000E19B8 24F6 and ;& $FF
    000E19BA D3 stl #3 ;store back modified TAB[y]
    000E19BB 70 ldl #0 ;x still 1
    000E19BC 608D adc -#3 ;adjust x
    000E19BE 2FF8 xsword
    000E19C0 D0 stl #0 ;store back
    000E19C1 40 ldc #0
    000E19C2 70 ldl #0
    000E19C3 F9 gt ;A = TRUE if 0 > -2
    000E19C4 A6 cj loc_E19CB ;jump if false
    000E19C6 70 ldl #0
    000E19C7 87 adc #7 ;-2 + 7 = 5
    000E19C8 2FF8 xsword
    000E19CA D0 stl #0 ;must be +
    000E19CB 72 loc_E19CB: ldl #2 ;TAB[x]
    000E19CC 70 ldl #0 ;x = 1 5 2 6 3 0 7 4
    000E19CD 81 adc #1
    000E19CE 24F1 shl ;TAB[x] << x+1
    000E19D0 47 ldc #7
    000E19D1 70 ldl #0
    000E19D2 F4 diff ;A=7-A => 0..7
    000E19D3 75 ldl #5 ;TAB[y]
    000E19D4 F0 rev
    000E19D5 24F0 shr ;TAB[y] >> 7-x
    000E19D7 24FB or ;+1
    000E19D9 2F4F ldc #FF
    000E19DB 24F6 and ;& $FF
    000E19DD D2 stl #2 ;store back modified TAB[x]
    000E19DE 70 ldl #0
    000E19DF 608D adc -#3 ;adjust x again
    000E19E1 2FF8 xsword
    000E19E3 D0 stl #0
    000E19E4 40 ldc #0
    000E19E5 70 ldl #0
    000E19E6 F9 gt
    000E19E7 A6 cj loc_E19EE
    000E19E9 70 ldl #0
    000E19EA 87 adc #7
    000E19EB 2FF8 xsword
    000E19ED D0 stl #0
    000E19EE 72 loc_E19EE: ldl #2 ;modified TAB[x]
    000E19EF 73 ldl #3 ;modified TAB[y]
    000E19F0 F4 diff ;A=B-A
    000E19F1 76 ldl #6 ;n
    000E19F2 7F ldl #F ;PTR to CW
    000E19F3 F2 bsub
    000E19F4 F1 lb ;CW[n]
    000E19F5 23F3 xor ;(TAB[x]-TAB[y]) ^ CW[n]
    000E19F7 76 ldl #6
    000E19F8 7F ldl #F
    000E19F9 F2 bsub
    000E19FA 23FB sb ;store back CW[n]
    000E19FC 71 ldl #1
    000E19FD 608F adc -#1 ;i--
    000E19FF 25FA dup
    000E1A01 D1 stl #1
    000E1A02 604F ldc -#1
    000E1A04 F9 gt
    000E1A05 A3 cj loc_E1A09
    000E1A07 6F08 j loc_E1911 ;inner loop
    000E1A09 77 loc_E1A09: ldl #7
    000E1A0A 608F adc -#1 ;j--
    000E1A0C 25FA dup
    000E1A0E D7 stl #7
    000E1A0F 604F ldc -#1
    000E1A11 F9 gt
    000E1A12 A4 cj loc_E1A17
    000E1A14 612F02 j loc_E1909 ;outer loop
    000E1A17 B9 loc_E1A17: ajw #9
    000E1A18 22F0 ret
    */

    /*
    v4 = 0x0001;
    v6 = 1; //len offset 1 or 2
    vv1 = 0x0000;
    TAB95[0] = 0;

    k = 0; //#5 //LSB or MSB ?

    while (k != v6) // do 1 or 2 times
    {
    temp = 0; //#0 //previous MSB
    v3 = OFSVAL[k]
    j = 0;
    i = k;

    temp = (TAB95[j] * v3 + temp + TAB101[i]) & 0xFFFF;
    TAB101[i] = (temp & 0xFF); //LSB
    temp = (temp >> 8) & 0xFF; //MSB
    j++;
    i++;

    while (temp != 0)
    {
    temp = (TAB101[i] + temp);
    TAB101[i] = (temp & 0xFF); //LSB
    temp = (temp >> 8) & 0xFF; //MSB
    i++;
    }

    k++;
    }
    store i to val##1;

    //questions left over:
    //- why is j not used
    //- TAB95[0] is 1, so why mul ?

    //this routine adds offs val depending on 96 bits if set

    */

    /*
    byte mm = 0x17;

    IRD[0] = box_id_1[0];
    IRD[1] = box_id_1[1];
    IRD[2] = box_id_1[2];
    IRD[3] = box_id_1[3];

    //80 00 00 07 03 06 11 09
    //80 00 01 07 03 06 50 09

    kk[0] = IRD[3] & 0x01;
    kk[0] |= IRD[0] & 0x80;
    if ((IRD[1] && 0x20) != 0) kk[0] |= 0x80;
    if ((IRD[1] && 0x80) != 0) kk[0] |= 0x80;
    if ((IRD[1] && 0x02) != 0) kk[0] |= 0x80;
    if ((IRD[1] && 0x04) != 0) kk[0] |= 0x80;
    kk[1] = 0;
    kk[3] = 0; //wasn't init
    if (IRD[3] && 0x10 != 0) kk[3] |= 0x07; else kk[3] |= 0x01;
    kk[2] = (IRD[3] & 0x02) >> 1;
    kk[4] = 3;
    kk[5] = 0;
    if ((IRD[2] && 0x40) != 0) kk[5] |= 0x02;
    if ((IRD[2] && 0x20) != 0) kk[5] |= 0x04;
    kk[6] = 0;
    kk[6] |= IRD[1] & 0x01;
    if ((IRD[1] && 0x08) != 0) kk[6] |= 0x10;
    kk[6] |= IRD[1] & 0x40;
    kk[7] = 0;
    if ((IRD[1] && 0x10) != 0) kk[7] |= 0x01;
    if ((IRD[2] && 0x80) != 0)
    {
    if (mm == 0x17) kk[7] |= 0x08; else kk[7] |= 0x20;
    }

    print(kk, DATLEN); printf("\n");

    return;
    */

    Yes confirm piracy bouquet Sky Italian operating under the protection of NDS
    And then reading the guide's full card but has not been raised soft organs
    www.zshare.net/download/13104719d8b3ab28/

  2. #2
    Moderator
    Join Date
    25-07-2006
    Posts
    535
    Uploads
    0

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    File is not downloading

  3. #3
    Member
    Join Date
    02-06-2008
    Location
    Holland
    Posts
    78
    Uploads
    0

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    Quote Originally Posted by zoltar25 View Post
    File is not downloading
    Download works fine

  4. #4

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    File download how this can be used I have an expired card!

  5. #5
    Banned ikramhasan's Avatar
    Join Date
    20-01-2008
    Location
    PAKISTAN
    Posts
    72
    Uploads
    0

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    any body help that what to do to open nds sys?

  6. #6

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    it's fake.

  7. #7

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    no trojan horse just a bunch of badly renamed text files (some that have been around since 2002) and some rehashed word docs that have been around since 2006.

    make of it what you want, it is what it is.

    BOB.SMITH

  8. #8
    New Member
    Join Date
    02-07-2006
    Posts
    6
    Uploads
    0

    Smile Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    Quote Originally Posted by bob.smith View Post
    no trojan horse just a bunch of badly renamed text files (some that have been around since 2002) and some rehashed word docs that have been around since 2006.

    make of it what you want, it is what it is.

    BOB.SMITH
    I would also say it is a fake and is one of the rehashed text file floating around. But it would be nice if it worked lol

  9. #9

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    does it work? how?

  10. #10
    Member RED B.'s Avatar
    Join Date
    19-03-2009
    Location
    Croatia
    Posts
    49
    Uploads
    0

    Re: Urgent: NDS system was piracy and Here's your version Khurzmih

    This info is fake.

Page 1 of 2 12 LastLast

Similar Threads

  1. new version for prio-chanell-provider version CARD-SHARE
    By programmer2 in forum CCcam Exchange: Local
    Replies: 4
    Last Post: 05-09-2009, 18:56:30
  2. 03/04/2008 nova gr prive version and besttt loader version 2.1
    By therapia in forum Greek / Ελληνικά
    Replies: 152
    Last Post: 23-07-2009, 10:30:10
  3. Update Piracy could cripple US DTH
    By <<ELVIS>> in forum Daily Satellite TV News
    Replies: 0
    Last Post: 17-03-2009, 10:34:27
  4. New 'Piracy is killing us'
    By <<ELVIS>> in forum Daily Satellite TV News
    Replies: 0
    Last Post: 04-06-2008, 09:16:46

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •