├── README.md ├── 0ctf2016 ├── Arsenal │ ├── data │ │ ├── flag.txt │ │ ├── key.txt │ │ ├── key.py │ │ └── output │ │ │ ├── output_parser.py │ │ │ └── output.txt │ ├── solution │ │ ├── key_reverse │ │ │ ├── key_reverse.cpp │ │ │ ├── AESFault.cpp │ │ │ └── AESFast.h │ │ ├── AESFault.cpp │ │ ├── attack.cpp │ │ ├── AESFast.h │ │ └── cipher.h │ └── src │ │ ├── crypto400.cpp │ │ ├── AESFault.cpp │ │ └── AESFast.h └── People's Square │ ├── data │ ├── flag.txt │ ├── key.txt │ ├── key.py │ └── output │ │ └── output_parser.py │ ├── solution │ ├── attack.cpp │ ├── key_reverse │ │ ├── key_reverse.cpp │ │ ├── AESFault.cpp │ │ └── AESFast.h │ ├── AESFault.cpp │ ├── AESFast.h │ └── cipher.h │ └── src │ ├── crypto300.cpp │ ├── AESFault.cpp │ └── AESFast.h ├── tmctf2016 └── defensive400 │ ├── file.enc │ └── enc.py └── uctf2016 ├── ciphertext.txt ├── attack ├── brute.h └── cipher.cpp └── test.c /README.md: -------------------------------------------------------------------------------- 1 | # CTF 2 | 3 | RomanGol's CTF problmes -------------------------------------------------------------------------------- /0ctf2016/Arsenal/data/flag.txt: -------------------------------------------------------------------------------- 1 | 0CTF{~~1MP0SS1BLE_1S_N0TH1NG!~~} -------------------------------------------------------------------------------- /0ctf2016/People's Square/data/flag.txt: -------------------------------------------------------------------------------- 1 | 0CTF{~R0MAN_l0VES_B10CK_C1PHER~} -------------------------------------------------------------------------------- /0ctf2016/Arsenal/data/key.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/romangol/CTF/HEAD/0ctf2016/Arsenal/data/key.txt -------------------------------------------------------------------------------- /tmctf2016/defensive400/file.enc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/romangol/CTF/HEAD/tmctf2016/defensive400/file.enc -------------------------------------------------------------------------------- /0ctf2016/People's Square/data/key.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/romangol/CTF/HEAD/0ctf2016/People's Square/data/key.txt -------------------------------------------------------------------------------- /0ctf2016/Arsenal/data/key.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | 3 | w = hashlib.md5() 4 | w.update(open("flag.txt").readline()) 5 | open("key.txt", "wb").write( w.digest() ) -------------------------------------------------------------------------------- /0ctf2016/People's Square/data/key.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | 3 | w = hashlib.md5() 4 | w.update(open("flag.txt").readline()) 5 | open("key.txt", "wb").write( w.digest() ) -------------------------------------------------------------------------------- /0ctf2016/Arsenal/data/output/output_parser.py: -------------------------------------------------------------------------------- 1 | data = open("output.txt").readlines() 2 | 3 | print "unsigned char zero[BLOCK * AMOUNT] = \n{" 4 | for i in xrange(512): 5 | #line = data[i * 7 + 5].split() 6 | line = data[i * 7 + 3].split() 7 | for x in line: 8 | print "0x%s,"%(x), 9 | print 10 | print "};" -------------------------------------------------------------------------------- /0ctf2016/People's Square/data/output/output_parser.py: -------------------------------------------------------------------------------- 1 | data = open("output.txt").readlines() 2 | 3 | print "unsigned char zero[BLOCK * AMOUNT] = \n{" 4 | for i in xrange(512): 5 | #line = data[i * 7 + 5].split() 6 | line = data[i * 7 + 3].split() 7 | for x in line: 8 | print "0x%s,"%(x), 9 | print 10 | print "};" -------------------------------------------------------------------------------- /uctf2016/ciphertext.txt: -------------------------------------------------------------------------------- 1 | char sample3_cipher[] = 2 | { 3 | 0x54,0x31,0xB5,0x1B,0xCF,0x8C,0x6E,0x7E, 4 | 0x87,0x6A,0xA3,0x24,0xEE,0x14,0x52,0x1C, 5 | 0x24,0x7E,0x0C,0xF8,0x47,0xEA,0xB1,0xC8, 6 | 0x3E,0x07,0x57,0x7E,0x27,0xA7,0x71,0xA3, 7 | 0x14,0xE4,0x70,0xD0,0x7F,0xA8,0x65,0x06, 8 | 0x45,0x23,0x57,0x14 9 | }; 10 | -------------------------------------------------------------------------------- /uctf2016/attack/brute.h: -------------------------------------------------------------------------------- 1 | #define EncByte(lastbyte, plain, key) sbox[(unsigned char) (plain ^ lastbyte ^ key)]; 2 | #define DecByte(lastbyte, cipher, key) (rsbox[(unsigned char) cipher] ^ lastbyte ^ key) 3 | 4 | 5 | void DecRound(char *cipher, int cipherlen, char *plain, char *IV, char *key, int keylen) 6 | { 7 | for(int i = cipherlen - 1; i >= 0; i--) 8 | { 9 | if(i == 0) 10 | { 11 | plain[i] = DecByte(*IV, cipher[i], key[i % keylen]); 12 | } 13 | else 14 | { 15 | plain[i] = DecByte(cipher[i - 1], cipher[i], key[i % keylen]); 16 | } 17 | } 18 | } 19 | 20 | 21 | 22 | void Decrypt(char *cipher, int cipherlen, char *plain, char *key, int keylen, int round) 23 | { 24 | for(int r = round - 1; r >= 0; r--) 25 | { 26 | if(r == 0) 27 | { 28 | DecRound(cipher, cipherlen, plain, key, key + 1, keylen - 1); 29 | } 30 | else 31 | { 32 | DecRound(cipher, cipherlen, cipher, cipher + cipherlen - 1, key + 1, keylen - 1); 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/attack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "AESFast.h" 5 | 6 | bool balance ( unsigned char * buffer, size_t pos ) 7 | { 8 | unsigned char z = 0; 9 | for ( size_t i = 0; i < 0x100; ++i ) 10 | { 11 | z ^= Sboxinv[ buffer[pos + i * 0x10] ]; // not z ^= buffer[pos + i * 0x10]; 12 | } 13 | 14 | return z == 0; 15 | } 16 | 17 | const static size_t AMOUNT = 0x200; 18 | const static size_t BLOCK = 0x10; 19 | 20 | #include "cipher.h" 21 | 22 | int main() 23 | { 24 | unsigned char buffer[BLOCK * AMOUNT]; 25 | unsigned char lastKey[BLOCK] = {0}; 26 | 27 | uint128 out; 28 | const static uint128 empty; 29 | 30 | for ( size_t pos = 0; pos < 16; ++pos ) 31 | { 32 | for ( size_t i = 0; i < 0x100; ++i ) 33 | { 34 | lastKey[pos] = i; 35 | for ( size_t j = 0; j < AMOUNT; ++j ) 36 | { 37 | out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(zero + j * BLOCK) ), _mm_loadu_si128( (uint128 *)(lastKey) ) ); 38 | _mm_storeu_si128( (uint128 *)(buffer + j * BLOCK), out ); 39 | } 40 | if ( balance( buffer, pos ) && balance( buffer + 0x1000, pos ) ) 41 | { 42 | printf( "key[%02x] is: %02x\n", pos, lastKey[pos] ); 43 | } 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/key_reverse/key_reverse.cpp: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | unsigned char key300[] = {0xf6, 0xf6, 0x01, 0xbb, 0x7b, 0x6a, 0xdf, 0x60, 0xd3, 0x66, 0xc0, 0xa7, 0x87, 0x24, 0xa6, 0x6b}; 4 | unsigned char key400[] = {0x8f, 0x12, 0xed, 0x70, 0x2e, 0xad, 0x24, 0x6e, 0x54, 0x94, 0xe7, 0x25, 0xf3, 0x04, 0xd7, 0x8b}; 5 | 6 | unsigned char cipher400[] = {0xa8, 0x8e, 0x94, 0x8e, 0x60, 0x73, 0x29, 0x70, 0x05, 0x28, 0x5e, 0x9d, 0xd6, 0xb1, 0x5e, 0x9f, 0x98, 0x10, 0x2c, 0x8f, 0xca, 0x68, 0x64, 0x74, 0xd1, 0x63, 0x38, 0xff, 0x73, 0x04, 0xb1, 0xa5}; 7 | unsigned char cipher300[] = {0xaf, 0x93, 0xce, 0xae, 0x1f, 0x1e, 0x7a, 0x13, 0x26, 0xd6, 0x05, 0x51, 0x97, 0x3c, 0x46, 0x1b, 0xc9, 0xb1, 0x56, 0x9c, 0x2c, 0xdf, 0xd5, 0x5a, 0xc6, 0xca, 0x33, 0x46, 0x31, 0xfb, 0x19, 0x73}; 8 | 9 | char cipher[33] = {0}; 10 | unsigned char key[16]; 11 | unsigned char lastkey[16]; 12 | 13 | memcpy(key, key400, 16); 14 | memcpy(cipher, cipher400, 32); 15 | 16 | aes128_key_schedule_inv_round(key, lastkey, 8); 17 | memcpy(key, lastkey, 16); 18 | aes128_key_schedule_inv_round(key, lastkey, 4); 19 | memcpy(key, lastkey, 16); 20 | aes128_key_schedule_inv_round(key, lastkey, 2); 21 | memcpy(key, lastkey, 16); 22 | aes128_key_schedule_inv_round(key, lastkey, 1); 23 | 24 | AESKey encKey; 25 | AESKey decKey; 26 | AES128_Key_Expansion( lastkey, encKey ); 27 | EncKey_to_DecKey( encKey, decKey, 4 ); 28 | 29 | uint128 u, v; 30 | u = _mm_loadu_si128( (uint128 *) (cipher) ); 31 | v = _mm_xor_si128(u, decKey[0]); 32 | v = _mm_aesdec_si128(v,decKey[1]); 33 | v = _mm_aesdec_si128(v,decKey[2]); 34 | v = _mm_aesdec_si128(v,decKey[3]); 35 | v = _mm_aesdeclast_si128(v,decKey[4]); 36 | _mm_storeu_si128((uint128 *)(cipher), v); 37 | 38 | u = _mm_loadu_si128( (uint128 *) (cipher + 16) ); 39 | v = _mm_xor_si128(u, decKey[0]); 40 | v = _mm_aesdec_si128(v,decKey[1]); 41 | v = _mm_aesdec_si128(v,decKey[2]); 42 | v = _mm_aesdec_si128(v,decKey[3]); 43 | v = _mm_aesdeclast_si128(v,decKey[4]); 44 | _mm_storeu_si128((uint128 *)(cipher + 16), v); 45 | } -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/key_reverse/key_reverse.cpp: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | unsigned char key300[] = {0xf6, 0xf6, 0x01, 0xbb, 0x7b, 0x6a, 0xdf, 0x60, 0xd3, 0x66, 0xc0, 0xa7, 0x87, 0x24, 0xa6, 0x6b}; 4 | unsigned char key400[] = {0x8f, 0x12, 0xed, 0x70, 0x2e, 0xad, 0x24, 0x6e, 0x54, 0x94, 0xe7, 0x25, 0xf3, 0x04, 0xd7, 0x8b}; 5 | 6 | unsigned char cipher400[] = {0xa8, 0x8e, 0x94, 0x8e, 0x60, 0x73, 0x29, 0x70, 0x05, 0x28, 0x5e, 0x9d, 0xd6, 0xb1, 0x5e, 0x9f, 0x98, 0x10, 0x2c, 0x8f, 0xca, 0x68, 0x64, 0x74, 0xd1, 0x63, 0x38, 0xff, 0x73, 0x04, 0xb1, 0xa5}; 7 | unsigned char cipher300[] = {0xaf, 0x93, 0xce, 0xae, 0x1f, 0x1e, 0x7a, 0x13, 0x26, 0xd6, 0x05, 0x51, 0x97, 0x3c, 0x46, 0x1b, 0xc9, 0xb1, 0x56, 0x9c, 0x2c, 0xdf, 0xd5, 0x5a, 0xc6, 0xca, 0x33, 0x46, 0x31, 0xfb, 0x19, 0x73}; 8 | 9 | char cipher[33] = {0}; 10 | unsigned char key[16]; 11 | unsigned char lastkey[16]; 12 | 13 | memcpy(key, key400, 16); 14 | memcpy(cipher, cipher400, 32); 15 | 16 | aes128_key_schedule_inv_round(key, lastkey, 8); 17 | memcpy(key, lastkey, 16); 18 | aes128_key_schedule_inv_round(key, lastkey, 4); 19 | memcpy(key, lastkey, 16); 20 | aes128_key_schedule_inv_round(key, lastkey, 2); 21 | memcpy(key, lastkey, 16); 22 | aes128_key_schedule_inv_round(key, lastkey, 1); 23 | 24 | AESKey encKey; 25 | AESKey decKey; 26 | AES128_Key_Expansion( lastkey, encKey ); 27 | EncKey_to_DecKey( encKey, decKey, 4 ); 28 | 29 | uint128 u, v; 30 | u = _mm_loadu_si128( (uint128 *) (cipher) ); 31 | v = _mm_xor_si128(u, decKey[0]); 32 | v = _mm_aesdec_si128(v,decKey[1]); 33 | v = _mm_aesdec_si128(v,decKey[2]); 34 | v = _mm_aesdec_si128(v,decKey[3]); 35 | v = _mm_aesdeclast_si128(v,decKey[4]); 36 | _mm_storeu_si128((uint128 *)(cipher), v); 37 | 38 | u = _mm_loadu_si128( (uint128 *) (cipher + 16) ); 39 | v = _mm_xor_si128(u, decKey[0]); 40 | v = _mm_aesdec_si128(v,decKey[1]); 41 | v = _mm_aesdec_si128(v,decKey[2]); 42 | v = _mm_aesdec_si128(v,decKey[3]); 43 | v = _mm_aesdeclast_si128(v,decKey[4]); 44 | _mm_storeu_si128((uint128 *)(cipher + 16), v); 45 | } -------------------------------------------------------------------------------- /0ctf2016/Arsenal/src/crypto400.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "AESFast.h" 5 | 6 | void output( unsigned char * input, size_t len ) 7 | { 8 | for ( size_t i = 0; i < len; ++i ) 9 | { 10 | printf("%02x ", input[i]); 11 | } 12 | puts(""); 13 | 14 | } 15 | 16 | void read_key(unsigned char *key) 17 | { 18 | FILE * fp = fopen("key.txt", "rb"); 19 | fread( key, 1, 16, fp ); 20 | fclose(fp); 21 | } 22 | 23 | void read_flag(unsigned char *flag) 24 | { 25 | FILE * fp = fopen("flag.txt", "r"); 26 | fread( flag, 1, 32, fp ); 27 | fclose(fp); 28 | } 29 | 30 | void enc( const AESKey & encKey, unsigned char *zero, unsigned char *one, size_t ctr, time_t timer ) 31 | { 32 | memset( zero, 0, 16 ); 33 | memset( one, 1, 16 ); 34 | 35 | memcpy( zero + 8, &ctr, 4 ); 36 | memcpy( one + 8, &ctr, 4 ); 37 | memcpy( zero + 12, &timer, 4 ); 38 | memcpy( one + 12, &timer, 4 ); 39 | 40 | 41 | AES128_block_enc( zero, encKey ); 42 | AES128_block_enc( one, encKey ); 43 | } 44 | 45 | int main() 46 | { 47 | unsigned char flag[32] = {0}; 48 | read_flag(flag); 49 | 50 | unsigned char key[16] = {0}; 51 | read_key(key); 52 | 53 | AESKey encKey; 54 | AES128_Key_Expansion( key, encKey ); 55 | 56 | unsigned char zero[16]; 57 | unsigned char one[16]; 58 | 59 | size_t counter = 0; 60 | time_t timer = time(0); 61 | for ( size_t ctr = 0; ctr < 0x40; ++ctr ) 62 | { 63 | enc( encKey, zero, one, ctr, timer ); 64 | 65 | unsigned int coin = rand() % 2; 66 | output( coin == 0 ? zero : one, BLOCK_SIZE ); 67 | 68 | puts("0 or 1?"); 69 | unsigned char choice = getchar() - 0x30; 70 | 71 | puts("ciphertext for 0 is: "); 72 | output( zero, BLOCK_SIZE ); 73 | puts("ciphertext for 1 is: "); 74 | output( one, BLOCK_SIZE ); 75 | 76 | if ( choice == coin ) 77 | { 78 | puts("Correct!"); 79 | ++counter; 80 | } 81 | else 82 | { 83 | puts( "Incorrect!" ); 84 | } 85 | } 86 | 87 | if ( 0x40 == counter ) 88 | { 89 | puts("Now I will give you the flag:"); 90 | AES128_block_enc( flag, encKey ); 91 | AES128_block_enc( flag + 16, encKey ); 92 | output(flag, sizeof(flag)); 93 | } 94 | } 95 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/src/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | void AES_128_Assist (uint128 & l, uint128 & r) 7 | { 8 | uint128 m; 9 | r = _mm_shuffle_epi32 (r ,0xff); 10 | m = _mm_slli_si128(l, 0x4); 11 | l = _mm_xor_si128(l, m); 12 | m = _mm_slli_si128(m, 0x4); 13 | l = _mm_xor_si128(l, m); 14 | m = _mm_slli_si128(m, 0x4); 15 | l = _mm_xor_si128(l, m); 16 | l = _mm_xor_si128(l, r); 17 | } 18 | 19 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 20 | { 21 | uint128 l, r; 22 | 23 | l = _mm_loadu_si128( (uint128 *)key ); 24 | 25 | _mm_storeu_si128(roundKeys + 0 , l); 26 | r = _mm_aeskeygenassist_si128(l, 1); 27 | AES_128_Assist(l, r); 28 | _mm_storeu_si128(roundKeys + 1 , l); 29 | r = _mm_aeskeygenassist_si128(l, 2); 30 | AES_128_Assist(l, r); 31 | _mm_storeu_si128(roundKeys + 2 , l); 32 | r = _mm_aeskeygenassist_si128(l, 4); 33 | AES_128_Assist(l, r); 34 | _mm_storeu_si128(roundKeys + 3 , l); 35 | r = _mm_aeskeygenassist_si128(l, 8); 36 | AES_128_Assist(l, r); 37 | _mm_storeu_si128(roundKeys + 4 , l); 38 | r = _mm_aeskeygenassist_si128(l, 0x10); 39 | AES_128_Assist(l, r); 40 | _mm_storeu_si128(roundKeys + 5 , l); 41 | r = _mm_aeskeygenassist_si128(l, 0x20); 42 | AES_128_Assist(l, r); 43 | _mm_storeu_si128(roundKeys + 6 , l); 44 | r = _mm_aeskeygenassist_si128(l, 0x40); 45 | AES_128_Assist(l, r); 46 | _mm_storeu_si128(roundKeys + 7 , l); 47 | r = _mm_aeskeygenassist_si128(l, 0x80); 48 | AES_128_Assist(l, r); 49 | _mm_storeu_si128(roundKeys + 8 , l); 50 | r = _mm_aeskeygenassist_si128(l, 0x1b); 51 | AES_128_Assist(l, r); 52 | _mm_storeu_si128(roundKeys + 9 , l); 53 | r = _mm_aeskeygenassist_si128(l, 0x36); 54 | AES_128_Assist(l, r); 55 | 56 | _mm_storeu_si128(roundKeys + 10, l); 57 | } 58 | 59 | 60 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 61 | { 62 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 63 | for ( size_t i = 1; i < ROUNDS; ++i ) 64 | { 65 | out = _mm_aesenc_si128(out, encKey[i]); 66 | } 67 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 68 | _mm_storeu_si128((uint128 *)(p), out); 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/src/crypto300.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "AESFast.h" 5 | 6 | void output( unsigned char * input, size_t len ) 7 | { 8 | for ( size_t i = 0; i < len; ++i ) 9 | { 10 | printf("%02x ", input[i]); 11 | } 12 | puts(""); 13 | 14 | } 15 | 16 | void read_key(unsigned char *key) 17 | { 18 | FILE * fp = fopen("key.txt", "rb"); 19 | fread( key, 1, 16, fp ); 20 | fclose(fp); 21 | } 22 | 23 | void read_flag(unsigned char *flag) 24 | { 25 | FILE * fp = fopen("flag.txt", "r"); 26 | fread( flag, 1, 32, fp ); 27 | fclose(fp); 28 | } 29 | 30 | void enc( const AESKey & encKey, unsigned char *zero, unsigned char *one, size_t ctr, time_t timer ) 31 | { 32 | memset( zero, 0, 16 ); 33 | memset( one, 1, 16 ); 34 | 35 | memcpy( zero + 8, &ctr, 4 ); 36 | memcpy( one + 8, &ctr, 4 ); 37 | memcpy( zero + 12, &timer, 4 ); 38 | memcpy( one + 12, &timer, 4 ); 39 | 40 | 41 | AES128_block_enc( zero, encKey ); 42 | AES128_block_enc( one, encKey ); 43 | } 44 | 45 | int main() 46 | { 47 | unsigned char flag[32] = {0}; 48 | read_flag(flag); 49 | 50 | unsigned char key[16] = {0}; 51 | read_key(key); 52 | 53 | AESKey encKey; 54 | AES128_Key_Expansion( key, encKey ); 55 | 56 | unsigned char zero[16]; 57 | unsigned char one[16]; 58 | 59 | size_t counter = 0; 60 | time_t timer = time(0); 61 | for ( size_t ctr = 0; ctr < 0x400; ++ctr ) 62 | { 63 | enc( encKey, zero, one, ctr, timer ); 64 | 65 | unsigned int coin = rand() % 2; 66 | output( coin == 0 ? zero : one, BLOCK_SIZE ); 67 | 68 | puts("0 or 1?"); 69 | unsigned char choice = getchar() - 0x30; 70 | 71 | puts("ciphertext for 0 is: "); 72 | output( zero, BLOCK_SIZE ); 73 | puts("ciphertext for 1 is: "); 74 | output( one, BLOCK_SIZE ); 75 | 76 | if ( choice == coin ) 77 | { 78 | puts("Correct!"); 79 | ++counter; 80 | } 81 | else 82 | { 83 | puts( "Incorrect!" ); 84 | } 85 | } 86 | 87 | if ( 0x400 == counter ) 88 | { 89 | puts("Now I will give you the flag:"); 90 | AES128_block_enc( flag, encKey ); 91 | AES128_block_enc( flag + 16, encKey ); 92 | output(flag, sizeof(flag)); 93 | } 94 | } 95 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | void AES_128_Assist (uint128 & l, uint128 & r) 7 | { 8 | uint128 m; 9 | r = _mm_shuffle_epi32 (r ,0xff); 10 | m = _mm_slli_si128(l, 0x4); 11 | l = _mm_xor_si128(l, m); 12 | m = _mm_slli_si128(m, 0x4); 13 | l = _mm_xor_si128(l, m); 14 | m = _mm_slli_si128(m, 0x4); 15 | l = _mm_xor_si128(l, m); 16 | l = _mm_xor_si128(l, r); 17 | } 18 | 19 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 20 | { 21 | uint128 l, r; 22 | 23 | l = _mm_loadu_si128( (uint128 *)key ); 24 | 25 | _mm_storeu_si128(roundKeys + 0 , l); 26 | r = _mm_aeskeygenassist_si128(l, 1); 27 | AES_128_Assist(l, r); 28 | _mm_storeu_si128(roundKeys + 1 , l); 29 | r = _mm_aeskeygenassist_si128(l, 2); 30 | AES_128_Assist(l, r); 31 | _mm_storeu_si128(roundKeys + 2 , l); 32 | r = _mm_aeskeygenassist_si128(l, 4); 33 | AES_128_Assist(l, r); 34 | _mm_storeu_si128(roundKeys + 3 , l); 35 | r = _mm_aeskeygenassist_si128(l, 8); 36 | AES_128_Assist(l, r); 37 | _mm_storeu_si128(roundKeys + 4 , l); 38 | r = _mm_aeskeygenassist_si128(l, 0x10); 39 | AES_128_Assist(l, r); 40 | _mm_storeu_si128(roundKeys + 5 , l); 41 | r = _mm_aeskeygenassist_si128(l, 0x20); 42 | AES_128_Assist(l, r); 43 | _mm_storeu_si128(roundKeys + 6 , l); 44 | r = _mm_aeskeygenassist_si128(l, 0x40); 45 | AES_128_Assist(l, r); 46 | _mm_storeu_si128(roundKeys + 7 , l); 47 | r = _mm_aeskeygenassist_si128(l, 0x80); 48 | AES_128_Assist(l, r); 49 | _mm_storeu_si128(roundKeys + 8 , l); 50 | r = _mm_aeskeygenassist_si128(l, 0x1b); 51 | AES_128_Assist(l, r); 52 | _mm_storeu_si128(roundKeys + 9 , l); 53 | r = _mm_aeskeygenassist_si128(l, 0x36); 54 | AES_128_Assist(l, r); 55 | 56 | _mm_storeu_si128(roundKeys + 10, l); 57 | } 58 | 59 | 60 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 61 | { 62 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 63 | for ( size_t i = 1; i < ROUNDS; ++i ) 64 | { 65 | out = _mm_aesenc_si128(out, encKey[i]); 66 | } 67 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 68 | _mm_storeu_si128((uint128 *)(p), out); 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/src/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | void AES_128_Assist (uint128 & l, uint128 & r) 7 | { 8 | uint128 m; 9 | r = _mm_shuffle_epi32 (r ,0xff); 10 | m = _mm_slli_si128(l, 0x4); 11 | l = _mm_xor_si128(l, m); 12 | m = _mm_slli_si128(m, 0x4); 13 | l = _mm_xor_si128(l, m); 14 | m = _mm_slli_si128(m, 0x4); 15 | l = _mm_xor_si128(l, m); 16 | l = _mm_xor_si128(l, r); 17 | } 18 | 19 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 20 | { 21 | uint128 l, r; 22 | 23 | l = _mm_loadu_si128( (uint128 *)key ); 24 | 25 | _mm_storeu_si128(roundKeys + 0 , l); 26 | r = _mm_aeskeygenassist_si128(l, 1); 27 | AES_128_Assist(l, r); 28 | _mm_storeu_si128(roundKeys + 1 , l); 29 | r = _mm_aeskeygenassist_si128(l, 2); 30 | AES_128_Assist(l, r); 31 | _mm_storeu_si128(roundKeys + 2 , l); 32 | r = _mm_aeskeygenassist_si128(l, 4); 33 | AES_128_Assist(l, r); 34 | _mm_storeu_si128(roundKeys + 3 , l); 35 | r = _mm_aeskeygenassist_si128(l, 8); 36 | AES_128_Assist(l, r); 37 | _mm_storeu_si128(roundKeys + 4 , l); 38 | r = _mm_aeskeygenassist_si128(l, 0x10); 39 | AES_128_Assist(l, r); 40 | _mm_storeu_si128(roundKeys + 5 , l); 41 | r = _mm_aeskeygenassist_si128(l, 0x20); 42 | AES_128_Assist(l, r); 43 | _mm_storeu_si128(roundKeys + 6 , l); 44 | r = _mm_aeskeygenassist_si128(l, 0x40); 45 | AES_128_Assist(l, r); 46 | _mm_storeu_si128(roundKeys + 7 , l); 47 | r = _mm_aeskeygenassist_si128(l, 0x80); 48 | AES_128_Assist(l, r); 49 | _mm_storeu_si128(roundKeys + 8 , l); 50 | r = _mm_aeskeygenassist_si128(l, 0x1b); 51 | AES_128_Assist(l, r); 52 | _mm_storeu_si128(roundKeys + 9 , l); 53 | r = _mm_aeskeygenassist_si128(l, 0x36); 54 | AES_128_Assist(l, r); 55 | 56 | _mm_storeu_si128(roundKeys + 10, l); 57 | } 58 | 59 | 60 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 61 | { 62 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 63 | for ( size_t i = 1; i < ROUNDS; ++i ) 64 | { 65 | out = _mm_aesenc_si128(out, encKey[i]); 66 | } 67 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 68 | _mm_storeu_si128((uint128 *)(p), out); 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/key_reverse/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | void AES_128_Assist (uint128 & l, uint128 & r) 7 | { 8 | uint128 m; 9 | r = _mm_shuffle_epi32 (r ,0xff); 10 | m = _mm_slli_si128(l, 0x4); 11 | l = _mm_xor_si128(l, m); 12 | m = _mm_slli_si128(m, 0x4); 13 | l = _mm_xor_si128(l, m); 14 | m = _mm_slli_si128(m, 0x4); 15 | l = _mm_xor_si128(l, m); 16 | l = _mm_xor_si128(l, r); 17 | } 18 | 19 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 20 | { 21 | uint128 l, r; 22 | 23 | l = _mm_loadu_si128( (uint128 *)key ); 24 | 25 | _mm_storeu_si128(roundKeys + 0 , l); 26 | r = _mm_aeskeygenassist_si128(l, 1); 27 | AES_128_Assist(l, r); 28 | _mm_storeu_si128(roundKeys + 1 , l); 29 | r = _mm_aeskeygenassist_si128(l, 2); 30 | AES_128_Assist(l, r); 31 | _mm_storeu_si128(roundKeys + 2 , l); 32 | r = _mm_aeskeygenassist_si128(l, 4); 33 | AES_128_Assist(l, r); 34 | _mm_storeu_si128(roundKeys + 3 , l); 35 | r = _mm_aeskeygenassist_si128(l, 8); 36 | AES_128_Assist(l, r); 37 | _mm_storeu_si128(roundKeys + 4 , l); 38 | r = _mm_aeskeygenassist_si128(l, 0x10); 39 | AES_128_Assist(l, r); 40 | _mm_storeu_si128(roundKeys + 5 , l); 41 | r = _mm_aeskeygenassist_si128(l, 0x20); 42 | AES_128_Assist(l, r); 43 | _mm_storeu_si128(roundKeys + 6 , l); 44 | r = _mm_aeskeygenassist_si128(l, 0x40); 45 | AES_128_Assist(l, r); 46 | _mm_storeu_si128(roundKeys + 7 , l); 47 | r = _mm_aeskeygenassist_si128(l, 0x80); 48 | AES_128_Assist(l, r); 49 | _mm_storeu_si128(roundKeys + 8 , l); 50 | r = _mm_aeskeygenassist_si128(l, 0x1b); 51 | AES_128_Assist(l, r); 52 | _mm_storeu_si128(roundKeys + 9 , l); 53 | r = _mm_aeskeygenassist_si128(l, 0x36); 54 | AES_128_Assist(l, r); 55 | 56 | _mm_storeu_si128(roundKeys + 10, l); 57 | } 58 | 59 | 60 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 61 | { 62 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 63 | for ( size_t i = 1; i < ROUNDS; ++i ) 64 | { 65 | out = _mm_aesenc_si128(out, encKey[i]); 66 | } 67 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 68 | _mm_storeu_si128((uint128 *)(p), out); 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/key_reverse/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | void AES_128_Assist (uint128 & l, uint128 & r) 7 | { 8 | uint128 m; 9 | r = _mm_shuffle_epi32 (r ,0xff); 10 | m = _mm_slli_si128(l, 0x4); 11 | l = _mm_xor_si128(l, m); 12 | m = _mm_slli_si128(m, 0x4); 13 | l = _mm_xor_si128(l, m); 14 | m = _mm_slli_si128(m, 0x4); 15 | l = _mm_xor_si128(l, m); 16 | l = _mm_xor_si128(l, r); 17 | } 18 | 19 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 20 | { 21 | uint128 l, r; 22 | 23 | l = _mm_loadu_si128( (uint128 *)key ); 24 | 25 | _mm_storeu_si128(roundKeys + 0 , l); 26 | r = _mm_aeskeygenassist_si128(l, 1); 27 | AES_128_Assist(l, r); 28 | _mm_storeu_si128(roundKeys + 1 , l); 29 | r = _mm_aeskeygenassist_si128(l, 2); 30 | AES_128_Assist(l, r); 31 | _mm_storeu_si128(roundKeys + 2 , l); 32 | r = _mm_aeskeygenassist_si128(l, 4); 33 | AES_128_Assist(l, r); 34 | _mm_storeu_si128(roundKeys + 3 , l); 35 | r = _mm_aeskeygenassist_si128(l, 8); 36 | AES_128_Assist(l, r); 37 | _mm_storeu_si128(roundKeys + 4 , l); 38 | r = _mm_aeskeygenassist_si128(l, 0x10); 39 | AES_128_Assist(l, r); 40 | _mm_storeu_si128(roundKeys + 5 , l); 41 | r = _mm_aeskeygenassist_si128(l, 0x20); 42 | AES_128_Assist(l, r); 43 | _mm_storeu_si128(roundKeys + 6 , l); 44 | r = _mm_aeskeygenassist_si128(l, 0x40); 45 | AES_128_Assist(l, r); 46 | _mm_storeu_si128(roundKeys + 7 , l); 47 | r = _mm_aeskeygenassist_si128(l, 0x80); 48 | AES_128_Assist(l, r); 49 | _mm_storeu_si128(roundKeys + 8 , l); 50 | r = _mm_aeskeygenassist_si128(l, 0x1b); 51 | AES_128_Assist(l, r); 52 | _mm_storeu_si128(roundKeys + 9 , l); 53 | r = _mm_aeskeygenassist_si128(l, 0x36); 54 | AES_128_Assist(l, r); 55 | 56 | _mm_storeu_si128(roundKeys + 10, l); 57 | } 58 | 59 | 60 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 61 | { 62 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 63 | for ( size_t i = 1; i < ROUNDS; ++i ) 64 | { 65 | out = _mm_aesenc_si128(out, encKey[i]); 66 | } 67 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 68 | _mm_storeu_si128((uint128 *)(p), out); 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /tmctf2016/defensive400/enc.py: -------------------------------------------------------------------------------- 1 | # Python bytecode 2.7 (disassembled from Python 2.7) 2 | 3 | # Embedded file name: 002.py 4 | # Compiled at: 2016-07-31 09:08:13 5 | import base64 6 | import os 7 | import random 8 | from Crypto import Random 9 | from Crypto.Cipher import AES 10 | from datetime import datetime 11 | 12 | class Ransom(object): 13 | def __init__(self, key, encFile): 14 | self.data = encFile 15 | if len(key) >= len(str(encFile)): 16 | self.key = key[:encFile] 17 | else: 18 | self.key = self.padding(key) 19 | 20 | def foo(self, data): 21 | data = self.padding(data) 22 | iv = Random.new().read(16) 23 | return base64.b64encode(iv + AES.new(self.key, AES.MODE_CBC, iv).encrypt(data)) 24 | 25 | def padding(self, key): 26 | return key + (self.data - len(key) % self.data) * chr(self.data - len(key) % self.data) 27 | 28 | 29 | def keyExpansion(k): 30 | orange = range(256) 31 | i = 0 32 | for j in xrange(256): 33 | i = (i + orange[j] + ord(k[j % len(k)])) % 256 34 | orange[j], orange[i] = orange[i], orange[j] 35 | return orange 36 | 37 | 38 | def rc4(state): 39 | i, j = (0, 0) 40 | while True: 41 | i = (i + 1) % 256 42 | j = (j + state[i]) % 256 43 | state[i], state[j] = state[j], state[i] 44 | stream = state[(state[i] + state[j]) % 256] 45 | yield stream 46 | 47 | def rc4_enc(input, k): 48 | keyStream = rc4( keyExpansion(k) ) 49 | input = bytearray(input) 50 | output = bytearray((i ^ il for i, il in zip(input, keyStream))) 51 | return str(output) 52 | 53 | 54 | inputData = open('.\\file', 'rb').read() 55 | encFile = open('.\\file.enc', 'wb') 56 | 57 | logan = 'TrEndMicRo' 58 | k = '' 59 | for i in range(5): 60 | k = k + random.choice(logan) 61 | k = '!' + k + k + k + k + k + k + '!' 62 | 63 | encryptor = Ransom(k, 32) 64 | 65 | peach = '' 66 | watermelon = datetime.now() 67 | peach = peach + watermelon.strftime('%Y') 68 | peach = peach + watermelon.strftime('%d') 69 | peach = peach + watermelon.strftime('%m') 70 | 71 | for i in xrange(10): 72 | grape = encryptor.foo(inputData) 73 | plum = rc4_enc(grape, peach) 74 | inputData = plum 75 | 76 | encFile.write(plum) 77 | encFile.close() 78 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/attack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "AESFast.h" 5 | 6 | 7 | const static size_t AMOUNT = 63; 8 | const static size_t BLOCK = 0x10; 9 | 10 | bool impossible ( unsigned char * buffer, size_t pos ) 11 | { 12 | unsigned char flags[0x100]; 13 | memset(flags, 0, 0x100); 14 | 15 | for ( size_t i = 0; i < AMOUNT; ++i ) 16 | { 17 | if ( flags[ buffer[i * BLOCK + pos] ] == 0 ) 18 | flags[ buffer[i * BLOCK + pos] ] = 1; 19 | else 20 | return false; 21 | } 22 | 23 | return true; 24 | } 25 | 26 | #include "cipher.h" 27 | 28 | int main() 29 | { 30 | unsigned char buffer[BLOCK * AMOUNT]; 31 | unsigned char lastKey[BLOCK] = {0}; 32 | 33 | uint128 out; 34 | const static uint128 empty; 35 | 36 | time_t timer = time(0); 37 | for ( size_t i = 0x00000000; i < 0xffffffff; ++i ) 38 | { 39 | lastKey[0] = (i >> 24); 40 | lastKey[7] = (i >> 16); 41 | lastKey[10] = (i >> 8); 42 | lastKey[13] = (i); 43 | lastKey[1] = (i >> 24); 44 | lastKey[4] = (i >> 16); 45 | lastKey[11] = (i >> 8); 46 | lastKey[14] = (i); 47 | lastKey[2] = (i >> 24); 48 | lastKey[5] = (i >> 16); 49 | lastKey[8] = (i >> 8); 50 | lastKey[15] = (i); 51 | lastKey[3] = (i >> 24); 52 | lastKey[6] = (i >> 16); 53 | lastKey[9] = (i >> 8); 54 | lastKey[12] = (i); 55 | 56 | for ( size_t j = 0; j < AMOUNT; ++j ) 57 | { 58 | out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(zero + j * BLOCK) ), _mm_loadu_si128( (uint128 *)(lastKey) ) ); 59 | out = _mm_aesdec_si128( out, empty ); 60 | _mm_storeu_si128( (uint128 *)(buffer + j * BLOCK), out ); 61 | } 62 | if ( impossible( buffer, 0 ) && impossible( buffer, 1 ) && impossible( buffer, 2 ) && impossible( buffer, 3 )) 63 | { 64 | printf( "key[0, 7, 10, 13] is: %08x\n", i ); 65 | } 66 | if ( impossible( buffer, 4 ) && impossible( buffer, 5 ) && impossible( buffer, 6 ) && impossible( buffer, 7 )) 67 | { 68 | printf( "key[1, 4, 11, 14] is: %08x\n", i ); 69 | } 70 | if ( impossible( buffer, 8 ) && impossible( buffer, 9 ) && impossible( buffer, 10 ) && impossible( buffer, 11 )) 71 | { 72 | printf( "key[2, 5, 8, 15] is: %08x\n", i ); 73 | } 74 | if ( impossible( buffer, 12 ) && impossible( buffer, 13 ) && impossible( buffer, 14 ) && impossible( buffer, 15 )) 75 | { 76 | printf( "key[3, 6, 9, 12] is: %08x\n", i ); 77 | } 78 | } 79 | 80 | printf("%d minutes\n", (time(0) - timer) / 60 ); 81 | } 82 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/src/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | 7 | static const unsigned char Sboxinv[256] = { 8 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 9 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 10 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 11 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 12 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 13 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 14 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 15 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 16 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 17 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 18 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 19 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 20 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 21 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 22 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 23 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 24 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 25 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 26 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 27 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 28 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 29 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 30 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 31 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 32 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 33 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 34 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 35 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 36 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 37 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 38 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 39 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 40 | }; 41 | 42 | 43 | typedef unsigned char uint8; 44 | typedef __m128i uint128; 45 | 46 | enum 47 | { 48 | BLOCK_SIZE = 16, 49 | KEY128_SIZE = 16, 50 | KEY192_SIZE = 24, 51 | KEY256_SIZE = 32, 52 | AES128_ROUNDS = 10, 53 | AES192_ROUNDS = 12, 54 | AES256_ROUNDS = 14, 55 | }; 56 | 57 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 58 | 59 | void AES_128_Assist (uint128 & l, uint128 & r); 60 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 61 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | 7 | static const unsigned char Sboxinv[256] = { 8 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 9 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 10 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 11 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 12 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 13 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 14 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 15 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 16 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 17 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 18 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 19 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 20 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 21 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 22 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 23 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 24 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 25 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 26 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 27 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 28 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 29 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 30 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 31 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 32 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 33 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 34 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 35 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 36 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 37 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 38 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 39 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 40 | }; 41 | 42 | 43 | typedef unsigned char uint8; 44 | typedef __m128i uint128; 45 | 46 | enum 47 | { 48 | BLOCK_SIZE = 16, 49 | KEY128_SIZE = 16, 50 | KEY192_SIZE = 24, 51 | KEY256_SIZE = 32, 52 | AES128_ROUNDS = 10, 53 | AES192_ROUNDS = 12, 54 | AES256_ROUNDS = 14, 55 | }; 56 | 57 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 58 | 59 | void AES_128_Assist (uint128 & l, uint128 & r); 60 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 61 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/src/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | 7 | static const unsigned char Sboxinv[256] = { 8 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 9 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 10 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 11 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 12 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 13 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 14 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 15 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 16 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 17 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 18 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 19 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 20 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 21 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 22 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 23 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 24 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 25 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 26 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 27 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 28 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 29 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 30 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 31 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 32 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 33 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 34 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 35 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 36 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 37 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 38 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 39 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 40 | }; 41 | 42 | 43 | typedef unsigned char uint8; 44 | typedef __m128i uint128; 45 | 46 | enum 47 | { 48 | BLOCK_SIZE = 16, 49 | KEY128_SIZE = 16, 50 | KEY192_SIZE = 24, 51 | KEY256_SIZE = 32, 52 | AES128_ROUNDS = 10, 53 | AES192_ROUNDS = 12, 54 | AES256_ROUNDS = 14, 55 | }; 56 | 57 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 58 | 59 | void AES_128_Assist (uint128 & l, uint128 & r); 60 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 61 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/key_reverse/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | 7 | static const unsigned char Sboxinv[256] = { 8 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 9 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 10 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 11 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 12 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 13 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 14 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 15 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 16 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 17 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 18 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 19 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 20 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 21 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 22 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 23 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 24 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 25 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 26 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 27 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 28 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 29 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 30 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 31 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 32 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 33 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 34 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 35 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 36 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 37 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 38 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 39 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 40 | }; 41 | 42 | 43 | typedef unsigned char uint8; 44 | typedef __m128i uint128; 45 | 46 | enum 47 | { 48 | BLOCK_SIZE = 16, 49 | KEY128_SIZE = 16, 50 | KEY192_SIZE = 24, 51 | KEY256_SIZE = 32, 52 | AES128_ROUNDS = 10, 53 | AES192_ROUNDS = 12, 54 | AES256_ROUNDS = 14, 55 | }; 56 | 57 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 58 | 59 | void AES_128_Assist (uint128 & l, uint128 & r); 60 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 61 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/key_reverse/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | 7 | static const unsigned char Sboxinv[256] = { 8 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 9 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 10 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 11 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 12 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 13 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 14 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 15 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 16 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 17 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 18 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 19 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 20 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 21 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 22 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 23 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 24 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 25 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 26 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 27 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 28 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 29 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 30 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 31 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 32 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 33 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 34 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 35 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 36 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 37 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 38 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 39 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 40 | }; 41 | 42 | 43 | typedef unsigned char uint8; 44 | typedef __m128i uint128; 45 | 46 | enum 47 | { 48 | BLOCK_SIZE = 16, 49 | KEY128_SIZE = 16, 50 | KEY192_SIZE = 24, 51 | KEY256_SIZE = 32, 52 | AES128_ROUNDS = 10, 53 | AES192_ROUNDS = 12, 54 | AES256_ROUNDS = 14, 55 | }; 56 | 57 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 58 | 59 | void AES_128_Assist (uint128 & l, uint128 & r); 60 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 61 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/AESFault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "AESFast.h" 3 | 4 | static const size_t ROUNDS = 4; 5 | 6 | /* rcon for the round must be provided, out of the sequence: 7 | * 54, 27, 128, 64, 32, 16, 8, 4, 2, 1 8 | * Subsequent values can be calculated with aes_div2(). 9 | */ 10 | void aes128_key_schedule_inv_round( unsigned char * thisKey, unsigned char * lastKey, unsigned char rcon ) 11 | { 12 | for ( size_t i = 0; i < 3; ++i ) 13 | { 14 | /* XOR in previous word */ 15 | lastKey[15 - i * 4 - 0] = thisKey[15 - i * 4 - 0] ^ thisKey[15 - i * 4 - 4]; 16 | lastKey[15 - i * 4 - 1] = thisKey[15 - i * 4 - 1] ^ thisKey[15 - i * 4 - 5]; 17 | lastKey[15 - i * 4 - 2] = thisKey[15 - i * 4 - 2] ^ thisKey[15 - i * 4 - 6]; 18 | lastKey[15 - i * 4 - 3] = thisKey[15 - i * 4 - 3] ^ thisKey[15 - i * 4 - 7]; 19 | } 20 | 21 | lastKey[0] = thisKey[0] ^ sbox[ lastKey[13] ] ^ rcon; 22 | lastKey[1] = thisKey[1] ^ sbox[ lastKey[14] ]; 23 | lastKey[2] = thisKey[2] ^ sbox[ lastKey[15] ]; 24 | lastKey[3] = thisKey[3] ^ sbox[ lastKey[12] ]; 25 | 26 | } 27 | 28 | void EncKey_to_DecKey(const AESKey & encKey, AESKey & decKey, size_t rounds) 29 | { 30 | decKey[rounds] = encKey[0]; 31 | 32 | for ( size_t i = 0; i < rounds - 1; ++i ) 33 | { 34 | decKey[rounds - i - 1] = _mm_aesimc_si128(encKey[1 + i]); 35 | } 36 | 37 | decKey[0] = encKey[rounds]; 38 | } 39 | 40 | void AES_128_Assist (uint128 & l, uint128 & r) 41 | { 42 | uint128 m; 43 | r = _mm_shuffle_epi32 (r ,0xff); 44 | m = _mm_slli_si128(l, 0x4); 45 | l = _mm_xor_si128(l, m); 46 | m = _mm_slli_si128(m, 0x4); 47 | l = _mm_xor_si128(l, m); 48 | m = _mm_slli_si128(m, 0x4); 49 | l = _mm_xor_si128(l, m); 50 | l = _mm_xor_si128(l, r); 51 | } 52 | 53 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys) 54 | { 55 | uint128 l, r; 56 | 57 | l = _mm_loadu_si128( (uint128 *)key ); 58 | 59 | _mm_storeu_si128(roundKeys + 0 , l); 60 | r = _mm_aeskeygenassist_si128(l, 1); 61 | AES_128_Assist(l, r); 62 | _mm_storeu_si128(roundKeys + 1 , l); 63 | r = _mm_aeskeygenassist_si128(l, 2); 64 | AES_128_Assist(l, r); 65 | _mm_storeu_si128(roundKeys + 2 , l); 66 | r = _mm_aeskeygenassist_si128(l, 4); 67 | AES_128_Assist(l, r); 68 | _mm_storeu_si128(roundKeys + 3 , l); 69 | r = _mm_aeskeygenassist_si128(l, 8); 70 | AES_128_Assist(l, r); 71 | _mm_storeu_si128(roundKeys + 4 , l); 72 | r = _mm_aeskeygenassist_si128(l, 0x10); 73 | AES_128_Assist(l, r); 74 | _mm_storeu_si128(roundKeys + 5 , l); 75 | r = _mm_aeskeygenassist_si128(l, 0x20); 76 | AES_128_Assist(l, r); 77 | _mm_storeu_si128(roundKeys + 6 , l); 78 | r = _mm_aeskeygenassist_si128(l, 0x40); 79 | AES_128_Assist(l, r); 80 | _mm_storeu_si128(roundKeys + 7 , l); 81 | r = _mm_aeskeygenassist_si128(l, 0x80); 82 | AES_128_Assist(l, r); 83 | _mm_storeu_si128(roundKeys + 8 , l); 84 | r = _mm_aeskeygenassist_si128(l, 0x1b); 85 | AES_128_Assist(l, r); 86 | _mm_storeu_si128(roundKeys + 9 , l); 87 | r = _mm_aeskeygenassist_si128(l, 0x36); 88 | AES_128_Assist(l, r); 89 | 90 | _mm_storeu_si128(roundKeys + 10, l); 91 | } 92 | 93 | 94 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ) 95 | { 96 | uint128 out = _mm_xor_si128( _mm_loadu_si128( (uint128 *)(p) ), encKey[0] ); 97 | for ( size_t i = 1; i < ROUNDS; ++i ) 98 | { 99 | out = _mm_aesenc_si128(out, encKey[i]); 100 | } 101 | out = _mm_aesenclast_si128(out, encKey[ROUNDS]); 102 | _mm_storeu_si128((uint128 *)(p), out); 103 | } 104 | 105 | 106 | 107 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/AESFast.h: -------------------------------------------------------------------------------- 1 | #ifndef _AES_FAST_ 2 | #define _AES_FAST_ 3 | 4 | #include 5 | 6 | static const unsigned char sbox[256] = 7 | { 8 | 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 9 | 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 10 | 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 11 | 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 12 | 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 13 | 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 14 | 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 15 | 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 16 | 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 17 | 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 18 | 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 19 | 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 20 | 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 21 | 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 22 | 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 23 | 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 24 | }; 25 | 26 | static const unsigned char Sboxinv[256] = { 27 | 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 28 | 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 29 | 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 30 | 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 31 | 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 32 | 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 33 | 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 34 | 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 35 | 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 36 | 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 37 | 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 38 | 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 39 | 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 40 | 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 41 | 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 42 | 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 43 | 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 44 | 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 45 | 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 46 | 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 47 | 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 48 | 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 49 | 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 50 | 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 51 | 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 52 | 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 53 | 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 54 | 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 55 | 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 56 | 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 57 | 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 58 | 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 59 | }; 60 | 61 | 62 | typedef unsigned char uint8; 63 | typedef __m128i uint128; 64 | 65 | enum 66 | { 67 | BLOCK_SIZE = 16, 68 | KEY128_SIZE = 16, 69 | KEY192_SIZE = 24, 70 | KEY256_SIZE = 32, 71 | AES128_ROUNDS = 10, 72 | AES192_ROUNDS = 12, 73 | AES256_ROUNDS = 14, 74 | }; 75 | 76 | typedef uint128 AESKey[AES256_ROUNDS + 1]; 77 | 78 | void AES_128_Assist (uint128 & l, uint128 & r); 79 | void AES128_Key_Expansion(const uint8 key[KEY128_SIZE], AESKey & roundKeys); 80 | void AES128_block_enc( unsigned char * p, const AESKey & encKey ); 81 | void EncKey_to_DecKey(const AESKey & encKey, AESKey & decKey, size_t rounds); 82 | void aes128_key_schedule_inv_round( unsigned char * thisKey, unsigned char * lastKey, unsigned char rcon ); 83 | 84 | #endif 85 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/solution/cipher.h: -------------------------------------------------------------------------------- 1 | unsigned char zero[BLOCK * AMOUNT] = 2 | { 3 | 0x95, 0xe7, 0x55, 0xa6, 0xc6, 0xa4, 0x19, 0x23, 0xeb, 0x79, 0x81, 0x63, 0x04, 0x66, 0x2d, 0x81, 4 | 0xa5, 0xa6, 0x30, 0xdd, 0x71, 0xc4, 0x76, 0xee, 0x6f, 0x0a, 0x47, 0xaa, 0xe7, 0x01, 0xe6, 0xd4, 5 | 0xe6, 0x3c, 0xbf, 0x29, 0xf1, 0xb2, 0xc8, 0xac, 0x68, 0x1f, 0x39, 0x16, 0x69, 0x35, 0x79, 0x95, 6 | 0x6a, 0xb1, 0x10, 0x2a, 0xcd, 0xdd, 0x7f, 0x8b, 0x35, 0x1c, 0xfc, 0x88, 0xe0, 0x0c, 0x2d, 0x6f, 7 | 0xee, 0x4b, 0x03, 0x35, 0x34, 0xd8, 0x39, 0x6d, 0x78, 0xcb, 0x08, 0xb1, 0x61, 0xbf, 0x8c, 0xf2, 8 | 0x3e, 0x16, 0xa6, 0x25, 0x1d, 0x3c, 0x87, 0x11, 0x78, 0x41, 0xdb, 0x76, 0xe2, 0xde, 0x6d, 0x92, 9 | 0x40, 0x1d, 0xf2, 0x40, 0xed, 0x39, 0x06, 0x72, 0x8f, 0x55, 0x85, 0xe2, 0x0b, 0x4c, 0x6c, 0x61, 10 | 0xfc, 0x86, 0x57, 0x11, 0xed, 0xdc, 0x9d, 0x7a, 0x6e, 0x37, 0x6b, 0xe4, 0xcb, 0xb6, 0x93, 0x28, 11 | 0xc6, 0x1d, 0x9d, 0x17, 0x0f, 0xc8, 0xc9, 0xc9, 0xaa, 0xf1, 0xfd, 0xb5, 0xda, 0x27, 0x3d, 0x65, 12 | 0xcd, 0xf3, 0xe2, 0x9e, 0x5f, 0x26, 0xaf, 0x3f, 0xed, 0x23, 0x71, 0xb8, 0xda, 0x03, 0x09, 0xd7, 13 | 0x20, 0x48, 0x95, 0xab, 0x2f, 0xc1, 0x4f, 0xdd, 0xc5, 0x3e, 0x43, 0x5d, 0x86, 0xc7, 0x4c, 0xa3, 14 | 0x19, 0xc8, 0xa3, 0x7a, 0x8d, 0xcf, 0xde, 0x89, 0x39, 0x8f, 0x62, 0x01, 0x44, 0x00, 0x0f, 0x00, 15 | 0xb0, 0x41, 0x55, 0xbd, 0x7e, 0xf8, 0xbd, 0xee, 0xbc, 0x04, 0x1f, 0xcd, 0xb3, 0xb7, 0xab, 0x62, 16 | 0xd9, 0x77, 0xfb, 0xcb, 0x16, 0x64, 0x30, 0x1b, 0x30, 0x07, 0xa6, 0xcd, 0x9b, 0x85, 0x09, 0xea, 17 | 0x5d, 0x19, 0xee, 0xdb, 0x8b, 0x3e, 0x43, 0x38, 0x15, 0x2e, 0xc6, 0x36, 0x10, 0x62, 0xd5, 0xc5, 18 | 0x78, 0xcd, 0xd6, 0x74, 0x0f, 0x0d, 0x53, 0x58, 0x1a, 0x79, 0x49, 0x54, 0xab, 0x28, 0x0b, 0x84, 19 | 0xf0, 0x11, 0xdf, 0x81, 0x23, 0x06, 0x3a, 0x16, 0x44, 0x7c, 0x81, 0x23, 0x7b, 0x11, 0x33, 0x6b, 20 | 0x24, 0xed, 0x44, 0x91, 0xf2, 0x08, 0xbb, 0xab, 0x3e, 0x64, 0x99, 0x55, 0xb7, 0x0c, 0x2e, 0xae, 21 | 0xd7, 0xd9, 0x87, 0x50, 0xda, 0x26, 0x27, 0x21, 0x26, 0x0d, 0xf3, 0x8b, 0x6b, 0xbe, 0xc0, 0xad, 22 | 0xe1, 0x81, 0x2d, 0xfc, 0x3e, 0x77, 0xa0, 0xe3, 0x3c, 0xc7, 0x0b, 0xd6, 0x3c, 0x5a, 0x23, 0x2e, 23 | 0x4b, 0xbf, 0xb9, 0xd3, 0xb7, 0xf7, 0xda, 0xf8, 0xd4, 0xb0, 0x49, 0x61, 0x5e, 0x1d, 0x33, 0x39, 24 | 0x15, 0xb0, 0xc6, 0x21, 0x85, 0x11, 0x65, 0x6e, 0x86, 0x12, 0x04, 0xc2, 0x8a, 0xc7, 0xad, 0x67, 25 | 0xdf, 0x13, 0x58, 0xeb, 0xac, 0x28, 0xfd, 0xc6, 0x99, 0xc3, 0x0a, 0x8c, 0xec, 0x4b, 0x56, 0xab, 26 | 0xc4, 0x65, 0xc3, 0x12, 0x3b, 0x1d, 0xbd, 0x65, 0x88, 0x22, 0x7b, 0x6c, 0x6c, 0x96, 0x35, 0x90, 27 | 0x0c, 0xf0, 0xb7, 0x10, 0xfd, 0x00, 0xdd, 0xc3, 0x17, 0x7f, 0x08, 0x1c, 0x0b, 0x89, 0xdb, 0x4b, 28 | 0x1a, 0x32, 0x89, 0x3e, 0xb8, 0x9d, 0x54, 0x41, 0xb3, 0x64, 0x7b, 0xf1, 0x5c, 0x1d, 0xa6, 0x7f, 29 | 0x90, 0xc0, 0x38, 0x32, 0x3f, 0xe4, 0x3b, 0x2b, 0x3d, 0xdb, 0x09, 0x36, 0x76, 0xbb, 0xfc, 0x4d, 30 | 0x1c, 0xc2, 0xf0, 0xfd, 0x43, 0xa3, 0x3f, 0x93, 0x22, 0xef, 0xdd, 0x32, 0xed, 0x8e, 0xfc, 0xfc, 31 | 0xec, 0x9b, 0x26, 0x35, 0xe8, 0x66, 0x1c, 0x4c, 0x44, 0xa9, 0x6c, 0x3b, 0xd6, 0xe6, 0x88, 0x7c, 32 | 0x21, 0x77, 0x47, 0xeb, 0xd6, 0xf8, 0x02, 0xb6, 0xcb, 0xbe, 0x31, 0x91, 0x73, 0xb1, 0x91, 0xed, 33 | 0x1a, 0xbc, 0x2c, 0x62, 0x8a, 0x43, 0xe2, 0x97, 0x84, 0x8d, 0x4f, 0xc6, 0x1e, 0xe5, 0xd7, 0xec, 34 | 0x03, 0x15, 0x72, 0xdf, 0x19, 0xf7, 0x8f, 0xd0, 0x73, 0x34, 0xdd, 0x5f, 0xeb, 0xfc, 0x76, 0xca, 35 | 0xbd, 0x20, 0x70, 0x47, 0x5c, 0x49, 0x3a, 0x14, 0xff, 0xe6, 0xa1, 0x72, 0x39, 0xdd, 0x34, 0xa7, 36 | 0xe5, 0xda, 0xdb, 0x7c, 0x34, 0x79, 0x14, 0x3c, 0xad, 0x11, 0x20, 0xd4, 0x59, 0x6d, 0xc6, 0x5b, 37 | 0x3c, 0xc3, 0xef, 0x86, 0xde, 0x16, 0x00, 0xeb, 0x96, 0x60, 0xfe, 0xa1, 0x9f, 0x3b, 0x89, 0x19, 38 | 0xd3, 0x83, 0x4b, 0x19, 0x57, 0x7e, 0x84, 0x1b, 0x2a, 0xc0, 0x02, 0x50, 0x39, 0x1e, 0xda, 0x00, 39 | 0x5a, 0x97, 0x3e, 0x4b, 0x1c, 0x7a, 0x2d, 0x35, 0x91, 0x10, 0xc0, 0x74, 0x32, 0xea, 0x5d, 0xbb, 40 | 0x0b, 0x8d, 0x9c, 0xab, 0xfa, 0x2c, 0x6a, 0x81, 0xac, 0xf8, 0xb5, 0x21, 0x53, 0x90, 0xa6, 0x2d, 41 | 0x54, 0xab, 0x13, 0xb2, 0x30, 0x9b, 0x2f, 0x0a, 0x00, 0x77, 0x04, 0xb1, 0x3e, 0x75, 0xbe, 0x44, 42 | 0x21, 0x5e, 0x26, 0x60, 0xd7, 0x44, 0x7b, 0xe7, 0x66, 0xbf, 0x66, 0x22, 0xa2, 0x70, 0x69, 0x00, 43 | 0x24, 0xb7, 0x63, 0x67, 0xb5, 0x90, 0x7e, 0xef, 0x11, 0xca, 0x59, 0xb2, 0x6d, 0x3f, 0xf9, 0x8b, 44 | 0xfe, 0xa3, 0x23, 0xf8, 0x90, 0x3b, 0xee, 0x49, 0xd7, 0x68, 0x63, 0x40, 0x01, 0x80, 0x30, 0xce, 45 | 0xa0, 0x3a, 0x1c, 0xa5, 0x60, 0x9d, 0xc4, 0x4e, 0x26, 0xaa, 0xa7, 0x70, 0xd5, 0x1b, 0xbc, 0x36, 46 | 0xe3, 0x92, 0xd6, 0xfc, 0x16, 0x57, 0xef, 0xd8, 0x3b, 0x26, 0xa7, 0x37, 0x92, 0xac, 0x9c, 0xe8, 47 | 0xd0, 0xe8, 0x00, 0xf5, 0x64, 0x29, 0x9c, 0xb4, 0x2b, 0xca, 0x02, 0x0a, 0xab, 0x34, 0x30, 0x10, 48 | 0x7b, 0x18, 0xde, 0x94, 0xc6, 0xf7, 0x19, 0x69, 0x40, 0xde, 0xfc, 0xb1, 0x95, 0x74, 0xc6, 0xa3, 49 | 0xaf, 0xc1, 0x54, 0x64, 0x49, 0x77, 0x5f, 0x86, 0x87, 0x27, 0x30, 0xa2, 0x79, 0xaf, 0x06, 0xf7, 50 | 0x02, 0x78, 0xd1, 0xc6, 0x15, 0xf7, 0x88, 0xee, 0x70, 0xd4, 0x14, 0xfe, 0x87, 0x79, 0xa0, 0x82, 51 | 0xe6, 0x75, 0x5a, 0xc4, 0x43, 0x4b, 0xa7, 0x7e, 0xc4, 0x6a, 0x3a, 0x36, 0x7e, 0x61, 0x3b, 0x83, 52 | 0x0a, 0x69, 0x86, 0xbc, 0x17, 0x94, 0x1c, 0x46, 0x8d, 0xfb, 0xe3, 0x15, 0x38, 0x84, 0xc5, 0xce, 53 | 0xbf, 0x60, 0x32, 0x5e, 0x80, 0x74, 0x05, 0x6e, 0xf0, 0x5c, 0x31, 0x27, 0x96, 0xa5, 0x14, 0x77, 54 | 0x78, 0xba, 0x02, 0xe6, 0x9b, 0xf7, 0x79, 0x2f, 0x3a, 0xd5, 0x7c, 0x66, 0x55, 0x24, 0x39, 0xd7, 55 | //0x88, 0xcb, 0xf2, 0xc4, 0xcf, 0xb6, 0xf5, 0x64, 0x41, 0x3b, 0x92, 0xc4, 0xdc, 0xcc, 0x35, 0x69, 56 | 0x28, 0xa9, 0x77, 0x83, 0x94, 0x9c, 0x25, 0x3d, 0x52, 0xba, 0xb1, 0xe6, 0xbe, 0x45, 0x08, 0xd6, 57 | 0x4b, 0xbd, 0x77, 0xe9, 0xee, 0x5f, 0x76, 0x47, 0x77, 0x21, 0x58, 0x46, 0x8b, 0xa6, 0xc9, 0x95, 58 | 0xc7, 0x30, 0x65, 0xff, 0x8b, 0x25, 0x16, 0x18, 0x37, 0x1d, 0x97, 0x97, 0x1d, 0xd3, 0x6e, 0xa0, 59 | 0x9b, 0x27, 0x6c, 0xb3, 0x3e, 0x7e, 0x04, 0xd6, 0x09, 0xd7, 0xe6, 0xc8, 0x8a, 0x66, 0xec, 0xe0, 60 | 0x7a, 0xf6, 0x9b, 0xfa, 0x65, 0x36, 0x7f, 0xc1, 0x22, 0x21, 0x66, 0x37, 0x4f, 0x0d, 0x87, 0x46, 61 | 0x9b, 0x3a, 0xf0, 0xea, 0xd0, 0x80, 0x81, 0x9b, 0x75, 0xc5, 0x80, 0x00, 0xc1, 0xc6, 0xf0, 0x86, 62 | 0x8c, 0x3c, 0x1e, 0xf3, 0x62, 0x75, 0x86, 0x78, 0x10, 0xe2, 0x3a, 0x13, 0x0a, 0x5b, 0x65, 0xce, 63 | 0xee, 0x73, 0x80, 0xed, 0xe4, 0x0f, 0x93, 0x58, 0xd3, 0xbc, 0xbd, 0x33, 0xc7, 0x94, 0xab, 0xa0, 64 | 0x12, 0x76, 0x49, 0xc5, 0x50, 0x94, 0x7f, 0xd1, 0xf6, 0x5d, 0x2f, 0x7c, 0xf4, 0x55, 0x0d, 0x48, 65 | 0x94, 0xf8, 0x83, 0x80, 0x95, 0x87, 0x0d, 0x6b, 0xa2, 0xfe, 0x45, 0xa5, 0x5f, 0x45, 0xb6, 0x1a, 66 | 0x7d, 0x18, 0xf5, 0x61, 0xb2, 0x45, 0x20, 0x7a, 0x5e, 0x6f, 0xde, 0x2d, 0x3a, 0xa6, 0x48, 0x75, 67 | }; 68 | -------------------------------------------------------------------------------- /uctf2016/attack/cipher.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define LOOP(i, times) for( size_t (i) = 0; (i) < (times); ++(i) ) 4 | #define LLOOP(i, times) for( (i) = 0; (i) < (times); ++(i) ) 5 | 6 | unsigned char sbox[256] = 7 | { 8 | 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5, 9 | 0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 10 | 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0, 11 | 0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0, 12 | 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc, 13 | 0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 14 | 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a, 15 | 0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75, 16 | 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0, 17 | 0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 18 | 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b, 19 | 0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf, 20 | 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85, 21 | 0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8, 22 | 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5, 23 | 0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 24 | 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17, 25 | 0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 26 | 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88, 27 | 0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb, 28 | 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c, 29 | 0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 30 | 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9, 31 | 0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 32 | 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6, 33 | 0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a, 34 | 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e, 35 | 0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 36 | 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94, 37 | 0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf, 38 | 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68, 39 | 0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 40 | }; 41 | 42 | unsigned char rsbox[256] = 43 | { 44 | 0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38, 45 | 0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb, 46 | 0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87, 47 | 0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb, 48 | 0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d, 49 | 0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e, 50 | 0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2, 51 | 0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25, 52 | 0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16, 53 | 0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92, 54 | 0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda, 55 | 0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84, 56 | 0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a, 57 | 0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06, 58 | 0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02, 59 | 0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b, 60 | 0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea, 61 | 0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73, 62 | 0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85, 63 | 0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e, 64 | 0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89, 65 | 0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b, 66 | 0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20, 67 | 0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4, 68 | 0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31, 69 | 0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f, 70 | 0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d, 71 | 0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef, 72 | 0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0, 73 | 0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61, 74 | 0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26, 75 | 0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d 76 | }; 77 | 78 | #include "brute.h" 79 | 80 | const unsigned char sample3_cipher[] = 81 | { 82 | 0x54,0x31,0xB5,0x1B,0xCF,0x8C,0x6E,0x7E, 83 | 0x87,0x6A,0xA3,0x24,0xEE,0x14,0x52,0x1C, 84 | 0x24,0x7E,0x0C,0xF8,0x47,0xEA,0xB1,0xC8, 85 | 0x3E,0x07,0x57,0x7E,0x27,0xA7,0x71,0xA3, 86 | 0x14,0xE4,0x70,0xD0,0x7F,0xA8,0x65,0x06, 87 | 0x45,0x23,0x57,0x14 88 | }; 89 | 90 | static unsigned char tableA[0x40000]; 91 | static unsigned char tableB[0x30000]; 92 | 93 | static unsigned char KeyCan[0x7000]; 94 | static size_t KeyCounter = 0; 95 | 96 | void stage1() 97 | { 98 | union 99 | { 100 | unsigned int i; 101 | unsigned char data[4]; 102 | } key; 103 | 104 | union 105 | { 106 | unsigned int i; 107 | unsigned char data[4]; 108 | } output; 109 | 110 | static unsigned char table[0x10000]; 111 | 112 | LLOOP( key.i, 0x1000000 ) 113 | { 114 | output.data[2] = rsbox[ sample3_cipher[3] ] ^ key.data[2] ^ sample3_cipher[2]; 115 | output.data[1] = rsbox[ sample3_cipher[2] ] ^ key.data[1] ^ sample3_cipher[1]; 116 | output.data[0] = rsbox[ sample3_cipher[1] ] ^ key.data[0] ^ sample3_cipher[0]; 117 | 118 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 119 | output.data[1] = rsbox[ output.data[1] ] ^ key.data[1] ^ output.data[0]; 120 | 121 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 122 | 123 | if ( output.data[2] == 'g' ) 124 | { 125 | table[ key.i / 0x100 ] = key.data[0]; 126 | } 127 | } 128 | 129 | size_t counter = 0; 130 | LLOOP( key.i, 0x1000000 ) 131 | { 132 | output.data[2] = rsbox[ sample3_cipher[4] ] ^ key.data[2] ^ sample3_cipher[3]; 133 | output.data[1] = rsbox[ sample3_cipher[3] ] ^ key.data[1] ^ sample3_cipher[2]; 134 | output.data[0] = rsbox[ sample3_cipher[2] ] ^ key.data[0] ^ sample3_cipher[1]; 135 | 136 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 137 | output.data[1] = rsbox[ output.data[1] ] ^ key.data[1] ^ output.data[0]; 138 | 139 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 140 | if ( output.data[2] == '{' ) 141 | { 142 | tableA[counter] = table[ key.i % 0x10000 ]; 143 | tableA[counter + 1] = key.data[0]; 144 | tableA[counter + 2] = key.data[1]; 145 | tableA[counter + 3] = key.data[2]; 146 | counter += 4; 147 | 148 | //printf("%02x%02x%02x%02x\n", table[ key.i % 0x10000 ], key.data[0], key.data[1], key.data[2] ); 149 | } 150 | } 151 | 152 | puts("------"); 153 | 154 | counter = 0; 155 | LLOOP( key.i, 0x1000000 ) 156 | { 157 | output.data[2] = rsbox[ sample3_cipher[43] ] ^ key.data[2] ^ sample3_cipher[42]; 158 | output.data[1] = rsbox[ sample3_cipher[42] ] ^ key.data[1] ^ sample3_cipher[41]; 159 | output.data[0] = rsbox[ sample3_cipher[41] ] ^ key.data[0] ^ sample3_cipher[40]; 160 | 161 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 162 | output.data[1] = rsbox[ output.data[1] ] ^ key.data[1] ^ output.data[0]; 163 | 164 | output.data[2] = rsbox[ output.data[2] ] ^ key.data[2] ^ output.data[1]; 165 | 166 | if ( output.data[2] == '}' ) 167 | { 168 | tableB[counter] = key.data[0]; 169 | tableB[counter + 1] = key.data[1]; 170 | tableB[counter + 2] = key.data[2]; 171 | counter += 3; 172 | 173 | //printf("%02x%02x%02x\n", key.data[0], key.data[1], key.data[2] ); 174 | } 175 | } 176 | } 177 | 178 | 179 | void stage2() 180 | { 181 | union 182 | { 183 | unsigned int i; 184 | unsigned char data[4]; 185 | } key; 186 | union 187 | { 188 | unsigned int i; 189 | unsigned char data[4]; 190 | } iv; 191 | union 192 | { 193 | unsigned int i; 194 | unsigned char data[4]; 195 | } input; 196 | union 197 | { 198 | unsigned int i; 199 | unsigned char data[4]; 200 | } output; 201 | union 202 | { 203 | unsigned int i; 204 | unsigned char data[4]; 205 | } cipher; 206 | 207 | memcpy ( input.data, "la", 2 ); 208 | memcpy ( output.data, sample3_cipher + 1, 2 ); 209 | 210 | static unsigned char keyBuf[0x7]; 211 | 212 | LOOP(i, 0x10000) 213 | { 214 | LOOP(j, 0x10000) 215 | { 216 | if ( tableA[i * 4] == tableB[j * 3 + 2]) 217 | { 218 | memcpy( keyBuf + 1, tableA + i * 4, 4 ); 219 | keyBuf[6] = tableB[j * 3]; 220 | keyBuf[0] = tableB[j * 3 + 1]; 221 | 222 | unsigned char i1 = sample3_cipher[42] ^ rsbox[ sample3_cipher[43] ] ^ keyBuf[1]; 223 | unsigned char i0 = sample3_cipher[41] ^ rsbox[ sample3_cipher[42] ] ^ keyBuf[0] ^ rsbox[i1] ^ keyBuf[1]; 224 | 225 | i1 = rsbox[ sample3_cipher[0] ] ^ keyBuf[0] ^ i1; 226 | i0 = rsbox[ i1 ] ^ keyBuf[0] ^ i0; 227 | 228 | cipher.data[0] = sbox[ input.data[0] ^ keyBuf[1] ^ i0 ]; 229 | cipher.data[1] = sbox[ input.data[1] ^ keyBuf[2] ^ cipher.data[0] ]; 230 | 231 | cipher.data[0] = sbox[ cipher.data[0] ^ keyBuf[1] ^ i1 ]; 232 | cipher.data[1] = sbox[ cipher.data[1] ^ keyBuf[2] ^ cipher.data[0] ]; 233 | 234 | cipher.data[0] = sbox[ cipher.data[0] ^ keyBuf[1] ^ sample3_cipher[0] ]; 235 | cipher.data[1] = sbox[ cipher.data[1] ^ keyBuf[2] ^ cipher.data[0] ]; 236 | 237 | if ( cipher.data[0] == output.data[0] && cipher.data[1] == output.data[1] ) 238 | { 239 | memcpy( KeyCan + KeyCounter * sizeof(keyBuf), keyBuf, sizeof(keyBuf) ); 240 | ++KeyCounter; 241 | } 242 | } 243 | } 244 | } 245 | 246 | /* 247 | LOOP( i, KeyCounter) 248 | { 249 | LOOP( j, 7) 250 | printf("0x%02x, ", KeyCan[ i * 7 + j ] ); 251 | puts(""); 252 | } 253 | printf( "%d\n", KeyCounter ); 254 | */ 255 | } 256 | 257 | bool check( char * input, size_t len ) 258 | { 259 | LOOP( i, len ) 260 | { 261 | if ( input[i] < 0x20 || input[i] > 0x7f ) 262 | return false; 263 | } 264 | return true; 265 | } 266 | 267 | void stage3() 268 | { 269 | char buffer[sizeof(sample3_cipher)]; 270 | char tmp[256]; 271 | char sample3_key[8] = {0x00}; 272 | 273 | LOOP( j, KeyCounter ) 274 | { 275 | memcpy( sample3_key + 1, KeyCan + j * 7, 7 ); 276 | LOOP( i, 0x100 ) 277 | { 278 | memcpy( buffer, sample3_cipher, sizeof(buffer) ); 279 | memset(tmp, 0, 256); 280 | sample3_key[6] = i; 281 | Decrypt(buffer, sizeof(buffer), tmp, sample3_key, 8, 3); 282 | if ( check ( tmp, sizeof(buffer) ) ) 283 | { 284 | tmp[0] = 'f'; 285 | puts(tmp); 286 | } 287 | 288 | } 289 | } 290 | } 291 | 292 | int main() 293 | { 294 | stage1(); 295 | stage2(); 296 | stage3(); 297 | return 0; 298 | } -------------------------------------------------------------------------------- /uctf2016/test.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | char sbox[256] = 6 | { 7 | 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5, 8 | 0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 9 | 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0, 10 | 0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0, 11 | 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc, 12 | 0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 13 | 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a, 14 | 0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75, 15 | 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0, 16 | 0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 17 | 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b, 18 | 0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf, 19 | 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85, 20 | 0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8, 21 | 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5, 22 | 0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 23 | 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17, 24 | 0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 25 | 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88, 26 | 0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb, 27 | 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c, 28 | 0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 29 | 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9, 30 | 0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 31 | 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6, 32 | 0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a, 33 | 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e, 34 | 0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 35 | 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94, 36 | 0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf, 37 | 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68, 38 | 0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 39 | }; 40 | 41 | char rsbox[256] = 42 | { 43 | 0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38, 44 | 0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb, 45 | 0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87, 46 | 0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb, 47 | 0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d, 48 | 0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e, 49 | 0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2, 50 | 0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25, 51 | 0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16, 52 | 0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92, 53 | 0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda, 54 | 0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84, 55 | 0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a, 56 | 0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06, 57 | 0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02, 58 | 0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b, 59 | 0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea, 60 | 0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73, 61 | 0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85, 62 | 0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e, 63 | 0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89, 64 | 0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b, 65 | 0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20, 66 | 0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4, 67 | 0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31, 68 | 0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f, 69 | 0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d, 70 | 0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef, 71 | 0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0, 72 | 0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61, 73 | 0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26, 74 | 0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d 75 | }; 76 | 77 | #define EncByte(lastbyte, plain, key) sbox[(unsigned char) (plain ^ lastbyte ^ key)]; 78 | #define DecByte(lastbyte, cipher, key) (rsbox[(unsigned char) cipher] ^ lastbyte ^ key) 79 | 80 | void ShowHex(char *buf, int len) 81 | { 82 | for(int i = 0; i < len; i++) 83 | { 84 | printf("%02X", (unsigned char) buf[i]); 85 | } 86 | 87 | printf("\n"); 88 | } 89 | 90 | void FillRandom(char *buf, int len) 91 | { 92 | for(int i = 0; i < len; i++) 93 | { 94 | buf[i] = rand(); 95 | } 96 | } 97 | 98 | void EncRound(char *plain, int plainlen, char *cipher, char *IV, char *key, int keylen) 99 | { 100 | for(int i = 0; i < plainlen; i++) 101 | { 102 | if(i == 0) 103 | { 104 | cipher[i] = EncByte(*IV, plain[i], key[i % keylen]); 105 | } 106 | else 107 | { 108 | cipher[i] = EncByte(cipher[i - 1], plain[i], key[i % keylen]); 109 | } 110 | } 111 | } 112 | 113 | void DecRound(char *cipher, int cipherlen, char *plain, char *IV, char *key, int keylen) 114 | { 115 | for(int i = cipherlen - 1; i >= 0; i--) 116 | { 117 | if(i == 0) 118 | { 119 | plain[i] = DecByte(*IV, cipher[i], key[i % keylen]); 120 | } 121 | else 122 | { 123 | plain[i] = DecByte(cipher[i - 1], cipher[i], key[i % keylen]); 124 | } 125 | } 126 | } 127 | 128 | void Encrypt(char *plain, int plainlen, char *cipher, char *key, int keylen, int round) 129 | { 130 | for(int r = 0; r < round; r++) 131 | { 132 | if(r == 0) 133 | { 134 | EncRound(plain, plainlen, cipher, &key[0], &key[1], keylen - 1); 135 | } 136 | else 137 | { 138 | EncRound(cipher, plainlen, cipher, &cipher[plainlen - 1], &key[1], keylen - 1); 139 | } 140 | } 141 | } 142 | 143 | void Decrypt(char *cipher, int cipherlen, char *plain, char *key, int keylen, int round) 144 | { 145 | for(int r = round - 1; r >= 0; r--) 146 | { 147 | if(r == 0) 148 | { 149 | DecRound(cipher, cipherlen, plain, &key[0], &key[1], keylen - 1); 150 | } 151 | else 152 | { 153 | DecRound(cipher, cipherlen, cipher, &cipher[cipherlen - 1], &key[1], keylen - 1); 154 | } 155 | } 156 | } 157 | 158 | char plain[256]; 159 | char cipher[256]; 160 | char key[256]; 161 | char tmp[256]; 162 | 163 | #define sample1_keyround 1 164 | #define sample1_keylen strlen(sample1_key) 165 | char *sample1_key = "Start"; 166 | #define sample1_plainlen strlen(sample1_plain) 167 | char *sample1_plain = "flag{Come_on_boy_You_need_to_learn_how_to_recover_this_text_from_the_cipher_below_without_knowing_the_key}"; 168 | char *sample1_cipher = { 169 | 0x83,0x19,0x67,0x92,0x5E,0x10,0xD7,0x8B, 170 | 0xB8,0x44,0xCB,0x3E,0x59,0xBE,0x0A,0xC5, 171 | 0x28,0xCA,0x0E,0x76,0x4C,0x1A,0xD7,0xB4, 172 | 0x49,0xF5,0x0D,0x47,0x50,0x4C,0x39,0x71, 173 | 0xF5,0x2D,0x63,0xD2,0xDD,0x1F,0x23,0x26, 174 | 0x27,0xD4,0x48,0xCB,0x86,0xC4,0xBA,0x62, 175 | 0x43,0xFF,0x99,0x97,0x7E,0x50,0xFF,0x16, 176 | 0xC5,0x86,0xCD,0x8E,0xDE,0xBD,0xE0,0x99, 177 | 0x37,0x93,0xA7,0x4E,0x4D,0x84,0xDB,0x9E, 178 | 0x13,0xF0,0x8C,0x5C,0xD6,0xB5,0x62,0xB6, 179 | 0xD5,0xE9,0xCE,0x66,0x33,0x80,0x5E,0xCF, 180 | 0x8A,0x8D,0x22,0x07,0x9C,0x7E,0x4D,0x5B, 181 | 0x52,0x50,0xB1,0x95,0x5F,0xEF,0x42,0xED, 182 | 0xE1,0x54, 183 | }; 184 | 185 | #define sample2_keyround 1 186 | #define sample2_keylen strlen(sample2_key) 187 | char *sample2_key = "Harder?"; 188 | #define sample2_plainlen strlen(sample2_plain) 189 | char *sample2_plain = "flag{Is_it_a_change_in_quantity__Not_really__Its_a_change_in_quality}"; 190 | char *sample2_cipher = { 191 | 0x84,0xB8,0x7A,0xBC,0xD5,0x0A,0xAD,0xCD, 192 | 0xBA,0x62,0x84,0x57,0xF9,0x9B,0x88,0x64, 193 | 0xBC,0x69,0x3C,0x82,0x73,0xBC,0x81,0x8A, 194 | 0x0B,0xAD,0x5C,0xE3,0x41,0x67,0xD2,0x16, 195 | 0xD8,0x0D,0xCA,0x0C,0x23,0x26,0xCC,0xE8, 196 | 0x42,0x82,0xB8,0x2A,0x82,0xE4,0x98,0x48, 197 | 0x38,0xF1,0x74,0x40,0xBE,0xE1,0x28,0x27, 198 | 0xF7,0xBD,0x24,0x9D,0x0A,0x01,0xCA,0x8B, 199 | 0x2A,0x10,0x6B,0xD0,0xDD, 200 | }; 201 | 202 | #define sample3_keyround 3 203 | #define sample3_keylen strlen(sample3_key) 204 | char *sample3_key = "GoodLuck"; 205 | #define sample3_plainlen strlen(sample3_plain) 206 | char *sample3_plain = "flag{Is_that_so_easy_for_you__WakeUp_WakeUp_Lets_move_to_the_real_challenge}"; 207 | char *sample3_cipher = { 208 | 0x86,0x32,0x41,0xCD,0x68,0x18,0x97,0x9C, 209 | 0x1D,0x9A,0xD2,0x38,0x0C,0xC0,0xE6,0x1D, 210 | 0xF6,0xF3,0xB9,0xC5,0x9B,0xD8,0x11,0x4D, 211 | 0xC1,0x0A,0x54,0x6B,0x54,0xF3,0x3B,0xBB, 212 | 0x6C,0x77,0x35,0x81,0x60,0xAC,0x19,0x73, 213 | 0x38,0x22,0x20,0xC4,0x3D,0xAB,0xC0,0xE1, 214 | 0x6C,0x66,0x84,0x3C,0x95,0x77,0x01,0x28, 215 | 0xBA,0x7B,0xE4,0x32,0x41,0x7C,0x1C,0xC4, 216 | 0xAA,0xBA,0x6A,0x12,0x18,0x50,0x5F,0xD7, 217 | 0xD5,0x13,0x2D,0x9A, 218 | }; 219 | 220 | int main(void) 221 | { 222 | clock_t start, finish; 223 | double elapsed; 224 | 225 | srand(time(NULL)); 226 | start = clock(); 227 | 228 | printf("---------- sample1 demo ------------\n"); 229 | printf("plain:\n"); 230 | ShowHex(sample1_plain, sample1_plainlen); 231 | 232 | Encrypt(sample1_plain, sample1_plainlen, cipher, sample1_key, sample1_keylen, sample1_keyround); 233 | printf("cipher:\n"); 234 | ShowHex(cipher, sample1_plainlen); 235 | 236 | Decrypt(cipher, sample1_plainlen, tmp, sample1_key, sample1_keylen, sample1_keyround); 237 | printf("recoverd plain:\n"); 238 | ShowHex(tmp, sample1_plainlen); 239 | 240 | printf("---------- sample2 demo ------------\n"); 241 | printf("plain:\n"); 242 | ShowHex(sample2_plain, sample2_plainlen); 243 | 244 | Encrypt(sample2_plain, sample2_plainlen, cipher, sample2_key, sample2_keylen, sample2_keyround); 245 | printf("cipher:\n"); 246 | ShowHex(cipher, sample2_plainlen); 247 | 248 | Decrypt(cipher, sample2_plainlen, tmp, sample2_key, sample2_keylen, sample2_keyround); 249 | printf("recoverd plain:\n"); 250 | ShowHex(tmp, sample2_plainlen); 251 | 252 | printf("---------- sample3 demo ------------\n"); 253 | printf("plain:\n"); 254 | ShowHex(sample3_plain, sample3_plainlen); 255 | 256 | Encrypt(sample3_plain, sample3_plainlen, cipher, sample3_key, sample3_keylen, sample3_keyround); 257 | printf("cipher:\n"); 258 | ShowHex(cipher, sample3_plainlen); 259 | 260 | Decrypt(cipher, sample3_plainlen, tmp, sample3_key, sample3_keylen, sample3_keyround); 261 | printf("recoverd plain:\n"); 262 | ShowHex(tmp, sample3_plainlen); 263 | 264 | printf("---------- random data demo ------------\n"); 265 | #define PlainLen 32 266 | #define KeyLen 16 267 | #define EncRound 8 268 | FillRandom(key, KeyLen); 269 | printf("key:\n"); 270 | ShowHex(key, KeyLen); 271 | 272 | FillRandom(plain, PlainLen); 273 | printf("plain:\n"); 274 | ShowHex(plain, PlainLen); 275 | 276 | Encrypt(plain, PlainLen, cipher, key, KeyLen, EncRound); 277 | printf("cipher:\n"); 278 | ShowHex(cipher, PlainLen); 279 | 280 | Decrypt(cipher, PlainLen, tmp, key, KeyLen, EncRound); 281 | printf("recoverd plain:\n"); 282 | ShowHex(tmp, PlainLen); 283 | 284 | finish = clock(); 285 | elapsed = (double) (finish - start) / CLOCKS_PER_SEC; 286 | printf("Elapsed Time %lf s\n", elapsed); 287 | return 0; 288 | } 289 | -------------------------------------------------------------------------------- /0ctf2016/Arsenal/data/output/output.txt: -------------------------------------------------------------------------------- 1 | 56 52 13 e5 59 20 28 fa 02 49 34 84 fd cc ff 4d 2 | 0 or 1? 3 | ciphertext for 0 is: 4 | 95 e7 55 a6 c6 a4 19 23 eb 79 81 63 04 66 2d 81 5 | ciphertext for 1 is: 6 | 56 52 13 e5 59 20 28 fa 02 49 34 84 fd cc ff 4d 7 | Correct! 8 | aa f8 ad 98 be 9c 60 89 6a 48 20 49 eb f6 78 43 9 | 0 or 1? 10 | ciphertext for 0 is: 11 | a5 a6 30 dd 71 c4 76 ee 6f 0a 47 aa e7 01 e6 d4 12 | ciphertext for 1 is: 13 | aa f8 ad 98 be 9c 60 89 6a 48 20 49 eb f6 78 43 14 | Correct! 15 | e6 3c bf 29 f1 b2 c8 ac 68 1f 39 16 69 35 79 95 16 | 0 or 1? 17 | ciphertext for 0 is: 18 | e6 3c bf 29 f1 b2 c8 ac 68 1f 39 16 69 35 79 95 19 | ciphertext for 1 is: 20 | ba e1 61 0a e6 c1 fb 41 9a c6 21 a2 73 75 b2 af 21 | Correct! 22 | 6a b1 10 2a cd dd 7f 8b 35 1c fc 88 e0 0c 2d 6f 23 | 0 or 1? 24 | ciphertext for 0 is: 25 | 6a b1 10 2a cd dd 7f 8b 35 1c fc 88 e0 0c 2d 6f 26 | ciphertext for 1 is: 27 | 2e 52 c4 40 be 95 ef 02 f8 f7 cb e8 aa 0c 95 b9 28 | Correct! 29 | 54 9a 32 d0 74 de e0 eb 48 05 3d e7 48 95 d9 f9 30 | 0 or 1? 31 | ciphertext for 0 is: 32 | ee 4b 03 35 34 d8 39 6d 78 cb 08 b1 61 bf 8c f2 33 | ciphertext for 1 is: 34 | 54 9a 32 d0 74 de e0 eb 48 05 3d e7 48 95 d9 f9 35 | Correct! 36 | 3e 16 a6 25 1d 3c 87 11 78 41 db 76 e2 de 6d 92 37 | 0 or 1? 38 | ciphertext for 0 is: 39 | 3e 16 a6 25 1d 3c 87 11 78 41 db 76 e2 de 6d 92 40 | ciphertext for 1 is: 41 | 4f 36 80 ec c0 b3 dd 3e 01 ae 2d be 9d 7d 4d 08 42 | Correct! 43 | 40 1d f2 40 ed 39 06 72 8f 55 85 e2 0b 4c 6c 61 44 | 0 or 1? 45 | ciphertext for 0 is: 46 | 40 1d f2 40 ed 39 06 72 8f 55 85 e2 0b 4c 6c 61 47 | ciphertext for 1 is: 48 | 42 3c 0d ee fd f6 7a 81 f9 60 bb 62 71 9a 1e b9 49 | Correct! 50 | fc 86 57 11 ed dc 9d 7a 6e 37 6b e4 cb b6 93 28 51 | 0 or 1? 52 | ciphertext for 0 is: 53 | fc 86 57 11 ed dc 9d 7a 6e 37 6b e4 cb b6 93 28 54 | ciphertext for 1 is: 55 | 77 de e0 79 dc 49 a1 4e 21 0d ea 33 8c 0f 37 89 56 | Correct! 57 | c6 1d 9d 17 0f c8 c9 c9 aa f1 fd b5 da 27 3d 65 58 | 0 or 1? 59 | ciphertext for 0 is: 60 | c6 1d 9d 17 0f c8 c9 c9 aa f1 fd b5 da 27 3d 65 61 | ciphertext for 1 is: 62 | 4e 18 7e 7e e8 c2 72 7d a7 97 a5 fe 22 57 d8 80 63 | Correct! 64 | cd f3 e2 9e 5f 26 af 3f ed 23 71 b8 da 03 09 d7 65 | 0 or 1? 66 | ciphertext for 0 is: 67 | cd f3 e2 9e 5f 26 af 3f ed 23 71 b8 da 03 09 d7 68 | ciphertext for 1 is: 69 | 62 7e 98 cc 48 b3 65 a0 06 92 5f d2 4b c1 cb 23 70 | Correct! 71 | cd f0 75 11 34 e1 1f ba 7d d4 ef d6 ab 69 b5 f4 72 | 0 or 1? 73 | ciphertext for 0 is: 74 | 20 48 95 ab 2f c1 4f dd c5 3e 43 5d 86 c7 4c a3 75 | ciphertext for 1 is: 76 | cd f0 75 11 34 e1 1f ba 7d d4 ef d6 ab 69 b5 f4 77 | Correct! 78 | 74 ed 88 e4 40 ad df cf e9 a3 7c e3 30 96 55 e3 79 | 0 or 1? 80 | ciphertext for 0 is: 81 | 19 c8 a3 7a 8d cf de 89 39 8f 62 01 44 00 0f 00 82 | ciphertext for 1 is: 83 | 74 ed 88 e4 40 ad df cf e9 a3 7c e3 30 96 55 e3 84 | Correct! 85 | 87 ca 6a 87 1e 45 41 c1 f0 ba d5 57 4e e0 4c 78 86 | 0 or 1? 87 | ciphertext for 0 is: 88 | b0 41 55 bd 7e f8 bd ee bc 04 1f cd b3 b7 ab 62 89 | ciphertext for 1 is: 90 | 87 ca 6a 87 1e 45 41 c1 f0 ba d5 57 4e e0 4c 78 91 | Correct! 92 | 33 15 af 0c 6c 4d a8 54 7c 8d 5e 30 33 2f 00 56 93 | 0 or 1? 94 | ciphertext for 0 is: 95 | d9 77 fb cb 16 64 30 1b 30 07 a6 cd 9b 85 09 ea 96 | ciphertext for 1 is: 97 | 33 15 af 0c 6c 4d a8 54 7c 8d 5e 30 33 2f 00 56 98 | Correct! 99 | 21 21 04 88 e8 c3 78 35 97 d2 ea 9a e0 5a 7d d4 100 | 0 or 1? 101 | ciphertext for 0 is: 102 | 5d 19 ee db 8b 3e 43 38 15 2e c6 36 10 62 d5 c5 103 | ciphertext for 1 is: 104 | 21 21 04 88 e8 c3 78 35 97 d2 ea 9a e0 5a 7d d4 105 | Correct! 106 | d8 5b bf 30 54 2d 72 6a 8c 87 2c 21 ec b4 7e 26 107 | 0 or 1? 108 | ciphertext for 0 is: 109 | 78 cd d6 74 0f 0d 53 58 1a 79 49 54 ab 28 0b 84 110 | ciphertext for 1 is: 111 | d8 5b bf 30 54 2d 72 6a 8c 87 2c 21 ec b4 7e 26 112 | Correct! 113 | 78 a7 90 99 67 9b 23 cb 8f 23 5b b3 9a f9 7c cb 114 | 0 or 1? 115 | ciphertext for 0 is: 116 | f0 11 df 81 23 06 3a 16 44 7c 81 23 7b 11 33 6b 117 | ciphertext for 1 is: 118 | 78 a7 90 99 67 9b 23 cb 8f 23 5b b3 9a f9 7c cb 119 | Correct! 120 | 24 ed 44 91 f2 08 bb ab 3e 64 99 55 b7 0c 2e ae 121 | 0 or 1? 122 | ciphertext for 0 is: 123 | 24 ed 44 91 f2 08 bb ab 3e 64 99 55 b7 0c 2e ae 124 | ciphertext for 1 is: 125 | 1f 7b 48 45 a4 cb e6 98 16 89 34 3c a7 ed 56 e0 126 | Correct! 127 | 11 39 1b 0f 32 df bc 00 2e 00 0e 94 63 cc dd 7a 128 | 0 or 1? 129 | ciphertext for 0 is: 130 | d7 d9 87 50 da 26 27 21 26 0d f3 8b 6b be c0 ad 131 | ciphertext for 1 is: 132 | 11 39 1b 0f 32 df bc 00 2e 00 0e 94 63 cc dd 7a 133 | Correct! 134 | e1 81 2d fc 3e 77 a0 e3 3c c7 0b d6 3c 5a 23 2e 135 | 0 or 1? 136 | ciphertext for 0 is: 137 | e1 81 2d fc 3e 77 a0 e3 3c c7 0b d6 3c 5a 23 2e 138 | ciphertext for 1 is: 139 | ab 5e 0d 50 8f bb ab 6f 30 45 34 68 5d 82 4b 11 140 | Correct! 141 | c2 3a b3 2a 16 de d5 d5 ef cc 16 7b 43 a3 a5 03 142 | 0 or 1? 143 | ciphertext for 0 is: 144 | 4b bf b9 d3 b7 f7 da f8 d4 b0 49 61 5e 1d 33 39 145 | ciphertext for 1 is: 146 | c2 3a b3 2a 16 de d5 d5 ef cc 16 7b 43 a3 a5 03 147 | Correct! 148 | 15 b0 c6 21 85 11 65 6e 86 12 04 c2 8a c7 ad 67 149 | 0 or 1? 150 | ciphertext for 0 is: 151 | 15 b0 c6 21 85 11 65 6e 86 12 04 c2 8a c7 ad 67 152 | ciphertext for 1 is: 153 | 13 4b c0 49 37 99 24 11 00 fa cc d8 6e 1f 2b 15 154 | Correct! 155 | df 13 58 eb ac 28 fd c6 99 c3 0a 8c ec 4b 56 ab 156 | 0 or 1? 157 | ciphertext for 0 is: 158 | df 13 58 eb ac 28 fd c6 99 c3 0a 8c ec 4b 56 ab 159 | ciphertext for 1 is: 160 | 06 ae 29 3d 23 f1 17 16 a4 c6 40 37 3b e6 3b f8 161 | Correct! 162 | 60 bc 35 72 46 59 31 eb 86 3f 9c f8 87 2b 00 2c 163 | 0 or 1? 164 | ciphertext for 0 is: 165 | c4 65 c3 12 3b 1d bd 65 88 22 7b 6c 6c 96 35 90 166 | ciphertext for 1 is: 167 | 60 bc 35 72 46 59 31 eb 86 3f 9c f8 87 2b 00 2c 168 | Correct! 169 | 0c f0 b7 10 fd 00 dd c3 17 7f 08 1c 0b 89 db 4b 170 | 0 or 1? 171 | ciphertext for 0 is: 172 | 0c f0 b7 10 fd 00 dd c3 17 7f 08 1c 0b 89 db 4b 173 | ciphertext for 1 is: 174 | ca 2f e1 6c b2 62 56 aa e8 25 11 42 56 8d e5 b7 175 | Correct! 176 | 1a 32 89 3e b8 9d 54 41 b3 64 7b f1 5c 1d a6 7f 177 | 0 or 1? 178 | ciphertext for 0 is: 179 | 1a 32 89 3e b8 9d 54 41 b3 64 7b f1 5c 1d a6 7f 180 | ciphertext for 1 is: 181 | cb c3 e3 38 aa b2 ed 58 cd fd 8d ee 59 9b 22 ff 182 | Correct! 183 | a5 34 2e 75 68 25 33 d0 be 69 b2 d7 77 b9 fd f2 184 | 0 or 1? 185 | ciphertext for 0 is: 186 | 90 c0 38 32 3f e4 3b 2b 3d db 09 36 76 bb fc 4d 187 | ciphertext for 1 is: 188 | a5 34 2e 75 68 25 33 d0 be 69 b2 d7 77 b9 fd f2 189 | Correct! 190 | 1c c2 f0 fd 43 a3 3f 93 22 ef dd 32 ed 8e fc fc 191 | 0 or 1? 192 | ciphertext for 0 is: 193 | 1c c2 f0 fd 43 a3 3f 93 22 ef dd 32 ed 8e fc fc 194 | ciphertext for 1 is: 195 | b8 0e c3 c2 44 6b f7 e0 a9 b9 b3 ca f5 50 56 cb 196 | Correct! 197 | ec 9b 26 35 e8 66 1c 4c 44 a9 6c 3b d6 e6 88 7c 198 | 0 or 1? 199 | ciphertext for 0 is: 200 | ec 9b 26 35 e8 66 1c 4c 44 a9 6c 3b d6 e6 88 7c 201 | ciphertext for 1 is: 202 | 87 9f a2 05 fd 93 74 42 e9 8d cf 60 ab ea dc 10 203 | Correct! 204 | c2 db 15 ac 1a 8c 3a 72 34 a5 0a 4d a3 83 22 5d 205 | 0 or 1? 206 | ciphertext for 0 is: 207 | 21 77 47 eb d6 f8 02 b6 cb be 31 91 73 b1 91 ed 208 | ciphertext for 1 is: 209 | c2 db 15 ac 1a 8c 3a 72 34 a5 0a 4d a3 83 22 5d 210 | Correct! 211 | 77 64 f4 6d a9 00 e9 13 89 ac 38 18 01 6f 01 0d 212 | 0 or 1? 213 | ciphertext for 0 is: 214 | 1a bc 2c 62 8a 43 e2 97 84 8d 4f c6 1e e5 d7 ec 215 | ciphertext for 1 is: 216 | 77 64 f4 6d a9 00 e9 13 89 ac 38 18 01 6f 01 0d 217 | Correct! 218 | 03 15 72 df 19 f7 8f d0 73 34 dd 5f eb fc 76 ca 219 | 0 or 1? 220 | ciphertext for 0 is: 221 | 03 15 72 df 19 f7 8f d0 73 34 dd 5f eb fc 76 ca 222 | ciphertext for 1 is: 223 | 9a 59 d0 11 00 62 36 12 6d f1 c0 2a ba 6a 97 c3 224 | Correct! 225 | 72 be 39 55 a7 26 27 16 e4 9e 2b 05 7b e1 26 67 226 | 0 or 1? 227 | ciphertext for 0 is: 228 | bd 20 70 47 5c 49 3a 14 ff e6 a1 72 39 dd 34 a7 229 | ciphertext for 1 is: 230 | 72 be 39 55 a7 26 27 16 e4 9e 2b 05 7b e1 26 67 231 | Correct! 232 | e5 da db 7c 34 79 14 3c ad 11 20 d4 59 6d c6 5b 233 | 0 or 1? 234 | ciphertext for 0 is: 235 | e5 da db 7c 34 79 14 3c ad 11 20 d4 59 6d c6 5b 236 | ciphertext for 1 is: 237 | b0 63 00 22 fe c2 f4 71 13 87 b4 51 90 2a 63 cc 238 | Correct! 239 | 2c 50 5c 37 5f 34 cd 6f d0 a9 3d d4 76 7d e4 75 240 | 0 or 1? 241 | ciphertext for 0 is: 242 | 3c c3 ef 86 de 16 00 eb 96 60 fe a1 9f 3b 89 19 243 | ciphertext for 1 is: 244 | 2c 50 5c 37 5f 34 cd 6f d0 a9 3d d4 76 7d e4 75 245 | Correct! 246 | d3 83 4b 19 57 7e 84 1b 2a c0 02 50 39 1e da 00 247 | 0 or 1? 248 | ciphertext for 0 is: 249 | d3 83 4b 19 57 7e 84 1b 2a c0 02 50 39 1e da 00 250 | ciphertext for 1 is: 251 | 11 bf 75 2a 20 31 4c 49 90 70 d4 83 9f d1 51 55 252 | Correct! 253 | 17 d5 bc ae 54 9f 2d 3f e5 54 73 a7 9f 33 34 1c 254 | 0 or 1? 255 | ciphertext for 0 is: 256 | 5a 97 3e 4b 1c 7a 2d 35 91 10 c0 74 32 ea 5d bb 257 | ciphertext for 1 is: 258 | 17 d5 bc ae 54 9f 2d 3f e5 54 73 a7 9f 33 34 1c 259 | Correct! 260 | 5c 99 97 78 bf e5 fe ae d6 c6 0b aa f7 fe 1a 79 261 | 0 or 1? 262 | ciphertext for 0 is: 263 | 0b 8d 9c ab fa 2c 6a 81 ac f8 b5 21 53 90 a6 2d 264 | ciphertext for 1 is: 265 | 5c 99 97 78 bf e5 fe ae d6 c6 0b aa f7 fe 1a 79 266 | Correct! 267 | 25 c8 9d dd 12 5e 83 6c 43 b4 24 61 5d 6e f8 5e 268 | 0 or 1? 269 | ciphertext for 0 is: 270 | 54 ab 13 b2 30 9b 2f 0a 00 77 04 b1 3e 75 be 44 271 | ciphertext for 1 is: 272 | 25 c8 9d dd 12 5e 83 6c 43 b4 24 61 5d 6e f8 5e 273 | Correct! 274 | 21 5e 26 60 d7 44 7b e7 66 bf 66 22 a2 70 69 00 275 | 0 or 1? 276 | ciphertext for 0 is: 277 | 21 5e 26 60 d7 44 7b e7 66 bf 66 22 a2 70 69 00 278 | ciphertext for 1 is: 279 | 24 64 bf 4f 89 ce b1 01 49 03 e5 b5 2d 44 0d eb 280 | Correct! 281 | 8d 7c a0 eb ad a1 0c 9e 30 d8 89 bf f2 14 3d 42 282 | 0 or 1? 283 | ciphertext for 0 is: 284 | 24 b7 63 67 b5 90 7e ef 11 ca 59 b2 6d 3f f9 8b 285 | ciphertext for 1 is: 286 | 8d 7c a0 eb ad a1 0c 9e 30 d8 89 bf f2 14 3d 42 287 | Correct! 288 | fc bd 2c fb ba 88 d3 fe 4b 2e a6 f3 99 8a 76 d5 289 | 0 or 1? 290 | ciphertext for 0 is: 291 | fe a3 23 f8 90 3b ee 49 d7 68 63 40 01 80 30 ce 292 | ciphertext for 1 is: 293 | fc bd 2c fb ba 88 d3 fe 4b 2e a6 f3 99 8a 76 d5 294 | Correct! 295 | a0 3a 1c a5 60 9d c4 4e 26 aa a7 70 d5 1b bc 36 296 | 0 or 1? 297 | ciphertext for 0 is: 298 | a0 3a 1c a5 60 9d c4 4e 26 aa a7 70 d5 1b bc 36 299 | ciphertext for 1 is: 300 | b6 db 64 9a 9b 3a fc 3a bf 52 aa 4c 38 6a 99 50 301 | Correct! 302 | c5 1f 70 89 5b 61 8e 7d 73 92 1f e7 04 48 e2 49 303 | 0 or 1? 304 | ciphertext for 0 is: 305 | e3 92 d6 fc 16 57 ef d8 3b 26 a7 37 92 ac 9c e8 306 | ciphertext for 1 is: 307 | c5 1f 70 89 5b 61 8e 7d 73 92 1f e7 04 48 e2 49 308 | Correct! 309 | 58 c6 a8 c3 70 49 06 bb c9 7e 7f da 97 62 ed b9 310 | 0 or 1? 311 | ciphertext for 0 is: 312 | d0 e8 00 f5 64 29 9c b4 2b ca 02 0a ab 34 30 10 313 | ciphertext for 1 is: 314 | 58 c6 a8 c3 70 49 06 bb c9 7e 7f da 97 62 ed b9 315 | Correct! 316 | 7b 18 de 94 c6 f7 19 69 40 de fc b1 95 74 c6 a3 317 | 0 or 1? 318 | ciphertext for 0 is: 319 | 7b 18 de 94 c6 f7 19 69 40 de fc b1 95 74 c6 a3 320 | ciphertext for 1 is: 321 | 4c 83 a2 cf 75 e7 38 b0 93 fc 7f c5 7d e0 3a 10 322 | Correct! 323 | 7a fb a4 14 de 2a ab 4e 67 72 9c 68 53 b4 ab 4a 324 | 0 or 1? 325 | ciphertext for 0 is: 326 | af c1 54 64 49 77 5f 86 87 27 30 a2 79 af 06 f7 327 | ciphertext for 1 is: 328 | 7a fb a4 14 de 2a ab 4e 67 72 9c 68 53 b4 ab 4a 329 | Correct! 330 | b2 2f 08 d0 6d 0e 78 29 b9 e3 49 bb 34 4c 90 c6 331 | 0 or 1? 332 | ciphertext for 0 is: 333 | 02 78 d1 c6 15 f7 88 ee 70 d4 14 fe 87 79 a0 82 334 | ciphertext for 1 is: 335 | b2 2f 08 d0 6d 0e 78 29 b9 e3 49 bb 34 4c 90 c6 336 | Correct! 337 | 1d f7 c8 35 7a d0 96 39 c6 0e 8d 23 2a 0a 5b 3f 338 | 0 or 1? 339 | ciphertext for 0 is: 340 | e6 75 5a c4 43 4b a7 7e c4 6a 3a 36 7e 61 3b 83 341 | ciphertext for 1 is: 342 | 1d f7 c8 35 7a d0 96 39 c6 0e 8d 23 2a 0a 5b 3f 343 | Correct! 344 | 0a 69 86 bc 17 94 1c 46 8d fb e3 15 38 84 c5 ce 345 | 0 or 1? 346 | ciphertext for 0 is: 347 | 0a 69 86 bc 17 94 1c 46 8d fb e3 15 38 84 c5 ce 348 | ciphertext for 1 is: 349 | b6 49 8b 4d 9a ce 5a 8f ca 07 37 95 46 be 8f e9 350 | Correct! 351 | ca 70 82 25 c1 26 a1 6c 20 a5 8b 2c 55 a8 09 88 352 | 0 or 1? 353 | ciphertext for 0 is: 354 | bf 60 32 5e 80 74 05 6e f0 5c 31 27 96 a5 14 77 355 | ciphertext for 1 is: 356 | ca 70 82 25 c1 26 a1 6c 20 a5 8b 2c 55 a8 09 88 357 | Correct! 358 | 78 ba 02 e6 9b f7 79 2f 3a d5 7c 66 55 24 39 d7 359 | 0 or 1? 360 | ciphertext for 0 is: 361 | 78 ba 02 e6 9b f7 79 2f 3a d5 7c 66 55 24 39 d7 362 | ciphertext for 1 is: 363 | 64 ba 80 ff b3 cd 3a 1c 75 f6 4a 34 b1 d3 35 06 364 | Correct! 365 | 88 cb f2 c4 cf b6 f5 64 41 3b 92 c4 dc cc 35 69 366 | 0 or 1? 367 | ciphertext for 0 is: 368 | 88 cb f2 c4 cf b6 f5 64 41 3b 92 c4 dc cc 35 69 369 | ciphertext for 1 is: 370 | 38 9b 25 dd 71 e6 b9 6c ab 7b fd 3c 6c 4a 0f 2c 371 | Correct! 372 | f2 2e d3 eb 8a ee 3c b0 5a ee c9 06 15 a6 c7 34 373 | 0 or 1? 374 | ciphertext for 0 is: 375 | 28 a9 77 83 94 9c 25 3d 52 ba b1 e6 be 45 08 d6 376 | ciphertext for 1 is: 377 | f2 2e d3 eb 8a ee 3c b0 5a ee c9 06 15 a6 c7 34 378 | Correct! 379 | b6 51 f7 0f 72 c5 55 dc 0e 7b 20 d2 24 30 d9 53 380 | 0 or 1? 381 | ciphertext for 0 is: 382 | 4b bd 77 e9 ee 5f 76 47 77 21 58 46 8b a6 c9 95 383 | ciphertext for 1 is: 384 | b6 51 f7 0f 72 c5 55 dc 0e 7b 20 d2 24 30 d9 53 385 | Correct! 386 | 59 ca a4 e2 95 b4 b3 06 22 25 f3 a0 de bd 6f f1 387 | 0 or 1? 388 | ciphertext for 0 is: 389 | c7 30 65 ff 8b 25 16 18 37 1d 97 97 1d d3 6e a0 390 | ciphertext for 1 is: 391 | 59 ca a4 e2 95 b4 b3 06 22 25 f3 a0 de bd 6f f1 392 | Correct! 393 | af b8 41 88 5b 2e d7 fb d0 7e ce a8 91 3a a0 d4 394 | 0 or 1? 395 | ciphertext for 0 is: 396 | 9b 27 6c b3 3e 7e 04 d6 09 d7 e6 c8 8a 66 ec e0 397 | ciphertext for 1 is: 398 | af b8 41 88 5b 2e d7 fb d0 7e ce a8 91 3a a0 d4 399 | Correct! 400 | da 69 f8 5c 3c b3 80 6b 4f 36 7d 8d 07 b3 e2 49 401 | 0 or 1? 402 | ciphertext for 0 is: 403 | 7a f6 9b fa 65 36 7f c1 22 21 66 37 4f 0d 87 46 404 | ciphertext for 1 is: 405 | da 69 f8 5c 3c b3 80 6b 4f 36 7d 8d 07 b3 e2 49 406 | Correct! 407 | fc a2 04 2d f7 26 3f 2c 4e 58 38 18 e3 36 9b e7 408 | 0 or 1? 409 | ciphertext for 0 is: 410 | 9b 3a f0 ea d0 80 81 9b 75 c5 80 00 c1 c6 f0 86 411 | ciphertext for 1 is: 412 | fc a2 04 2d f7 26 3f 2c 4e 58 38 18 e3 36 9b e7 413 | Correct! 414 | 8c 3c 1e f3 62 75 86 78 10 e2 3a 13 0a 5b 65 ce 415 | 0 or 1? 416 | ciphertext for 0 is: 417 | 8c 3c 1e f3 62 75 86 78 10 e2 3a 13 0a 5b 65 ce 418 | ciphertext for 1 is: 419 | d3 ba 82 25 b2 4a 63 c1 46 4d 4b 54 92 79 b3 03 420 | Correct! 421 | ee 73 80 ed e4 0f 93 58 d3 bc bd 33 c7 94 ab a0 422 | 0 or 1? 423 | ciphertext for 0 is: 424 | ee 73 80 ed e4 0f 93 58 d3 bc bd 33 c7 94 ab a0 425 | ciphertext for 1 is: 426 | 7c da ec 98 b7 00 54 d2 e5 81 95 25 a0 ec 73 a8 427 | Correct! 428 | 47 f7 ce 72 92 62 14 aa 5e e7 d5 54 04 d1 e9 51 429 | 0 or 1? 430 | ciphertext for 0 is: 431 | 12 76 49 c5 50 94 7f d1 f6 5d 2f 7c f4 55 0d 48 432 | ciphertext for 1 is: 433 | 47 f7 ce 72 92 62 14 aa 5e e7 d5 54 04 d1 e9 51 434 | Correct! 435 | 94 f8 83 80 95 87 0d 6b a2 fe 45 a5 5f 45 b6 1a 436 | 0 or 1? 437 | ciphertext for 0 is: 438 | 94 f8 83 80 95 87 0d 6b a2 fe 45 a5 5f 45 b6 1a 439 | ciphertext for 1 is: 440 | 9b 8e 33 03 39 a2 2b 1e b6 b3 b1 07 e7 e1 00 48 441 | Correct! 442 | 7d 18 f5 61 b2 45 20 7a 5e 6f de 2d 3a a6 48 75 443 | 0 or 1? 444 | ciphertext for 0 is: 445 | 7d 18 f5 61 b2 45 20 7a 5e 6f de 2d 3a a6 48 75 446 | ciphertext for 1 is: 447 | 30 27 d6 7b c8 ad 09 b3 f1 35 58 07 95 10 88 c5 448 | Correct! 449 | Now I will give you the flag: 450 | a8 8e 94 8e 60 73 29 70 05 28 5e 9d d6 b1 5e 9f 98 10 2c 8f ca 68 64 74 d1 63 38 ff 73 04 b1 a5 451 | -------------------------------------------------------------------------------- /0ctf2016/People's Square/solution/cipher.h: -------------------------------------------------------------------------------- 1 | unsigned char zero[BLOCK * AMOUNT] = 2 | { 3 | 0x4d, 0x7c, 0x5d, 0xb0, 0x80, 0x45, 0xa2, 0x13, 0xf6, 0x61, 0x0d, 0xca, 0xe2, 0xc1, 0x75, 0x9f, 4 | 0x1d, 0xdc, 0xd4, 0xfb, 0xe0, 0x4a, 0x33, 0xc2, 0xa8, 0x3f, 0x24, 0xa6, 0xd2, 0x6d, 0x86, 0x39, 5 | 0xfb, 0x54, 0x3e, 0x82, 0xd4, 0xe0, 0x85, 0x2d, 0xd4, 0xa5, 0xfd, 0x6e, 0x0b, 0x5c, 0xd1, 0xbb, 6 | 0x35, 0x8a, 0x97, 0xd4, 0xd6, 0x6d, 0xef, 0x16, 0x9e, 0x64, 0x59, 0x2d, 0xb6, 0xd0, 0x3f, 0x81, 7 | 0xea, 0xc7, 0xcc, 0x65, 0x23, 0x67, 0xb3, 0xf4, 0xbe, 0xfa, 0x88, 0x7f, 0x92, 0xd6, 0x63, 0xc4, 8 | 0x11, 0x37, 0x18, 0xe7, 0x86, 0x8b, 0x9f, 0xe9, 0xb5, 0xba, 0x40, 0x90, 0x0f, 0x6c, 0x39, 0x94, 9 | 0x1d, 0x54, 0xd4, 0x47, 0x30, 0xc9, 0xfc, 0x43, 0x68, 0x0c, 0x11, 0x52, 0xe9, 0x51, 0x6a, 0x20, 10 | 0xc3, 0xc9, 0xc2, 0x55, 0xa8, 0xa4, 0x84, 0x11, 0xc6, 0x0c, 0x3d, 0x30, 0xbd, 0x1c, 0xeb, 0xc5, 11 | 0x5a, 0x0d, 0x2f, 0x43, 0x5c, 0x25, 0x4b, 0xed, 0xdf, 0x78, 0xc8, 0x32, 0x00, 0xfc, 0x6c, 0x2f, 12 | 0x1d, 0xd0, 0x63, 0x1b, 0x53, 0xa9, 0x54, 0x26, 0x2e, 0x34, 0xb9, 0x8f, 0x03, 0xa7, 0x1d, 0xb1, 13 | 0xef, 0x32, 0x42, 0xa7, 0x2c, 0x2a, 0x49, 0x3c, 0x2a, 0x27, 0xe6, 0x4e, 0x78, 0xd9, 0x60, 0xa3, 14 | 0x62, 0xa4, 0x3f, 0x94, 0x14, 0x3e, 0x51, 0x39, 0x02, 0xeb, 0xbe, 0x79, 0x4e, 0x25, 0x4e, 0xd8, 15 | 0xfc, 0x38, 0x85, 0x2c, 0xb5, 0x84, 0x31, 0xeb, 0xef, 0x47, 0x5e, 0xd5, 0x92, 0xd4, 0x54, 0xd0, 16 | 0xd7, 0x75, 0x9d, 0xc7, 0x11, 0x5b, 0xe4, 0x02, 0x07, 0x54, 0x92, 0x67, 0xf4, 0x61, 0xc8, 0xc3, 17 | 0x6c, 0x01, 0x08, 0x7d, 0xc2, 0xc9, 0xa9, 0x73, 0x73, 0x81, 0x56, 0x06, 0x2c, 0x51, 0xb8, 0xf3, 18 | 0x5e, 0x07, 0xed, 0x95, 0xc5, 0xaf, 0xcc, 0xd0, 0xbe, 0xd7, 0xb2, 0x5f, 0xc5, 0x1f, 0x5a, 0x76, 19 | 0xfc, 0x8e, 0x76, 0x52, 0x33, 0x44, 0x4f, 0x33, 0x37, 0x1c, 0x73, 0x74, 0x06, 0x32, 0x4f, 0xef, 20 | 0xd9, 0xd4, 0xe2, 0xff, 0x1e, 0x7d, 0xdc, 0x5f, 0x12, 0x97, 0x60, 0x44, 0x90, 0x59, 0x32, 0x82, 21 | 0x5e, 0x50, 0xe8, 0xae, 0x62, 0xf6, 0xc6, 0x30, 0x2d, 0xc8, 0xc3, 0x55, 0xfd, 0xbb, 0x66, 0xcc, 22 | 0xa2, 0x94, 0xbd, 0xde, 0x56, 0xfd, 0xf9, 0x52, 0x68, 0x5e, 0xb4, 0x78, 0x08, 0xaf, 0xf4, 0x75, 23 | 0xd4, 0x7a, 0x75, 0xfa, 0x9f, 0xac, 0xb3, 0x33, 0x49, 0xab, 0x7b, 0x8e, 0x36, 0xdd, 0x4d, 0x09, 24 | 0x2c, 0x5e, 0xa8, 0x4b, 0xe8, 0x47, 0xe1, 0xa1, 0x09, 0x92, 0xe0, 0x0e, 0xaa, 0x5d, 0x37, 0x94, 25 | 0x66, 0x80, 0x54, 0x51, 0x42, 0xf0, 0x13, 0x0e, 0xd7, 0xf9, 0x47, 0x84, 0x9b, 0x97, 0x72, 0x55, 26 | 0x69, 0x37, 0xc4, 0x39, 0x97, 0xc2, 0x23, 0x95, 0x1e, 0x97, 0xc3, 0x50, 0x37, 0xe7, 0x72, 0x49, 27 | 0x56, 0xa5, 0xca, 0xc5, 0x7e, 0x63, 0x62, 0x62, 0xc8, 0x4e, 0x76, 0xdd, 0x1a, 0x7a, 0x38, 0xcc, 28 | 0x63, 0x9d, 0x0d, 0x53, 0x14, 0x27, 0x25, 0xac, 0xb4, 0x4d, 0x90, 0x08, 0xa9, 0x1a, 0xe9, 0x75, 29 | 0x57, 0xd2, 0x96, 0xf6, 0xd7, 0xdf, 0x86, 0x6a, 0xc1, 0xa2, 0x24, 0x9a, 0xe9, 0xfa, 0x29, 0x38, 30 | 0xce, 0xd4, 0x1f, 0xbe, 0xf4, 0x9f, 0x28, 0xd2, 0xf0, 0xce, 0x1a, 0x58, 0x32, 0x03, 0x26, 0x21, 31 | 0x49, 0x86, 0x54, 0x6f, 0xc4, 0x13, 0x0f, 0xbf, 0xdd, 0x7b, 0x8b, 0x35, 0x49, 0x4c, 0xbc, 0xc8, 32 | 0x0a, 0x52, 0xf2, 0xe7, 0x4a, 0xdb, 0xcd, 0x48, 0x3d, 0x6e, 0xdd, 0xc6, 0xf0, 0xf7, 0xd8, 0xa1, 33 | 0x9f, 0x7a, 0x92, 0x5a, 0x1e, 0xb1, 0xc2, 0xe3, 0xd3, 0x42, 0xbb, 0xa2, 0x19, 0x1e, 0xd4, 0x9c, 34 | 0x22, 0xb0, 0x8d, 0xc0, 0x83, 0x03, 0xe7, 0x5a, 0x4a, 0x1b, 0x50, 0xfd, 0x1d, 0x23, 0x21, 0x72, 35 | 0xc2, 0xe6, 0x45, 0x6e, 0x28, 0xd0, 0x15, 0xc1, 0x55, 0x16, 0x56, 0x06, 0x15, 0x8b, 0x86, 0xf8, 36 | 0x26, 0x2f, 0xa0, 0x85, 0x02, 0xe6, 0x35, 0xb8, 0xda, 0x00, 0x64, 0x02, 0xbf, 0x64, 0x3f, 0x50, 37 | 0x2a, 0x71, 0x33, 0xe4, 0xd8, 0xd7, 0xc2, 0xa7, 0xc3, 0x96, 0x60, 0xa3, 0xac, 0xb3, 0x7a, 0xf3, 38 | 0x5c, 0x96, 0x41, 0x58, 0x83, 0x8e, 0xee, 0xcf, 0x6e, 0x2d, 0x8e, 0x1d, 0xcb, 0xe3, 0xf3, 0xc4, 39 | 0x65, 0xd4, 0xac, 0xf4, 0xd0, 0xfe, 0x2d, 0x55, 0x59, 0x03, 0xa5, 0xf6, 0x64, 0x52, 0xeb, 0x64, 40 | 0x73, 0xa5, 0x91, 0x0e, 0x66, 0x9c, 0xc7, 0x6b, 0x56, 0x83, 0x6b, 0xe8, 0xd8, 0xd0, 0x4f, 0x1a, 41 | 0xab, 0xa9, 0x56, 0xd8, 0x3c, 0x66, 0x36, 0xab, 0xa1, 0x68, 0xe4, 0x2a, 0x2d, 0xf5, 0x69, 0xfe, 42 | 0xe0, 0xd2, 0xda, 0x4b, 0x03, 0x2f, 0x23, 0xe6, 0x34, 0x45, 0x5d, 0x8b, 0xb5, 0xed, 0xc1, 0x64, 43 | 0x68, 0x95, 0xda, 0x1d, 0xc5, 0xc7, 0xa8, 0x26, 0xce, 0x4e, 0xe2, 0x10, 0x79, 0xe3, 0xc0, 0x44, 44 | 0x84, 0xe6, 0x9d, 0x19, 0x30, 0xd7, 0x79, 0xb3, 0xa4, 0xb8, 0x2d, 0x1d, 0xe4, 0xb1, 0x7d, 0xc8, 45 | 0x02, 0x71, 0x9c, 0x88, 0x20, 0xd4, 0x36, 0xc0, 0x49, 0xf2, 0x90, 0x27, 0xd1, 0x42, 0x98, 0xff, 46 | 0xba, 0xc4, 0x2d, 0x95, 0xfe, 0x16, 0x01, 0xc6, 0x3d, 0xf0, 0xb2, 0xbb, 0xe5, 0x4b, 0x3a, 0xa5, 47 | 0x82, 0x5f, 0x90, 0x29, 0xce, 0x93, 0x86, 0xc7, 0x38, 0x8b, 0x7f, 0x08, 0x36, 0xff, 0x7d, 0x0f, 48 | 0xc5, 0xdc, 0x40, 0x8c, 0xdd, 0xe8, 0x9b, 0x38, 0x63, 0x5b, 0xef, 0xb1, 0x17, 0xf2, 0xdd, 0xc3, 49 | 0x5a, 0xc6, 0x3c, 0x4b, 0xf0, 0x50, 0xec, 0xfd, 0x29, 0x90, 0x5b, 0x62, 0xc4, 0x44, 0xe3, 0x71, 50 | 0x84, 0xae, 0x47, 0x8f, 0x6c, 0xff, 0xc8, 0x57, 0x99, 0xd7, 0xa1, 0x58, 0x58, 0x88, 0x6b, 0x78, 51 | 0x24, 0x69, 0x83, 0x79, 0x87, 0x71, 0x98, 0x07, 0x89, 0x2b, 0x1a, 0x5b, 0xb9, 0xbc, 0x15, 0xaf, 52 | 0xa3, 0xef, 0x24, 0x51, 0x2a, 0xe6, 0x8d, 0x79, 0xe6, 0x80, 0xcd, 0x94, 0x2f, 0x19, 0xee, 0x3f, 53 | 0x46, 0xf2, 0xfc, 0xa4, 0x3c, 0xe3, 0xbc, 0xbe, 0x7d, 0x9c, 0x55, 0x13, 0x4a, 0x43, 0xeb, 0xd8, 54 | 0xe9, 0xe6, 0xa7, 0xb8, 0x02, 0x26, 0x93, 0x2c, 0xb3, 0xc8, 0xbe, 0xe2, 0xb9, 0x2f, 0xbd, 0x1c, 55 | 0x8b, 0xac, 0xed, 0x37, 0x11, 0x15, 0x89, 0x0b, 0x82, 0x9f, 0x5c, 0x30, 0xb7, 0x6b, 0x05, 0x68, 56 | 0x7a, 0xd3, 0x74, 0xd4, 0xb1, 0xe8, 0xda, 0xb1, 0x19, 0x9b, 0xa9, 0xcf, 0x5f, 0x55, 0x69, 0x74, 57 | 0x4b, 0xee, 0x73, 0x21, 0x23, 0xd6, 0x05, 0x1b, 0xce, 0xb6, 0x89, 0xe5, 0xae, 0x63, 0x22, 0xa6, 58 | 0xee, 0x34, 0xf6, 0x8d, 0x97, 0x1b, 0xe3, 0xe3, 0xdf, 0x58, 0x31, 0x5b, 0x86, 0x6d, 0x38, 0x22, 59 | 0x2e, 0x10, 0x75, 0x4a, 0x05, 0x88, 0xd3, 0xdf, 0xf7, 0x08, 0x47, 0x42, 0xcb, 0x9a, 0xdf, 0x20, 60 | 0xd6, 0xa2, 0xf7, 0x17, 0xe4, 0x71, 0x57, 0xdb, 0xe1, 0x59, 0x9b, 0xfe, 0x20, 0xef, 0x41, 0xc4, 61 | 0x6b, 0xf7, 0xe8, 0xf2, 0x34, 0xcf, 0x40, 0xfb, 0x07, 0x5a, 0xa4, 0x74, 0x08, 0xe8, 0x23, 0x3d, 62 | 0x89, 0x0f, 0x97, 0x76, 0x3b, 0xbf, 0xfa, 0xdd, 0x51, 0x5d, 0x1c, 0xa9, 0x89, 0x49, 0xf2, 0x39, 63 | 0x8b, 0x42, 0x59, 0xa9, 0x04, 0xf2, 0xda, 0x54, 0xb0, 0x21, 0xf0, 0xd2, 0xdc, 0x1c, 0x36, 0x6c, 64 | 0x1a, 0x29, 0x39, 0xf9, 0x77, 0x98, 0x1c, 0x0e, 0xe3, 0x5d, 0x09, 0xe6, 0x2d, 0xb2, 0xf9, 0xd6, 65 | 0x5c, 0x75, 0x92, 0x7e, 0x9e, 0xb8, 0x51, 0x94, 0xc7, 0xbe, 0xd5, 0xea, 0xdc, 0xaa, 0x91, 0x00, 66 | 0x49, 0xee, 0xa9, 0x26, 0x9b, 0x58, 0xda, 0x04, 0xd1, 0x7b, 0x43, 0x9e, 0xbb, 0x87, 0x69, 0x46, 67 | 0x83, 0x56, 0x50, 0x44, 0xa9, 0x0c, 0x08, 0xa3, 0xb4, 0x65, 0x03, 0xed, 0x00, 0xf5, 0x7e, 0x01, 68 | 0xa8, 0xeb, 0xbf, 0x4d, 0xc2, 0x00, 0x4c, 0x44, 0x69, 0xff, 0x20, 0x6c, 0x72, 0x46, 0xaf, 0x4e, 69 | 0xd3, 0x6f, 0x4f, 0x82, 0x08, 0xb3, 0xdb, 0xac, 0x75, 0x0c, 0xce, 0xa4, 0x85, 0xfc, 0x96, 0x09, 70 | 0xbd, 0x50, 0xd2, 0x7b, 0x3e, 0xdd, 0xcd, 0xed, 0xa7, 0xf1, 0x6b, 0x6e, 0x3d, 0x08, 0x15, 0x62, 71 | 0x9d, 0x41, 0x9f, 0xf2, 0x8b, 0xda, 0xed, 0xc6, 0x70, 0x9a, 0xb3, 0x8d, 0x95, 0x97, 0xea, 0xb5, 72 | 0xe1, 0xf2, 0x1e, 0xe6, 0xb7, 0x41, 0x01, 0xc4, 0x29, 0x56, 0x03, 0x32, 0xc0, 0x71, 0xe7, 0x95, 73 | 0xc1, 0x9f, 0xa6, 0x7a, 0x11, 0x79, 0x1e, 0x67, 0x76, 0x33, 0x62, 0xd2, 0x6c, 0xab, 0x28, 0x68, 74 | 0xcc, 0x0a, 0xe1, 0x0b, 0x8a, 0x6d, 0x3a, 0x8a, 0x11, 0x10, 0x16, 0xd0, 0x6d, 0x40, 0xb7, 0xa8, 75 | 0x9a, 0xc7, 0xa2, 0xd5, 0x11, 0x11, 0x42, 0xb0, 0xff, 0x84, 0x95, 0xc0, 0x1c, 0x58, 0xd1, 0x6a, 76 | 0x4d, 0x68, 0x95, 0x33, 0x3f, 0x0b, 0x83, 0x8a, 0x07, 0xe6, 0xd4, 0xec, 0xb7, 0x6e, 0xb8, 0x3b, 77 | 0x85, 0x5d, 0x31, 0x33, 0xc0, 0x12, 0xb7, 0xb3, 0x29, 0x87, 0x3f, 0x19, 0x01, 0xa9, 0x94, 0xc1, 78 | 0x3f, 0x62, 0x8a, 0x1b, 0x6d, 0x7b, 0x4b, 0x7d, 0xe5, 0x63, 0xa6, 0xb0, 0x1a, 0x64, 0x77, 0xeb, 79 | 0x92, 0xc7, 0x70, 0x72, 0x64, 0x73, 0x46, 0x44, 0xb5, 0xe5, 0xa9, 0x38, 0xd8, 0x75, 0x37, 0x14, 80 | 0x96, 0x7c, 0x60, 0xc8, 0xee, 0xee, 0x1a, 0x24, 0x90, 0x66, 0x68, 0xde, 0xf6, 0x92, 0x24, 0xa3, 81 | 0x1d, 0x23, 0x36, 0xc9, 0xa2, 0x60, 0x45, 0xfd, 0x90, 0x95, 0x75, 0xaf, 0x52, 0xfc, 0x4a, 0xf5, 82 | 0x69, 0xe9, 0x0d, 0xb0, 0x0f, 0x1a, 0xf0, 0xad, 0x71, 0xba, 0x55, 0x22, 0x0f, 0x0c, 0x50, 0xa1, 83 | 0xdb, 0xa9, 0xc3, 0x16, 0xed, 0x4f, 0x61, 0xfa, 0x12, 0x47, 0x5b, 0xe8, 0x3b, 0x10, 0x27, 0xd5, 84 | 0xf5, 0x50, 0x68, 0xb5, 0x85, 0x76, 0x2f, 0x04, 0xd9, 0x38, 0x63, 0xcc, 0x9b, 0x58, 0xbe, 0xf4, 85 | 0x63, 0x50, 0xdd, 0xf7, 0xb2, 0xfb, 0xc8, 0x65, 0x68, 0x19, 0x84, 0x4e, 0xc5, 0x34, 0x4b, 0xe0, 86 | 0x39, 0x94, 0x0e, 0xbe, 0xca, 0x17, 0xa1, 0xcb, 0x21, 0x12, 0xc6, 0xe6, 0x09, 0x2f, 0x2b, 0x36, 87 | 0x2d, 0xaf, 0x7f, 0xd7, 0xc0, 0x5a, 0x26, 0x93, 0x6f, 0x89, 0x18, 0xef, 0xfe, 0x6c, 0x12, 0xa4, 88 | 0x68, 0xb6, 0x7b, 0xcc, 0xc7, 0x20, 0x66, 0x2c, 0x54, 0x00, 0x64, 0xc8, 0x06, 0x88, 0x8b, 0xd7, 89 | 0x76, 0x2f, 0x82, 0x66, 0xc6, 0xa4, 0x96, 0xf6, 0x5f, 0x83, 0x58, 0xf3, 0x6f, 0xce, 0xee, 0x20, 90 | 0xbd, 0x9f, 0x4f, 0x80, 0x52, 0xfb, 0xb0, 0x78, 0x7d, 0x63, 0x33, 0x28, 0xb2, 0x2f, 0xdf, 0x37, 91 | 0xa0, 0xbd, 0x10, 0xbf, 0xff, 0x6e, 0x2d, 0xe6, 0xa7, 0xc9, 0x04, 0xac, 0x65, 0x35, 0x1f, 0x79, 92 | 0x31, 0x45, 0x0e, 0x07, 0x11, 0x34, 0xae, 0xa1, 0x08, 0xef, 0x1f, 0x14, 0x35, 0x4d, 0x67, 0x75, 93 | 0xf1, 0x2b, 0x19, 0x6b, 0x26, 0xd3, 0xe7, 0x55, 0xb3, 0x54, 0x0b, 0x85, 0x6b, 0xa8, 0xf0, 0x93, 94 | 0x7b, 0xea, 0x13, 0xbc, 0x04, 0x47, 0xb5, 0x5a, 0xaf, 0x9c, 0x0a, 0xe3, 0x3a, 0xb8, 0x64, 0xd1, 95 | 0x7c, 0x93, 0xa8, 0xb1, 0x5a, 0x34, 0xd6, 0x06, 0x9e, 0x3b, 0xb9, 0xb4, 0x42, 0x0b, 0x4d, 0x41, 96 | 0x53, 0xf3, 0xdc, 0xe2, 0x1e, 0xaa, 0x72, 0xc4, 0x37, 0x2c, 0x23, 0x70, 0x12, 0x38, 0x17, 0xc6, 97 | 0x77, 0xb2, 0x80, 0x5a, 0x7c, 0xcb, 0xea, 0x05, 0x5c, 0x12, 0x16, 0xe3, 0x1a, 0x31, 0xf4, 0x50, 98 | 0xdb, 0xc6, 0xec, 0xf8, 0xce, 0x1c, 0xd3, 0x2b, 0x96, 0x47, 0x1e, 0x1b, 0x78, 0xb0, 0x40, 0xe9, 99 | 0xb8, 0x44, 0xd8, 0x3d, 0x28, 0x29, 0x8e, 0x27, 0x33, 0x23, 0x0f, 0xc2, 0x82, 0x6e, 0x24, 0x8d, 100 | 0x1d, 0xd9, 0xb2, 0xb6, 0x0d, 0xbd, 0x21, 0x8e, 0xe3, 0x5a, 0xb8, 0xc1, 0x92, 0xeb, 0x47, 0xbc, 101 | 0xd3, 0x1d, 0xd2, 0x26, 0x76, 0x41, 0x92, 0xbe, 0xaf, 0x2b, 0xca, 0xe0, 0x6f, 0xcd, 0x41, 0x3a, 102 | 0xc9, 0x2e, 0xaa, 0xa4, 0x62, 0xd8, 0xdb, 0xde, 0xf9, 0xdb, 0x76, 0xfb, 0x17, 0x99, 0xc2, 0x71, 103 | 0x63, 0x36, 0x71, 0xf1, 0x1f, 0xb5, 0x26, 0xa7, 0x04, 0x38, 0x02, 0xe1, 0x9d, 0x7f, 0x28, 0xb3, 104 | 0x8c, 0x53, 0x91, 0x6d, 0xbb, 0x70, 0x96, 0x14, 0x4e, 0x6a, 0x70, 0xed, 0x55, 0xf8, 0x23, 0xca, 105 | 0x07, 0x52, 0x11, 0xb9, 0xa2, 0x8f, 0x35, 0xbf, 0xb1, 0x14, 0x37, 0x48, 0xf3, 0xa5, 0x1b, 0x48, 106 | 0x34, 0x65, 0x29, 0x5b, 0x74, 0x93, 0xaa, 0x8b, 0x06, 0x83, 0xd7, 0x65, 0xb0, 0xd6, 0x7d, 0x3a, 107 | 0x54, 0xb7, 0xa1, 0x9a, 0xf3, 0x30, 0x8a, 0x2f, 0xbb, 0x25, 0x7b, 0x32, 0x42, 0x8f, 0x8b, 0x66, 108 | 0x17, 0xe2, 0x16, 0xe2, 0x28, 0x3d, 0xf2, 0xae, 0xd1, 0x9f, 0xad, 0xcd, 0xc1, 0x4a, 0xc2, 0x5c, 109 | 0x37, 0xe0, 0xf5, 0xea, 0x7f, 0x07, 0xf8, 0xae, 0x5e, 0x41, 0x25, 0x3d, 0x39, 0xb0, 0x35, 0x93, 110 | 0x6f, 0x5d, 0x80, 0xd7, 0x49, 0xd3, 0xe0, 0xff, 0x81, 0x7d, 0x8f, 0xeb, 0xb6, 0x52, 0xa9, 0xc8, 111 | 0xfb, 0xe0, 0x23, 0xd2, 0x42, 0x1d, 0xc2, 0x26, 0xc4, 0x49, 0x5e, 0x4c, 0x56, 0xa4, 0x91, 0xda, 112 | 0x82, 0xf6, 0xd0, 0xd1, 0x13, 0xcd, 0x54, 0xda, 0xd8, 0x9e, 0x99, 0xb0, 0x11, 0x82, 0xc0, 0x88, 113 | 0xd9, 0x7d, 0x06, 0xe8, 0xb1, 0x27, 0xc5, 0x88, 0x1c, 0xa2, 0xba, 0xbf, 0x33, 0x05, 0xbe, 0xca, 114 | 0xd4, 0x71, 0x4c, 0xd5, 0xc3, 0x49, 0x69, 0x85, 0xc0, 0x23, 0xd7, 0xdd, 0x4c, 0x95, 0xce, 0xe6, 115 | 0x3f, 0x47, 0xd0, 0x5e, 0x6e, 0xae, 0x88, 0x0a, 0xfb, 0xa6, 0x5c, 0xc9, 0x93, 0xf8, 0x5b, 0x6a, 116 | 0x9d, 0xb6, 0x2a, 0x34, 0xfe, 0x32, 0xd9, 0x82, 0x74, 0x44, 0x55, 0xa3, 0x18, 0x1e, 0x76, 0xaa, 117 | 0xb0, 0xb7, 0x61, 0x3e, 0xb2, 0x8f, 0x49, 0xc4, 0x4f, 0xd9, 0xae, 0x57, 0x47, 0x07, 0x86, 0xc0, 118 | 0xcd, 0xa5, 0xa3, 0xd4, 0xb3, 0xae, 0x18, 0x1a, 0xa9, 0x8f, 0xa2, 0xb1, 0xbb, 0xa9, 0xac, 0xb7, 119 | 0xe7, 0x3d, 0x5a, 0x0c, 0xb9, 0x7d, 0x93, 0x90, 0x07, 0xc6, 0x3c, 0x1e, 0xd5, 0xd9, 0x93, 0x46, 120 | 0x5b, 0xe7, 0xd3, 0x80, 0x54, 0x0d, 0xcc, 0x63, 0xf8, 0x83, 0x91, 0x39, 0xc7, 0xdb, 0xf3, 0xb4, 121 | 0x2b, 0x87, 0x59, 0x05, 0x5a, 0x4d, 0xea, 0xe2, 0x98, 0x10, 0x78, 0x3a, 0xbb, 0xa3, 0x34, 0xc8, 122 | 0xe9, 0xdd, 0xd5, 0xee, 0xa5, 0xa9, 0x78, 0xdd, 0xe1, 0x8b, 0x12, 0xbf, 0x60, 0x9d, 0x0f, 0x70, 123 | 0xb5, 0x0f, 0xa5, 0x27, 0x8c, 0xf7, 0x17, 0x92, 0xf3, 0x1b, 0xc5, 0xbe, 0x94, 0x45, 0x0d, 0xcd, 124 | 0x3b, 0xd6, 0x64, 0xbd, 0xf8, 0x93, 0x46, 0xd0, 0x26, 0xac, 0x81, 0x06, 0x62, 0x03, 0xd7, 0xb9, 125 | 0x60, 0x96, 0xa1, 0xe5, 0x09, 0x6e, 0xb6, 0x23, 0xa9, 0xd7, 0xe9, 0x7f, 0xd4, 0xae, 0x07, 0xaa, 126 | 0x4d, 0xbe, 0xac, 0x80, 0xbd, 0x79, 0xfd, 0xd0, 0xe4, 0x49, 0x2e, 0x15, 0xac, 0x99, 0xe3, 0xfe, 127 | 0xc8, 0x51, 0x5e, 0xd5, 0x10, 0xf9, 0xb4, 0x58, 0x4a, 0xdc, 0x4a, 0x24, 0xe0, 0x4f, 0x7d, 0x59, 128 | 0x23, 0x51, 0xd0, 0xd3, 0x93, 0xf5, 0x52, 0x4d, 0x05, 0xc8, 0xfe, 0x02, 0xca, 0x7e, 0x11, 0x2b, 129 | 0x8a, 0xda, 0xbd, 0x5c, 0xa7, 0x16, 0xd5, 0x85, 0x61, 0x74, 0x59, 0x5f, 0xeb, 0xee, 0x6d, 0x08, 130 | 0x04, 0xaf, 0x35, 0xee, 0x51, 0xc4, 0xe1, 0xd3, 0xbd, 0xfb, 0x95, 0x77, 0x09, 0x3b, 0x03, 0x96, 131 | 0xeb, 0xe8, 0xa4, 0x86, 0x14, 0x1f, 0x09, 0x46, 0x71, 0x35, 0x03, 0xbf, 0xee, 0x37, 0xd6, 0xc2, 132 | 0x86, 0xc9, 0x09, 0x28, 0xf1, 0x0c, 0x17, 0x29, 0xd5, 0xc1, 0xa8, 0xee, 0x7f, 0x98, 0x09, 0xc9, 133 | 0x92, 0x18, 0xb6, 0x5b, 0x01, 0x26, 0x7c, 0x9c, 0x8e, 0x51, 0x0c, 0x94, 0xd3, 0x85, 0xee, 0x2f, 134 | 0x2b, 0xf4, 0xee, 0xc0, 0x53, 0xc6, 0x45, 0x3a, 0xfe, 0xe6, 0xbf, 0xcc, 0x8f, 0xfc, 0xe5, 0x71, 135 | 0xf6, 0x70, 0x08, 0x50, 0xc8, 0x6d, 0x05, 0x7d, 0x9e, 0x6e, 0x2f, 0x01, 0x27, 0xb4, 0x3f, 0x35, 136 | 0x03, 0xba, 0xd4, 0xda, 0xa9, 0x2d, 0x4f, 0x0c, 0x6f, 0x3e, 0x67, 0x3a, 0xf0, 0x0b, 0x63, 0xce, 137 | 0xb0, 0x15, 0x3e, 0xa6, 0x0d, 0x20, 0x75, 0x21, 0x05, 0x5c, 0xce, 0xf6, 0xfd, 0x39, 0xe2, 0xc0, 138 | 0x36, 0x81, 0x89, 0x69, 0x9f, 0xe9, 0x8f, 0xff, 0x74, 0x98, 0x56, 0x9b, 0x76, 0x0f, 0x8c, 0xa8, 139 | 0x29, 0x75, 0x23, 0x3f, 0x9f, 0xb8, 0xb6, 0xd3, 0xd4, 0x09, 0x48, 0xd9, 0x0e, 0xda, 0x01, 0xc7, 140 | 0x41, 0xe3, 0x5f, 0x6c, 0x32, 0xc9, 0x8c, 0xf8, 0x06, 0xad, 0x60, 0xf2, 0x7c, 0x6d, 0xa5, 0x9b, 141 | 0x39, 0xe9, 0xa1, 0xbe, 0x70, 0x83, 0x1c, 0xc3, 0xf0, 0x61, 0x7b, 0x47, 0xb1, 0x39, 0xf8, 0x49, 142 | 0x45, 0x82, 0xbb, 0x79, 0xcf, 0x7e, 0xc6, 0xe3, 0x4b, 0x2f, 0xa7, 0x2f, 0xca, 0x2c, 0x98, 0x75, 143 | 0x2d, 0x0c, 0xdc, 0x52, 0x84, 0xe0, 0x87, 0x30, 0xa3, 0xc4, 0xb5, 0xc1, 0xe3, 0x68, 0x5d, 0xfb, 144 | 0xf3, 0x4c, 0xf7, 0x38, 0x6b, 0x7f, 0x89, 0x29, 0x79, 0x89, 0x67, 0x10, 0xbe, 0xfc, 0xe7, 0x55, 145 | 0x27, 0xe6, 0xaf, 0x7b, 0x10, 0x35, 0xff, 0xef, 0xb7, 0x98, 0x66, 0xf0, 0xc1, 0x32, 0x5e, 0x6d, 146 | 0xcc, 0xa0, 0xc1, 0xda, 0xb0, 0x49, 0xe2, 0x66, 0xb8, 0xab, 0x31, 0x33, 0xd0, 0xf5, 0x79, 0x57, 147 | 0xa9, 0x2f, 0xb0, 0x0d, 0xce, 0xc3, 0xbb, 0x4e, 0x3d, 0x16, 0x5b, 0xa1, 0x27, 0xae, 0x73, 0xea, 148 | 0x54, 0x02, 0xaf, 0x33, 0x4e, 0xfc, 0xd4, 0xce, 0x0a, 0xb7, 0xec, 0xb7, 0x4b, 0x2b, 0x2b, 0xc5, 149 | 0x11, 0x68, 0x24, 0x0a, 0x0c, 0xb7, 0x72, 0x17, 0x42, 0x4b, 0x0a, 0xb0, 0xe7, 0xdc, 0x9a, 0x2b, 150 | 0x58, 0x6a, 0xa2, 0x27, 0x82, 0x17, 0xef, 0x5b, 0x22, 0x40, 0x8a, 0x1f, 0x06, 0x5c, 0x67, 0xe2, 151 | 0xc5, 0x94, 0x85, 0x93, 0x48, 0x20, 0x20, 0xb5, 0x6d, 0xa4, 0x10, 0xe8, 0x4e, 0x1b, 0x3b, 0xfd, 152 | 0x07, 0x23, 0x59, 0x10, 0x6e, 0x5f, 0x5a, 0x88, 0x71, 0x70, 0x28, 0xda, 0xdb, 0x3e, 0x37, 0x62, 153 | 0x35, 0xe9, 0x79, 0x46, 0x40, 0x49, 0xcc, 0x18, 0x42, 0xd3, 0xa3, 0x41, 0xef, 0x2f, 0x9d, 0x37, 154 | 0xd3, 0xb9, 0x13, 0xfb, 0xd2, 0x6e, 0x53, 0x62, 0x01, 0x46, 0x94, 0x55, 0x18, 0x71, 0xfd, 0xeb, 155 | 0x84, 0xb9, 0xc8, 0x49, 0x4e, 0x5e, 0x83, 0x07, 0xcf, 0x17, 0x3a, 0x66, 0xeb, 0xbe, 0x7a, 0x34, 156 | 0xc1, 0xd4, 0x4f, 0x7a, 0x47, 0x93, 0x78, 0x8d, 0xb3, 0xdc, 0x68, 0x79, 0x6e, 0xa0, 0x8c, 0xb4, 157 | 0x61, 0xf4, 0x54, 0x8b, 0xb7, 0xb7, 0xd5, 0xc5, 0x35, 0x82, 0x08, 0x1b, 0xba, 0x75, 0xc2, 0xe9, 158 | 0x44, 0x5c, 0x90, 0x04, 0x00, 0xb8, 0xad, 0x8f, 0xd6, 0x4e, 0x75, 0x85, 0x4b, 0xf0, 0x85, 0x88, 159 | 0x78, 0xc9, 0x42, 0x4b, 0x0c, 0x17, 0x91, 0x6f, 0xfa, 0xe6, 0x9f, 0xc9, 0x3f, 0x76, 0xc6, 0x3f, 160 | 0x7e, 0x56, 0xa2, 0xbd, 0x8a, 0x5f, 0x54, 0xb5, 0xd1, 0x1b, 0xed, 0xec, 0x7f, 0x4e, 0xc7, 0x53, 161 | 0xa5, 0xba, 0x1c, 0x95, 0x82, 0x42, 0x58, 0xae, 0xa8, 0x8d, 0x7c, 0x7c, 0x65, 0x55, 0x32, 0x9d, 162 | 0xb4, 0xc1, 0x59, 0x87, 0x04, 0xea, 0xb4, 0x6e, 0xb3, 0x12, 0xb3, 0x0b, 0xe9, 0xaa, 0x4f, 0x61, 163 | 0xec, 0x4a, 0x50, 0x52, 0x56, 0xac, 0x96, 0xeb, 0xc7, 0x88, 0x84, 0xe5, 0xbf, 0x36, 0x59, 0xa6, 164 | 0xdb, 0x58, 0xc6, 0x4e, 0x9b, 0x23, 0xa5, 0xe2, 0xd0, 0xf3, 0x40, 0xba, 0xe4, 0xc9, 0x8a, 0x7a, 165 | 0x85, 0x5a, 0x3a, 0x9c, 0x66, 0xd7, 0x54, 0xdb, 0xf2, 0xab, 0xdb, 0x20, 0xf0, 0x34, 0x40, 0x80, 166 | 0x09, 0x79, 0x60, 0x9b, 0x4d, 0x06, 0xfb, 0xe8, 0x49, 0x15, 0xf9, 0x14, 0x8a, 0x31, 0xeb, 0x02, 167 | 0x86, 0x8a, 0xc4, 0x06, 0x93, 0xe8, 0x71, 0xb0, 0x2a, 0x64, 0x63, 0x45, 0xa0, 0x92, 0xe1, 0x4d, 168 | 0x28, 0x67, 0x3b, 0x99, 0x7a, 0xe3, 0xd0, 0x10, 0x0f, 0x09, 0x93, 0x00, 0x38, 0x5c, 0x86, 0x84, 169 | 0xf4, 0xaf, 0xf4, 0x4d, 0xc3, 0xf1, 0x59, 0x37, 0x8b, 0x1e, 0xcd, 0x1f, 0xa5, 0x98, 0x0e, 0xc6, 170 | 0xbb, 0x56, 0x82, 0xdd, 0x70, 0x03, 0x44, 0x75, 0x51, 0x2c, 0x5e, 0xf6, 0x41, 0x34, 0xdd, 0xd9, 171 | 0x59, 0x7f, 0x67, 0xe3, 0xf1, 0x66, 0x59, 0x5f, 0x48, 0xe4, 0x8d, 0x23, 0x3e, 0x5c, 0x4b, 0xa8, 172 | 0xa2, 0xce, 0x57, 0x49, 0x34, 0x89, 0x5b, 0x19, 0xb0, 0x85, 0xeb, 0xd3, 0xd3, 0x90, 0x24, 0xc3, 173 | 0xd0, 0x03, 0x8a, 0x57, 0xe9, 0x8e, 0x39, 0x99, 0xb0, 0x5a, 0x3c, 0xc4, 0xb8, 0x10, 0x6f, 0x34, 174 | 0x63, 0x97, 0x94, 0xca, 0xa7, 0x3c, 0xc3, 0x92, 0x94, 0x65, 0x32, 0x46, 0x5f, 0xd1, 0xc1, 0x71, 175 | 0x8b, 0x0d, 0xac, 0x4a, 0x06, 0xdf, 0x12, 0x8f, 0xa8, 0x6a, 0x1c, 0xf8, 0x6e, 0x68, 0xb3, 0x2c, 176 | 0xee, 0x14, 0x9b, 0xd1, 0x36, 0xad, 0x22, 0xa3, 0xa2, 0x6c, 0x94, 0x9b, 0xbe, 0xbe, 0x04, 0xed, 177 | 0xd5, 0xd3, 0xdc, 0xce, 0xb9, 0x2d, 0x8d, 0x34, 0xe0, 0x61, 0x09, 0x26, 0x31, 0x83, 0x2d, 0x43, 178 | 0x1a, 0x75, 0xb5, 0x14, 0xd3, 0xd2, 0xa3, 0x3b, 0x05, 0x3f, 0xaf, 0xbc, 0x2f, 0x30, 0x79, 0x51, 179 | 0x9c, 0x20, 0x4f, 0x0c, 0x4d, 0x71, 0xd5, 0xc4, 0x2d, 0xa1, 0x87, 0x4d, 0xdc, 0x6c, 0xb4, 0x01, 180 | 0x89, 0xbd, 0x48, 0x8a, 0xfc, 0xc2, 0x28, 0xe5, 0xd9, 0xbe, 0xc6, 0xd1, 0x8a, 0x4e, 0xfb, 0x1c, 181 | 0x15, 0xf7, 0x68, 0x73, 0x96, 0x1c, 0x0c, 0x07, 0x6f, 0xef, 0x50, 0x9f, 0x01, 0x9a, 0xbf, 0x18, 182 | 0x41, 0xd9, 0xe5, 0x58, 0x67, 0x16, 0x9f, 0x44, 0x64, 0xb8, 0x8a, 0x60, 0x1f, 0xf0, 0x2c, 0xa4, 183 | 0x50, 0x09, 0x48, 0x9a, 0x3a, 0x8c, 0xe5, 0x88, 0x48, 0x34, 0x2e, 0x17, 0x37, 0xf4, 0x40, 0xd8, 184 | 0xdb, 0xae, 0xcf, 0xf8, 0xbc, 0xb8, 0xd6, 0x08, 0x08, 0xbb, 0xcf, 0xda, 0x2d, 0x75, 0x96, 0xa7, 185 | 0xe8, 0xd5, 0x99, 0x1f, 0xd1, 0xa6, 0xc7, 0x6f, 0x79, 0x40, 0x80, 0x07, 0x77, 0xa9, 0x00, 0x68, 186 | 0x5c, 0x7b, 0x00, 0xc1, 0xd7, 0xa7, 0x23, 0x6a, 0xa5, 0x2c, 0x0d, 0x35, 0xc9, 0xdc, 0xb1, 0xbd, 187 | 0x05, 0x4a, 0x1c, 0x00, 0xa5, 0x13, 0x54, 0x5b, 0x31, 0x34, 0x4c, 0x5d, 0xad, 0x6b, 0x6b, 0x36, 188 | 0x8a, 0x7f, 0x05, 0x86, 0xec, 0x03, 0xa3, 0xef, 0x0d, 0x2d, 0x43, 0x09, 0x47, 0xdd, 0x17, 0x48, 189 | 0xbd, 0x3a, 0xac, 0x8c, 0x10, 0x20, 0xdf, 0x62, 0xc0, 0xb5, 0x7c, 0xd3, 0x2b, 0xe7, 0x4c, 0x92, 190 | 0x1c, 0x78, 0x47, 0x34, 0x16, 0x24, 0xdd, 0x63, 0x0e, 0xa9, 0x9c, 0x85, 0x14, 0x81, 0x95, 0x9f, 191 | 0xab, 0xf7, 0x51, 0xc6, 0x7c, 0xfc, 0xfa, 0x23, 0xab, 0x7f, 0x41, 0x41, 0x17, 0xf3, 0x21, 0x3c, 192 | 0x73, 0x01, 0x23, 0xb6, 0x1d, 0x7c, 0xa9, 0x89, 0x09, 0xba, 0xc9, 0xaf, 0x09, 0x03, 0x92, 0x26, 193 | 0xc3, 0xe8, 0x6d, 0x6e, 0x08, 0x1e, 0x9e, 0x1d, 0x60, 0x5b, 0x1d, 0x14, 0x52, 0x09, 0x09, 0x55, 194 | 0xc7, 0x0f, 0x1e, 0xa1, 0x0b, 0x2b, 0xfe, 0x85, 0xd8, 0x06, 0x1a, 0x86, 0xc4, 0x05, 0xfd, 0xe6, 195 | 0x9b, 0x11, 0xb3, 0x92, 0x3e, 0x84, 0xcc, 0x15, 0xe1, 0x51, 0xcc, 0x5a, 0x99, 0x25, 0x11, 0xe3, 196 | 0x2b, 0xa1, 0xe2, 0x78, 0xbf, 0x91, 0x8f, 0xb2, 0xd5, 0x3f, 0xaf, 0x8c, 0x4a, 0x39, 0xee, 0x02, 197 | 0x20, 0xd7, 0x79, 0xcf, 0x2a, 0xbd, 0xba, 0x47, 0x53, 0xe5, 0x70, 0x46, 0x2a, 0x0e, 0x22, 0x64, 198 | 0x5f, 0xef, 0x94, 0xf6, 0x1c, 0xa3, 0x5f, 0x85, 0x65, 0xe3, 0x92, 0xfe, 0xf0, 0x01, 0xde, 0x2c, 199 | 0x72, 0x74, 0x16, 0xbb, 0x66, 0x27, 0x3c, 0x86, 0x68, 0x27, 0x81, 0x5c, 0x7b, 0xbc, 0x52, 0xdf, 200 | 0x6b, 0x06, 0x48, 0x8d, 0x68, 0x9e, 0xeb, 0xc0, 0x48, 0xa0, 0xbf, 0x9b, 0x0d, 0x71, 0x62, 0x8e, 201 | 0x1c, 0x10, 0xe4, 0x5c, 0xf4, 0x4a, 0x1e, 0x8a, 0xd9, 0x48, 0x67, 0xbf, 0x8e, 0x58, 0xb4, 0x93, 202 | 0x8a, 0xd3, 0x4d, 0xdf, 0xc4, 0x47, 0x97, 0x36, 0xe1, 0x4d, 0x93, 0x77, 0x17, 0xd1, 0x04, 0xac, 203 | 0x6c, 0x0c, 0x85, 0x8c, 0xdf, 0xb7, 0x76, 0x09, 0xec, 0x2c, 0x14, 0x38, 0x45, 0xf9, 0x84, 0x7b, 204 | 0xc3, 0xdb, 0xc5, 0xec, 0x86, 0x24, 0xa4, 0xbd, 0xd8, 0x0a, 0x21, 0xc0, 0x28, 0xed, 0x63, 0xe3, 205 | 0x8c, 0x7f, 0xd2, 0xf3, 0xf4, 0xe9, 0xd6, 0xb1, 0x50, 0x47, 0x42, 0xb7, 0x13, 0x8b, 0x69, 0xfa, 206 | 0xfb, 0x2a, 0x8d, 0xc2, 0x0c, 0x51, 0xa8, 0xa4, 0x16, 0x78, 0x21, 0xc2, 0x5c, 0x38, 0x1c, 0x6d, 207 | 0x85, 0x07, 0x35, 0x04, 0x08, 0x79, 0xfe, 0x6e, 0xf1, 0x87, 0x52, 0x1c, 0x83, 0xd5, 0xe3, 0x85, 208 | 0x41, 0x06, 0xd8, 0x5e, 0x7a, 0xf3, 0x28, 0x50, 0x0f, 0x42, 0xbb, 0xde, 0xdb, 0x89, 0x17, 0xe4, 209 | 0x80, 0xfc, 0x9a, 0xde, 0x58, 0x87, 0x23, 0xe4, 0x2c, 0x26, 0x42, 0xa8, 0x0b, 0x46, 0x8e, 0xba, 210 | 0x65, 0x76, 0xe4, 0x68, 0xd9, 0x0a, 0xc8, 0xda, 0xf4, 0xa4, 0xd6, 0xa1, 0x00, 0xc4, 0xe9, 0x06, 211 | 0x94, 0x7f, 0xa0, 0x39, 0x08, 0x94, 0x43, 0x12, 0x4c, 0x2f, 0x9e, 0xe7, 0xf1, 0x2e, 0x0a, 0x54, 212 | 0x61, 0x13, 0x81, 0x38, 0x51, 0x4f, 0xbb, 0xf5, 0x66, 0xeb, 0x1d, 0x3d, 0x06, 0x85, 0x02, 0xae, 213 | 0x53, 0x95, 0x19, 0xd1, 0x79, 0xbf, 0x10, 0xcb, 0xca, 0x41, 0x60, 0x9d, 0x76, 0x45, 0x3c, 0xf1, 214 | 0x4c, 0x67, 0x9d, 0x6c, 0x51, 0x1c, 0x4f, 0x96, 0xf0, 0xc4, 0x81, 0xc3, 0x0c, 0x43, 0xb8, 0xa4, 215 | 0xf3, 0xba, 0xc0, 0x4b, 0x70, 0x6a, 0xf0, 0xe2, 0xf1, 0x61, 0x1b, 0x94, 0x42, 0x5f, 0x2f, 0xb8, 216 | 0xd7, 0x1b, 0x34, 0xf9, 0xd0, 0x6a, 0x58, 0x38, 0xa2, 0xfc, 0x0e, 0x78, 0x52, 0x6a, 0xd0, 0x06, 217 | 0xea, 0x6c, 0x5c, 0x86, 0x08, 0xa2, 0x27, 0xef, 0x0b, 0xad, 0xd0, 0x1e, 0x71, 0x25, 0x91, 0xbc, 218 | 0x63, 0x32, 0xa0, 0x94, 0xa3, 0xca, 0xa6, 0xe3, 0x04, 0x36, 0x61, 0xf0, 0xdd, 0x90, 0xe8, 0x72, 219 | 0x58, 0x16, 0x78, 0x37, 0x8d, 0xdd, 0x20, 0x90, 0x28, 0x59, 0x82, 0x3a, 0xf3, 0xa9, 0x9b, 0xf4, 220 | 0x18, 0xb8, 0x64, 0xea, 0xa1, 0x9a, 0x0d, 0x13, 0x1c, 0x3f, 0x92, 0x0b, 0x82, 0x58, 0xf2, 0x50, 221 | 0x12, 0xb6, 0x0b, 0x8f, 0x8b, 0x56, 0x0d, 0xbb, 0x19, 0x2f, 0xf5, 0xe1, 0x3e, 0x8f, 0x24, 0x15, 222 | 0xc9, 0x05, 0x09, 0x28, 0xa0, 0x2a, 0x7b, 0xf5, 0x16, 0xbb, 0x0a, 0x71, 0x36, 0xcb, 0xbf, 0xb6, 223 | 0x5f, 0x03, 0xa1, 0xe5, 0x6d, 0x17, 0xd7, 0x10, 0x23, 0x06, 0x4d, 0xe6, 0xb5, 0xe9, 0xe0, 0xb7, 224 | 0x3a, 0xc5, 0x1c, 0xf8, 0x63, 0x0a, 0x37, 0x43, 0xa1, 0xae, 0x3a, 0x48, 0x94, 0x6f, 0xcb, 0xaf, 225 | 0x63, 0xab, 0x36, 0x30, 0xb6, 0xcc, 0x09, 0x4c, 0xb4, 0x3f, 0xed, 0xcc, 0x65, 0x84, 0x91, 0xc4, 226 | 0xf9, 0x59, 0xff, 0x87, 0x0b, 0xa8, 0xf6, 0x08, 0x70, 0x97, 0x43, 0xa2, 0x9a, 0xa1, 0x45, 0xae, 227 | 0xc5, 0x37, 0xf9, 0xfe, 0xf5, 0xed, 0xa5, 0x26, 0xb0, 0x98, 0xdd, 0x87, 0x03, 0x3d, 0xa0, 0xe4, 228 | 0x00, 0x72, 0x80, 0x70, 0x12, 0xb1, 0x37, 0x05, 0x5a, 0x60, 0xf7, 0xcc, 0xd6, 0x4c, 0xf1, 0x8f, 229 | 0x3c, 0xcb, 0xa2, 0xe4, 0xd2, 0x8d, 0x4d, 0x32, 0xce, 0x4f, 0xc1, 0x0c, 0x99, 0xfc, 0x98, 0x9c, 230 | 0x42, 0xa7, 0x68, 0xda, 0xc5, 0x0f, 0x66, 0xa9, 0x63, 0xec, 0xfc, 0x6f, 0x72, 0xdf, 0x13, 0xbf, 231 | 0x63, 0x51, 0x90, 0xf2, 0x3b, 0x42, 0xfe, 0xb2, 0x67, 0x65, 0x51, 0x9d, 0xa9, 0xb4, 0xe9, 0x40, 232 | 0x26, 0xc1, 0x29, 0xa9, 0x88, 0x3e, 0x53, 0x84, 0xf9, 0xea, 0xe6, 0x73, 0x85, 0x78, 0x83, 0x59, 233 | 0x7f, 0x0c, 0x80, 0x42, 0x8d, 0x4c, 0xbf, 0x15, 0xe6, 0xc3, 0xeb, 0x60, 0x0a, 0x0f, 0x3f, 0xf3, 234 | 0xf8, 0xc2, 0x3c, 0xa6, 0x2f, 0xc0, 0xc0, 0x69, 0x9b, 0xf1, 0x57, 0xd4, 0xa2, 0x26, 0x66, 0xc5, 235 | 0x20, 0x46, 0x21, 0xff, 0x45, 0x5f, 0xd1, 0xe7, 0xdc, 0x79, 0x2a, 0x3e, 0x15, 0xab, 0xad, 0x53, 236 | 0xb3, 0x5a, 0xf8, 0x76, 0xf3, 0x1d, 0xd0, 0xd2, 0x65, 0xec, 0x1e, 0xff, 0x10, 0x34, 0xa2, 0xdd, 237 | 0xb9, 0x6b, 0x69, 0x2a, 0x16, 0xe9, 0x07, 0x54, 0x51, 0x43, 0x8a, 0x2d, 0x20, 0xdb, 0x2d, 0xaf, 238 | 0xd8, 0x94, 0xb2, 0xed, 0x16, 0xc8, 0x86, 0x59, 0xc3, 0x65, 0x75, 0x16, 0x88, 0x4c, 0x0a, 0x82, 239 | 0x41, 0x13, 0x93, 0x45, 0xed, 0xa2, 0x56, 0x22, 0x0b, 0x47, 0xed, 0xb9, 0xbd, 0xab, 0xc5, 0xb6, 240 | 0xb5, 0xb8, 0x79, 0xc9, 0x8d, 0x88, 0xfa, 0x87, 0xc7, 0x9b, 0xf8, 0xe6, 0x0d, 0x4f, 0x68, 0x2f, 241 | 0x51, 0xf3, 0x3f, 0x09, 0x20, 0x8f, 0x48, 0x51, 0x43, 0x77, 0xe1, 0x32, 0xe4, 0x96, 0xcd, 0x1b, 242 | 0x98, 0xd7, 0x30, 0xc6, 0xe1, 0x78, 0xde, 0x39, 0xa6, 0x5c, 0xe9, 0x7d, 0x84, 0x00, 0xd1, 0x94, 243 | 0x0e, 0xfb, 0x86, 0xc2, 0x86, 0xf4, 0x0a, 0xa3, 0xa5, 0x74, 0x9a, 0xdc, 0xa3, 0xee, 0xb6, 0x0d, 244 | 0xab, 0x4d, 0x7a, 0x85, 0xfe, 0x3e, 0x25, 0x13, 0x8c, 0x8c, 0x9d, 0x84, 0xc1, 0xd3, 0x0d, 0x6c, 245 | 0x3c, 0xee, 0x69, 0x51, 0x4a, 0x2f, 0x85, 0x6a, 0x6d, 0x9a, 0xc4, 0x8e, 0xb9, 0xf0, 0x55, 0x9a, 246 | 0xe5, 0x01, 0xf1, 0x0c, 0x13, 0xfb, 0x0a, 0x65, 0xf6, 0xde, 0xfa, 0x4e, 0x0b, 0x47, 0xae, 0x04, 247 | 0x6c, 0x41, 0xdb, 0x7b, 0x8d, 0xde, 0x47, 0xf2, 0x65, 0x9f, 0x55, 0x1f, 0xfa, 0x34, 0xb9, 0x26, 248 | 0x56, 0x5b, 0x29, 0xa6, 0x42, 0x49, 0xc1, 0x67, 0xbf, 0x2c, 0x66, 0x45, 0x06, 0x12, 0xaf, 0xbe, 249 | 0xe4, 0xdc, 0xcd, 0xf3, 0x71, 0x9d, 0x33, 0x0d, 0x55, 0x3c, 0xf5, 0xc3, 0xca, 0xde, 0x4c, 0x1d, 250 | 0xa9, 0x50, 0xd1, 0x83, 0x51, 0x38, 0x44, 0x0f, 0xb5, 0x66, 0xe1, 0x16, 0x15, 0x89, 0x93, 0x69, 251 | 0x4d, 0x8e, 0x60, 0x9b, 0x22, 0xa4, 0x67, 0xe3, 0xe3, 0x93, 0x4c, 0x6d, 0x5f, 0xc4, 0xcf, 0xb2, 252 | 0xd6, 0xa1, 0xe2, 0x04, 0x1d, 0x96, 0x67, 0x7e, 0xe8, 0xa9, 0x76, 0x2f, 0x75, 0x9f, 0xff, 0x35, 253 | 0xef, 0x12, 0x4f, 0x02, 0xa1, 0x9c, 0x2d, 0x8e, 0xb3, 0xbc, 0xad, 0xa6, 0x2f, 0xdf, 0x04, 0xb9, 254 | 0x04, 0xdf, 0x60, 0x83, 0x5d, 0x24, 0xe3, 0x08, 0x55, 0xca, 0x7c, 0x1a, 0xad, 0x89, 0x17, 0xf6, 255 | 0x47, 0xe8, 0xee, 0x65, 0xfa, 0x95, 0xf9, 0xe7, 0xe2, 0x98, 0x65, 0x81, 0x7c, 0xa9, 0xeb, 0xae, 256 | 0x0f, 0x04, 0x88, 0xf1, 0x32, 0x48, 0x75, 0x04, 0xba, 0x5c, 0x41, 0x86, 0xe2, 0x4c, 0xd2, 0xe6, 257 | 0xcc, 0xa6, 0x1d, 0xbf, 0x48, 0x4d, 0x65, 0x66, 0x55, 0x1a, 0x6a, 0x60, 0xe6, 0xd0, 0xe9, 0x55, 258 | 0xf9, 0x64, 0x04, 0x54, 0x47, 0x2b, 0x4b, 0x05, 0xe9, 0xce, 0x10, 0x04, 0x62, 0x26, 0x8b, 0xed, 259 | 0x45, 0x3f, 0x80, 0x77, 0xa1, 0x8d, 0xaa, 0x74, 0x9e, 0x90, 0xa4, 0x82, 0x65, 0xc5, 0xf9, 0x56, 260 | 0x50, 0xc0, 0x02, 0xcf, 0xbd, 0x3b, 0x78, 0x16, 0x53, 0xda, 0xdc, 0xd0, 0x27, 0xf8, 0x26, 0x28, 261 | 0x50, 0xe1, 0x53, 0x54, 0x0a, 0x91, 0x70, 0xf2, 0x78, 0xc7, 0xef, 0xc2, 0xdd, 0xa9, 0x15, 0x5f, 262 | 0xb3, 0x7e, 0x69, 0x1e, 0x2d, 0xb0, 0x35, 0x87, 0x7b, 0xb4, 0x81, 0xf1, 0x2a, 0x2f, 0xe5, 0xce, 263 | 0x03, 0xe4, 0x03, 0xa7, 0xf9, 0x1a, 0xd1, 0x18, 0x3d, 0xd7, 0xec, 0x7d, 0x89, 0x8b, 0x5c, 0x1c, 264 | 0x6d, 0x23, 0x18, 0xc8, 0xc8, 0x2f, 0xe5, 0xa7, 0x72, 0x2d, 0x72, 0xb6, 0x2f, 0xed, 0xcb, 0xbd, 265 | 0x0e, 0x7b, 0x6b, 0x55, 0x13, 0x55, 0x37, 0x05, 0x2a, 0x7d, 0xaf, 0x9a, 0x8a, 0xa4, 0xe4, 0x4c, 266 | 0x48, 0x01, 0xd6, 0x05, 0x81, 0x81, 0x4f, 0x85, 0x2e, 0x58, 0x28, 0x4f, 0xe1, 0x71, 0x5a, 0xf2, 267 | 0x9a, 0x4f, 0x43, 0x31, 0x01, 0x7f, 0xd8, 0x8c, 0x38, 0xad, 0x79, 0x4b, 0x94, 0xf8, 0xfc, 0x86, 268 | 0xa5, 0xb9, 0xa3, 0xbd, 0x8e, 0x3c, 0x0e, 0x8e, 0xc9, 0xfd, 0x92, 0xbc, 0xe6, 0xcd, 0x27, 0xed, 269 | 0xaa, 0x2d, 0x70, 0x8b, 0x89, 0xe7, 0x7d, 0x73, 0x76, 0x6e, 0x51, 0x7e, 0x9b, 0xc7, 0xc8, 0x69, 270 | 0xf1, 0x9e, 0x53, 0x7a, 0x29, 0xed, 0x9c, 0x25, 0xc1, 0x69, 0x3e, 0x80, 0x3c, 0x60, 0x2b, 0x40, 271 | 0x4a, 0x5c, 0xa9, 0x43, 0x8f, 0x23, 0x61, 0x4b, 0xc7, 0xd1, 0x46, 0xad, 0xa5, 0x5e, 0x33, 0x3e, 272 | 0xeb, 0x47, 0x01, 0x08, 0xf1, 0x1c, 0xae, 0x8b, 0xf2, 0x36, 0x91, 0x5d, 0x69, 0x5c, 0x55, 0xee, 273 | 0x9e, 0x8b, 0xba, 0xe6, 0x10, 0xb8, 0x7e, 0x29, 0xa9, 0x79, 0xf4, 0x1a, 0xd4, 0x2c, 0x39, 0xa8, 274 | 0xdd, 0x1e, 0x84, 0xe7, 0x5c, 0x72, 0x43, 0xe0, 0x6d, 0xea, 0xc8, 0x19, 0x09, 0x44, 0x9a, 0xc8, 275 | 0x02, 0x87, 0xde, 0x6a, 0xd5, 0x80, 0x75, 0x06, 0x5d, 0xc4, 0x12, 0x9f, 0x4c, 0xb6, 0x9e, 0x31, 276 | 0x82, 0xb8, 0x84, 0x79, 0x5c, 0x42, 0xfc, 0x92, 0xf2, 0xc2, 0x2d, 0x07, 0x8c, 0x01, 0xfb, 0x62, 277 | 0xd2, 0xf4, 0xb0, 0x71, 0xe0, 0x72, 0x50, 0xb5, 0xc0, 0xa9, 0x2c, 0x58, 0x89, 0x07, 0x0d, 0xd2, 278 | 0x44, 0xc7, 0x45, 0x25, 0x89, 0xf0, 0x38, 0xc3, 0xca, 0x90, 0x41, 0xbe, 0xfd, 0xa6, 0xde, 0xa3, 279 | 0x5a, 0x3d, 0x3c, 0xab, 0x77, 0xf3, 0x34, 0xdd, 0xad, 0xf4, 0x6a, 0x54, 0x24, 0x56, 0x04, 0xa1, 280 | 0x49, 0x52, 0x12, 0xf7, 0x51, 0x36, 0x5c, 0x76, 0x46, 0x29, 0xb4, 0x9b, 0x67, 0xfa, 0x6d, 0x8d, 281 | 0x09, 0xe6, 0xcd, 0x81, 0x8c, 0x60, 0xf0, 0xd0, 0x20, 0xdd, 0x33, 0xb9, 0x76, 0x06, 0x29, 0x37, 282 | 0x0e, 0x27, 0x42, 0xe7, 0x6e, 0xdf, 0xc0, 0x21, 0x62, 0x2c, 0x3a, 0xca, 0x08, 0xcf, 0xfa, 0xaf, 283 | 0x74, 0x5e, 0xe5, 0xe1, 0xc0, 0x8e, 0xe9, 0x7a, 0x1d, 0x70, 0xa4, 0x2c, 0x4f, 0x36, 0x7a, 0xfe, 284 | 0x20, 0xfd, 0xb6, 0x2b, 0xa4, 0xf1, 0x12, 0x7f, 0xfc, 0x7d, 0xdc, 0x92, 0x73, 0xd6, 0xba, 0xc3, 285 | 0xfb, 0x8d, 0xdf, 0xc4, 0x1d, 0xa1, 0x03, 0xa0, 0x93, 0xb5, 0xe8, 0x3c, 0xfc, 0x75, 0xf8, 0xf8, 286 | 0x65, 0x0c, 0x84, 0x67, 0x92, 0x56, 0x94, 0xd8, 0x62, 0x1b, 0x3f, 0x38, 0x23, 0x8a, 0xd6, 0x1c, 287 | 0x8c, 0x62, 0x69, 0x9f, 0x4d, 0x49, 0x97, 0x5d, 0xe0, 0x43, 0x3f, 0xeb, 0xc7, 0x2f, 0xeb, 0xa3, 288 | 0x87, 0x72, 0xbf, 0x4c, 0xff, 0x55, 0x13, 0x45, 0xe8, 0x6b, 0xe7, 0xad, 0x07, 0x59, 0x10, 0xdb, 289 | 0x1c, 0xf5, 0x21, 0x8e, 0x60, 0xfa, 0xbe, 0xcb, 0x3b, 0x64, 0xd8, 0x0a, 0xdd, 0xca, 0x7a, 0x3b, 290 | 0x30, 0x3b, 0x6d, 0x0f, 0x38, 0xcb, 0x4e, 0xe0, 0x68, 0x2f, 0x9e, 0xe1, 0x19, 0xd1, 0xb2, 0xbd, 291 | 0x75, 0x65, 0x76, 0xc9, 0x4f, 0x7a, 0xab, 0xd5, 0xb6, 0xe5, 0xe7, 0x60, 0x91, 0xf8, 0x9e, 0x44, 292 | 0x61, 0x46, 0x71, 0xc9, 0x3c, 0x3b, 0x48, 0x70, 0x8b, 0xb0, 0x87, 0x51, 0x25, 0x18, 0x13, 0xe2, 293 | 0x1f, 0x11, 0xfb, 0xa3, 0xe8, 0xb8, 0xc4, 0xcd, 0xaa, 0x02, 0x24, 0x6c, 0x7c, 0xca, 0xa1, 0xe1, 294 | 0x5c, 0xdc, 0x35, 0x3c, 0x0a, 0x80, 0x8c, 0xa1, 0x25, 0xba, 0x37, 0xe7, 0x9b, 0x3b, 0xbd, 0x6d, 295 | 0xdf, 0x37, 0xeb, 0x2e, 0xac, 0x77, 0xbc, 0xf4, 0x20, 0x00, 0x8f, 0x56, 0x33, 0x98, 0x99, 0xed, 296 | 0xc3, 0xd4, 0xf7, 0x33, 0x43, 0xf1, 0x96, 0x6c, 0x7e, 0x07, 0x2c, 0x68, 0xfb, 0xd6, 0xaa, 0x58, 297 | 0x10, 0x9c, 0xeb, 0x0b, 0xc0, 0x52, 0xcd, 0x74, 0x3b, 0xf9, 0xd9, 0xe7, 0x3e, 0x46, 0x8b, 0xcd, 298 | 0xaa, 0x2c, 0xbd, 0xf5, 0x03, 0x92, 0x22, 0x3c, 0xe0, 0xc5, 0x61, 0xd8, 0xec, 0x70, 0xda, 0x42, 299 | 0x88, 0x53, 0xa6, 0x49, 0x1a, 0xf6, 0x7f, 0xc7, 0xef, 0xac, 0x6b, 0xf8, 0xae, 0x55, 0x13, 0x5b, 300 | 0xd9, 0x77, 0x47, 0xf8, 0xe4, 0x05, 0x21, 0xd3, 0x24, 0xf3, 0x40, 0xc0, 0xa3, 0x11, 0x45, 0x79, 301 | 0xbe, 0xe2, 0xee, 0x79, 0x00, 0xe9, 0x8a, 0x9a, 0x21, 0x4e, 0x35, 0x68, 0x11, 0xba, 0xbe, 0xe1, 302 | 0xbf, 0x25, 0xbb, 0xd5, 0x55, 0x2f, 0xb9, 0x16, 0xad, 0x2b, 0x46, 0xe4, 0x60, 0x0e, 0x4a, 0x0e, 303 | 0xe9, 0xa9, 0xdb, 0x21, 0xc2, 0xa2, 0xa4, 0xc4, 0x7b, 0x58, 0x31, 0x63, 0x5c, 0xc9, 0x15, 0x36, 304 | 0x2c, 0xea, 0x87, 0xb6, 0x4a, 0xb3, 0xa3, 0xf8, 0xba, 0x53, 0x83, 0x94, 0xd8, 0xaf, 0x04, 0x07, 305 | 0x2a, 0xe8, 0x1b, 0x85, 0xfd, 0xe1, 0x1d, 0x37, 0x95, 0x0c, 0x3f, 0xb7, 0xd6, 0xd1, 0x19, 0x74, 306 | 0x60, 0xc8, 0xba, 0xf2, 0x49, 0xac, 0xb2, 0x0f, 0xd7, 0x03, 0xcf, 0x14, 0x9a, 0xa8, 0x78, 0x98, 307 | 0x4b, 0x34, 0x5b, 0x82, 0x1d, 0xb0, 0x4a, 0xbc, 0xd4, 0xac, 0xc6, 0x59, 0x45, 0xa4, 0x43, 0x48, 308 | 0x56, 0x7d, 0x86, 0xac, 0x69, 0x1c, 0xd5, 0x3c, 0xce, 0xbf, 0x4c, 0x6e, 0xf8, 0x4f, 0x32, 0xa8, 309 | 0x61, 0x07, 0x43, 0xa6, 0x4f, 0x8c, 0xd9, 0x99, 0xbf, 0x29, 0x7a, 0xf4, 0x6f, 0x5d, 0x2f, 0x6c, 310 | 0xdf, 0x53, 0xee, 0xe0, 0x46, 0x1a, 0x70, 0xf3, 0xf6, 0xbf, 0x0c, 0x4f, 0xcf, 0xf7, 0x77, 0xb2, 311 | 0xee, 0x2c, 0x5f, 0xca, 0xb8, 0x6c, 0x23, 0xbe, 0xb0, 0x93, 0x90, 0x47, 0x1a, 0x8b, 0x92, 0x7d, 312 | 0x74, 0x4e, 0x69, 0x0f, 0x10, 0xbe, 0x2f, 0x10, 0xa3, 0x67, 0x74, 0xe4, 0xde, 0x50, 0xcc, 0xf7, 313 | 0x56, 0x09, 0x2e, 0x48, 0x2e, 0x37, 0x43, 0x60, 0xbb, 0x29, 0xcf, 0x39, 0x55, 0x8d, 0x76, 0x15, 314 | 0xf9, 0xc0, 0x84, 0x96, 0x36, 0x4d, 0x2b, 0x8b, 0x44, 0x80, 0x6b, 0x44, 0x33, 0xd5, 0xe1, 0x6d, 315 | 0xa8, 0x0f, 0xf8, 0x3a, 0x9c, 0xf1, 0xe5, 0xef, 0xa2, 0xa8, 0x3f, 0xa3, 0xa3, 0x29, 0x36, 0xec, 316 | 0xcc, 0xc6, 0x03, 0x06, 0x42, 0xd9, 0x10, 0x60, 0x30, 0xf0, 0x56, 0x2c, 0x27, 0xda, 0x6b, 0x80, 317 | 0x95, 0x20, 0xd4, 0x9d, 0x8a, 0x46, 0x74, 0x82, 0x7b, 0xf0, 0xf3, 0x5f, 0x96, 0x32, 0xa2, 0xa0, 318 | 0x01, 0xed, 0x35, 0x03, 0x76, 0x1a, 0x75, 0x2e, 0x2b, 0x4c, 0xc5, 0x20, 0x1b, 0xf7, 0x0b, 0x4a, 319 | 0xa7, 0xb9, 0xce, 0x4f, 0x4c, 0x25, 0x06, 0x0d, 0x29, 0x72, 0xa3, 0x1a, 0xca, 0xd6, 0xe5, 0x4d, 320 | 0x5f, 0x5c, 0x73, 0xe3, 0x84, 0x44, 0xdd, 0x1c, 0x43, 0xb7, 0xa2, 0x8d, 0xa4, 0x71, 0x96, 0x29, 321 | 0xf4, 0xd8, 0x30, 0x1a, 0x20, 0x5a, 0xa1, 0x47, 0x3d, 0x24, 0x35, 0xa8, 0x5a, 0xbf, 0x01, 0x64, 322 | 0xcd, 0x45, 0x58, 0x92, 0x72, 0x4f, 0x5f, 0x09, 0xb6, 0x2a, 0x01, 0xaa, 0x98, 0xa4, 0x79, 0x5e, 323 | 0x8a, 0x33, 0x07, 0x34, 0x30, 0xc3, 0x40, 0x22, 0xab, 0xba, 0x43, 0x95, 0x48, 0xe1, 0x96, 0x81, 324 | 0xd3, 0x1e, 0xee, 0xe5, 0x18, 0x68, 0xba, 0x30, 0x7b, 0x8d, 0x4f, 0xb7, 0xd0, 0x1d, 0x5c, 0x68, 325 | 0x39, 0xd4, 0x5c, 0x5d, 0x92, 0xfd, 0x47, 0xb6, 0xef, 0xdd, 0xe4, 0x01, 0xfd, 0x26, 0xb8, 0xc9, 326 | 0xd1, 0x62, 0x73, 0x6c, 0x31, 0x60, 0x3c, 0x74, 0x1b, 0xc7, 0x64, 0xc1, 0x9d, 0xf3, 0x3a, 0xab, 327 | 0x87, 0xc1, 0x42, 0x77, 0x04, 0xce, 0x21, 0xf8, 0xc4, 0xfd, 0x36, 0xb7, 0x65, 0xb2, 0x95, 0x9b, 328 | 0x3e, 0x15, 0x41, 0x0b, 0x1e, 0x65, 0x41, 0xcf, 0x78, 0xbf, 0x9f, 0xd1, 0x23, 0x8e, 0xb8, 0xc5, 329 | 0x5a, 0xac, 0xd1, 0xbb, 0x56, 0x6c, 0xb7, 0x34, 0xbb, 0x07, 0x5b, 0x03, 0x99, 0xeb, 0x92, 0x71, 330 | 0xca, 0x51, 0xab, 0x97, 0x49, 0x2a, 0xe3, 0xbb, 0x6d, 0xa1, 0x84, 0x1c, 0x04, 0x84, 0xe6, 0x43, 331 | 0xb5, 0xbf, 0x0a, 0x16, 0xef, 0x9f, 0x13, 0xe0, 0x5e, 0x23, 0x72, 0x15, 0xdd, 0xb0, 0x42, 0x1c, 332 | 0x1f, 0xe2, 0xab, 0x90, 0x1b, 0x63, 0x85, 0x12, 0xf9, 0x9c, 0xbe, 0xe2, 0x70, 0xcb, 0x26, 0xef, 333 | 0xb7, 0x60, 0x46, 0x15, 0x37, 0x0e, 0x4a, 0x52, 0x70, 0xc4, 0x8d, 0x2d, 0xc3, 0xca, 0xc1, 0xfa, 334 | 0xf6, 0xed, 0x11, 0x87, 0x9e, 0x31, 0x30, 0x40, 0x6b, 0x55, 0x09, 0x5f, 0x6f, 0x57, 0xb1, 0xbc, 335 | 0x1f, 0x2f, 0xd6, 0xe5, 0xfd, 0x06, 0x7e, 0x60, 0xd2, 0x7e, 0x99, 0x97, 0x4b, 0x92, 0x75, 0x84, 336 | 0xa9, 0x10, 0x64, 0xc9, 0xc0, 0xe3, 0xef, 0x7e, 0xf5, 0x74, 0x4f, 0x6c, 0x85, 0x7d, 0x18, 0x44, 337 | 0x4c, 0x35, 0xcc, 0x7c, 0x52, 0x59, 0x87, 0x10, 0xec, 0x16, 0x03, 0x87, 0xcc, 0xa6, 0x89, 0x7d, 338 | 0x50, 0xca, 0xb3, 0x96, 0x52, 0xf0, 0x3c, 0x95, 0x43, 0x1e, 0x8a, 0x40, 0xd4, 0xec, 0x74, 0x0f, 339 | 0xee, 0x78, 0xca, 0xf9, 0x9a, 0x94, 0x04, 0x47, 0x51, 0xa2, 0xe0, 0xc4, 0x85, 0x1e, 0xef, 0x2e, 340 | 0x49, 0x42, 0x24, 0x7a, 0xbe, 0xd1, 0x6c, 0x52, 0x7d, 0x1c, 0x83, 0xab, 0xb1, 0x62, 0x31, 0x38, 341 | 0xef, 0x7e, 0x6a, 0xe5, 0xb2, 0x55, 0x2c, 0x3a, 0x51, 0xa5, 0xde, 0xf1, 0xa5, 0x13, 0x4c, 0xa0, 342 | 0x6c, 0xe9, 0x87, 0xa4, 0x9e, 0x0f, 0x8f, 0x50, 0xc0, 0x3c, 0xb9, 0x91, 0xd0, 0x83, 0xc5, 0x87, 343 | 0xcc, 0x8b, 0xf6, 0x90, 0x2e, 0x0c, 0x0a, 0xf5, 0x2e, 0x4f, 0x98, 0x9d, 0x17, 0x73, 0xed, 0xb1, 344 | 0x15, 0x0a, 0xc4, 0x84, 0x91, 0x5d, 0xd4, 0xd2, 0x01, 0x41, 0xcd, 0xb0, 0x92, 0x41, 0x8c, 0xf9, 345 | 0xdf, 0x75, 0x50, 0x8e, 0xd3, 0xf1, 0xe8, 0x5f, 0xc2, 0x3e, 0xfb, 0xb3, 0x1d, 0xda, 0xd8, 0xc9, 346 | 0x31, 0x6b, 0x43, 0x33, 0xd2, 0xd6, 0xe1, 0x9b, 0x1d, 0xf7, 0xf0, 0x27, 0x25, 0xae, 0x35, 0x76, 347 | 0x3d, 0xce, 0x74, 0x3c, 0xcf, 0xd8, 0x69, 0x80, 0x9f, 0xf7, 0x2f, 0x4d, 0xa1, 0xd2, 0x75, 0x19, 348 | 0xf4, 0x51, 0x4a, 0xd7, 0x76, 0x57, 0x07, 0x8c, 0xae, 0x17, 0xd6, 0xfa, 0x88, 0x22, 0xcb, 0x07, 349 | 0x9d, 0xa1, 0x38, 0x5e, 0xbc, 0xf6, 0x8b, 0xd7, 0xfb, 0xfe, 0x14, 0x20, 0x18, 0x97, 0xc3, 0x24, 350 | 0x12, 0x11, 0x95, 0xd0, 0x2d, 0x80, 0xa5, 0xda, 0x3b, 0x9f, 0xa3, 0x9a, 0x49, 0x9d, 0xc0, 0xc6, 351 | 0xdb, 0x09, 0x41, 0xc3, 0x73, 0x9d, 0x6b, 0xec, 0x12, 0xae, 0xd7, 0x1a, 0x0b, 0xf3, 0x5e, 0x08, 352 | 0x67, 0xa8, 0xf8, 0xf1, 0x24, 0xc4, 0xce, 0x44, 0xc0, 0x00, 0x54, 0x63, 0x9b, 0x45, 0xfb, 0xc4, 353 | 0x5d, 0xec, 0xfa, 0x38, 0xd0, 0xa4, 0x57, 0xdb, 0x42, 0x78, 0x35, 0x4f, 0x77, 0x7d, 0x49, 0x27, 354 | 0x6e, 0xf5, 0x58, 0xf1, 0x7a, 0x52, 0xd1, 0x0a, 0xc6, 0x9a, 0xe4, 0x62, 0x05, 0x18, 0x81, 0x44, 355 | 0x5e, 0x1f, 0x84, 0xb3, 0xe8, 0xa2, 0x81, 0xd1, 0xeb, 0xe0, 0x7f, 0xc7, 0x9b, 0x02, 0xea, 0x24, 356 | 0x75, 0xac, 0x8e, 0x25, 0xd7, 0xa4, 0xae, 0xb0, 0x95, 0x38, 0xe1, 0x4a, 0xaa, 0x32, 0x8a, 0x5c, 357 | 0x29, 0x4a, 0xe7, 0xe9, 0xd6, 0x9e, 0xe3, 0x9b, 0x89, 0xd9, 0x2a, 0x6c, 0x79, 0x95, 0xdd, 0xde, 358 | 0xda, 0xfe, 0xd5, 0xbf, 0x32, 0xe5, 0xe9, 0xc5, 0x9f, 0x6e, 0xe1, 0x6b, 0x26, 0x42, 0x56, 0xf2, 359 | 0xa9, 0x80, 0xc7, 0x1d, 0x86, 0xbb, 0x54, 0x64, 0xc5, 0x8e, 0xde, 0xd8, 0x60, 0x47, 0x71, 0x19, 360 | 0xf9, 0xe2, 0xb9, 0x38, 0xa9, 0xde, 0x1d, 0xd4, 0xda, 0x12, 0x51, 0x34, 0x2d, 0x46, 0x4e, 0x64, 361 | 0x7e, 0x4e, 0x68, 0x53, 0x85, 0x06, 0x8b, 0xf4, 0x54, 0x14, 0xed, 0x47, 0x39, 0xa0, 0xc1, 0x91, 362 | 0xf5, 0x6e, 0x23, 0x4b, 0x40, 0x36, 0xf9, 0xcc, 0xd4, 0x53, 0x42, 0xea, 0xf6, 0xeb, 0x3e, 0x16, 363 | 0x71, 0x8c, 0xe4, 0xfd, 0xd5, 0x09, 0x16, 0xfb, 0xfa, 0xf0, 0x88, 0xb3, 0xd5, 0xac, 0xcc, 0xeb, 364 | 0x92, 0xcd, 0xbc, 0x47, 0x55, 0x17, 0xeb, 0xae, 0xf7, 0x66, 0x32, 0xc4, 0xae, 0x56, 0x0a, 0xd3, 365 | 0x77, 0x9f, 0x0b, 0x7b, 0x2f, 0x93, 0x0d, 0x4f, 0xf1, 0xbe, 0xfd, 0x78, 0xeb, 0x99, 0x5c, 0x7a, 366 | 0xcf, 0xf7, 0x4c, 0xe0, 0x21, 0x91, 0x02, 0x98, 0xf8, 0x55, 0xa4, 0x77, 0x0f, 0x64, 0x53, 0x23, 367 | 0xa2, 0x2d, 0xce, 0xa4, 0xe8, 0x38, 0x36, 0xb4, 0x14, 0x01, 0xa9, 0x18, 0xe4, 0x36, 0x8f, 0x7a, 368 | 0x10, 0x99, 0x17, 0xf9, 0x9c, 0xbe, 0x9c, 0x2e, 0xb2, 0xc5, 0xa6, 0xf9, 0xea, 0x57, 0xd8, 0x30, 369 | 0x68, 0x85, 0x4d, 0xe2, 0xf5, 0x8f, 0xe4, 0xe4, 0x97, 0x3a, 0x12, 0xd1, 0x0e, 0x89, 0x81, 0xd5, 370 | 0x49, 0x47, 0x79, 0x84, 0xa0, 0x82, 0x91, 0xd5, 0x75, 0xa4, 0xe7, 0x14, 0xff, 0x03, 0x9b, 0x1c, 371 | 0x78, 0x0b, 0xd7, 0x9d, 0xf7, 0x55, 0x97, 0xc1, 0x93, 0xba, 0x45, 0x83, 0x54, 0x92, 0xf0, 0x53, 372 | 0xfb, 0x7f, 0x6a, 0x4b, 0xda, 0xfa, 0x2a, 0x4c, 0x34, 0x35, 0x87, 0xb0, 0x0f, 0x7f, 0x39, 0xdd, 373 | 0x36, 0xe2, 0x90, 0x2e, 0x28, 0xac, 0xa8, 0xff, 0x6c, 0x48, 0x3e, 0x60, 0x12, 0x08, 0xf6, 0x89, 374 | 0x53, 0xc8, 0x50, 0xd0, 0x92, 0x88, 0x30, 0xaf, 0x78, 0x29, 0x36, 0x7d, 0xb0, 0x1c, 0x87, 0x5e, 375 | 0xf1, 0xc9, 0x76, 0x0c, 0xbb, 0x5b, 0xef, 0xed, 0x3a, 0xff, 0xb2, 0x32, 0xcc, 0x06, 0xf1, 0xc0, 376 | 0x02, 0x05, 0x18, 0x43, 0x0c, 0x56, 0x22, 0x3d, 0x0f, 0x6d, 0x3e, 0xe9, 0x96, 0x71, 0x05, 0x95, 377 | 0xbf, 0x2c, 0xe9, 0x85, 0x08, 0x8e, 0xda, 0x4e, 0xdc, 0x9d, 0xd7, 0xe3, 0x14, 0xa1, 0x47, 0xe3, 378 | 0x15, 0x1d, 0xc3, 0x68, 0x7d, 0x8d, 0x12, 0xac, 0xfd, 0x60, 0x54, 0x49, 0x5e, 0xbd, 0xb5, 0x46, 379 | 0x6b, 0xec, 0x11, 0xa6, 0x57, 0x85, 0x53, 0xa5, 0xad, 0x08, 0xd8, 0x14, 0x01, 0xfa, 0x7b, 0xfd, 380 | 0x4c, 0x44, 0xf0, 0xd3, 0xe5, 0x85, 0x9e, 0x9d, 0x60, 0x8f, 0xf1, 0xd2, 0xb1, 0xe6, 0x39, 0x90, 381 | 0x2c, 0x6e, 0xa3, 0xd2, 0x40, 0x98, 0x0e, 0x26, 0x99, 0xb8, 0xbf, 0x0b, 0xa9, 0xde, 0xf5, 0x3f, 382 | 0xce, 0x70, 0x0c, 0x3b, 0xef, 0xfe, 0x73, 0xc1, 0x49, 0x3e, 0x70, 0x2d, 0xd2, 0xe7, 0xb1, 0xc3, 383 | 0x86, 0xb0, 0xac, 0x2f, 0xad, 0x8c, 0xac, 0xe6, 0x3d, 0xde, 0xa3, 0x99, 0x75, 0x98, 0x2b, 0x3e, 384 | 0x94, 0x00, 0x30, 0x9e, 0xa3, 0x98, 0x14, 0x8d, 0xa6, 0xe7, 0x82, 0x19, 0x6b, 0x11, 0x95, 0xf1, 385 | 0xe5, 0xa3, 0xae, 0x38, 0x3f, 0x8c, 0xc9, 0xe0, 0x67, 0x6d, 0x3b, 0x21, 0x84, 0x13, 0xaf, 0x5a, 386 | 0x70, 0x1d, 0x8a, 0x0b, 0x71, 0x5e, 0xd3, 0x92, 0xa8, 0x0b, 0x12, 0x59, 0x84, 0x1b, 0xbe, 0xa4, 387 | 0xd2, 0x2b, 0xc5, 0xd7, 0x6c, 0xcf, 0x37, 0xe0, 0xba, 0x74, 0x1d, 0x10, 0x04, 0x83, 0xdf, 0x5e, 388 | 0x08, 0x58, 0x31, 0x81, 0xef, 0x13, 0x4b, 0x25, 0xfb, 0xd5, 0xc8, 0xd7, 0xf7, 0x9d, 0xe9, 0x80, 389 | 0xcd, 0xf6, 0x35, 0x26, 0x1f, 0x61, 0x1c, 0x29, 0xfa, 0x84, 0x5a, 0x97, 0x91, 0xa8, 0x1a, 0xb7, 390 | 0xef, 0xd1, 0xae, 0xe6, 0xd6, 0xf3, 0x9f, 0x4f, 0x7d, 0xdb, 0x31, 0xe2, 0xb6, 0x15, 0x94, 0x1c, 391 | 0x19, 0x24, 0x32, 0x01, 0xc5, 0x18, 0x8c, 0x04, 0xa8, 0x85, 0x18, 0xcb, 0xac, 0x8f, 0xff, 0x83, 392 | 0x75, 0xe1, 0x88, 0x11, 0xc4, 0x69, 0x34, 0xd1, 0xaa, 0x98, 0xf1, 0x77, 0xf1, 0x49, 0x92, 0x67, 393 | 0xa9, 0x53, 0x08, 0xd6, 0x1e, 0x8c, 0xf0, 0xa9, 0x59, 0x37, 0x0d, 0xaf, 0xb9, 0x8c, 0x8e, 0x84, 394 | 0x77, 0x12, 0x81, 0x01, 0x4d, 0x08, 0xdb, 0xd0, 0xcf, 0x79, 0x50, 0x89, 0x19, 0x76, 0x0f, 0x8e, 395 | 0x4d, 0x87, 0x45, 0xd6, 0x7d, 0x12, 0xf8, 0xda, 0xe5, 0x34, 0xb5, 0xbd, 0x9a, 0xf2, 0x1d, 0x47, 396 | 0xe8, 0x38, 0x02, 0x4a, 0x77, 0xfa, 0x5d, 0xf1, 0x88, 0x1a, 0xd7, 0xfe, 0x91, 0x8d, 0x89, 0x94, 397 | 0x3d, 0x7b, 0x3d, 0x5e, 0xa6, 0x71, 0xea, 0x61, 0x80, 0x11, 0xff, 0x63, 0x16, 0xee, 0x1d, 0xab, 398 | 0x4b, 0xc2, 0xec, 0xe0, 0x4c, 0x64, 0xf2, 0xc2, 0x7c, 0x5b, 0xe1, 0x99, 0x71, 0x1d, 0xb8, 0xcb, 399 | 0x5e, 0x4f, 0x7e, 0x02, 0xdf, 0xbf, 0x37, 0x73, 0xbf, 0xd4, 0x07, 0x5d, 0xa6, 0xb9, 0x17, 0x04, 400 | 0x85, 0x2d, 0x71, 0x7b, 0xf8, 0x51, 0xb4, 0x13, 0xf2, 0x66, 0x22, 0x98, 0xb6, 0xcd, 0x5d, 0x06, 401 | 0x27, 0xb4, 0xe5, 0x42, 0x4a, 0xa0, 0x5d, 0x9c, 0xc1, 0x12, 0xfc, 0x29, 0x20, 0x73, 0x57, 0xa7, 402 | 0xab, 0x29, 0xeb, 0x73, 0x83, 0x8d, 0xf8, 0xcd, 0x49, 0x55, 0xfb, 0x02, 0xc1, 0x27, 0x3f, 0xc8, 403 | 0x0b, 0x0f, 0xd4, 0x56, 0x50, 0x59, 0x0a, 0x3f, 0xfe, 0x09, 0x1d, 0xa0, 0x4e, 0xbd, 0xfd, 0x34, 404 | 0x14, 0x61, 0x7f, 0x6c, 0xf0, 0x74, 0x7f, 0x97, 0x6d, 0x3d, 0x31, 0xdc, 0xb7, 0xf7, 0x15, 0xae, 405 | 0x62, 0xae, 0xf2, 0x6a, 0xc9, 0x6d, 0x04, 0x0b, 0x92, 0xb9, 0x82, 0xf3, 0xd8, 0x8a, 0xd5, 0x18, 406 | 0xa6, 0x99, 0x41, 0x03, 0x35, 0xb8, 0xd6, 0x4f, 0xc2, 0x48, 0x7a, 0xa4, 0x3f, 0x6e, 0x1d, 0x25, 407 | 0x65, 0x73, 0x00, 0x70, 0x14, 0xbe, 0x4d, 0xd9, 0xd1, 0x0d, 0x2a, 0xea, 0xd7, 0x19, 0xd3, 0xfe, 408 | 0xfa, 0x72, 0x8e, 0x78, 0xeb, 0x71, 0xb9, 0x80, 0x26, 0xd4, 0x4a, 0x74, 0x94, 0x6c, 0x04, 0x91, 409 | 0x97, 0x42, 0x08, 0x51, 0x82, 0xbd, 0xdd, 0x0a, 0xe5, 0xb6, 0x6c, 0x49, 0x7c, 0x77, 0x5e, 0xae, 410 | 0x1d, 0x46, 0x64, 0x7e, 0xa2, 0xfa, 0x86, 0xa7, 0x1b, 0x2b, 0x76, 0x7e, 0x26, 0xb3, 0x49, 0x3e, 411 | 0xca, 0x8d, 0x06, 0x5b, 0x8c, 0x39, 0x8a, 0x7e, 0xa4, 0xf8, 0xb1, 0x77, 0x12, 0xa0, 0x81, 0xb3, 412 | 0xe5, 0x60, 0x93, 0x9f, 0x56, 0x3f, 0xaf, 0x67, 0x7a, 0xfd, 0x93, 0xfc, 0x2c, 0x04, 0x01, 0x54, 413 | 0x1f, 0x76, 0x16, 0x78, 0xfc, 0x82, 0x27, 0xc5, 0x7a, 0x94, 0x2a, 0x2d, 0xf8, 0xa6, 0x11, 0x8f, 414 | 0x2e, 0xe4, 0xa4, 0xca, 0x0c, 0x4b, 0x3c, 0x6a, 0xeb, 0xe5, 0xe7, 0xb4, 0x9b, 0xb0, 0xb6, 0xd0, 415 | 0x45, 0xd1, 0xa6, 0xf0, 0x55, 0xf2, 0x63, 0xb2, 0x35, 0xe6, 0xc5, 0xad, 0x2d, 0xdc, 0x5a, 0xb0, 416 | 0x1d, 0x05, 0x5a, 0xec, 0xea, 0x1d, 0x54, 0xa4, 0xbe, 0xd2, 0xa6, 0xd0, 0x47, 0x27, 0x87, 0xec, 417 | 0xa7, 0x72, 0xfe, 0x98, 0xc6, 0xd7, 0x7e, 0x4e, 0x20, 0xb2, 0x68, 0x92, 0x98, 0xc2, 0xa1, 0x3c, 418 | 0xae, 0x3f, 0x8e, 0x15, 0x97, 0x40, 0x38, 0x65, 0x8d, 0xd6, 0x13, 0x8b, 0xca, 0xa6, 0x9f, 0xe2, 419 | 0xfd, 0xee, 0x6b, 0xba, 0xfd, 0x65, 0xb6, 0xa9, 0x72, 0x65, 0x64, 0xc5, 0xb8, 0x69, 0x1c, 0x0e, 420 | 0xc9, 0x8d, 0xfb, 0x8d, 0x21, 0x2c, 0x02, 0xec, 0x86, 0xe5, 0x91, 0x3f, 0x83, 0x87, 0xf2, 0x6f, 421 | 0x61, 0x9e, 0x41, 0x79, 0x17, 0x03, 0xd7, 0xeb, 0x76, 0x9d, 0xd2, 0x94, 0xe8, 0xdf, 0x0b, 0x26, 422 | 0x1f, 0xea, 0x88, 0xed, 0x82, 0x65, 0xb5, 0x33, 0xbf, 0xbf, 0x3b, 0x1d, 0x10, 0x01, 0xc4, 0x60, 423 | 0x88, 0x80, 0x9d, 0xcf, 0x17, 0x0b, 0xec, 0x93, 0x1f, 0x80, 0xe5, 0x7b, 0x19, 0x3d, 0x5d, 0xe9, 424 | 0x9e, 0x48, 0x5e, 0x9f, 0xcf, 0xa1, 0x9f, 0x0a, 0xbd, 0x0e, 0xad, 0xe6, 0x5e, 0x3b, 0x18, 0xd0, 425 | 0xef, 0x73, 0x21, 0x9c, 0xe7, 0x6c, 0x60, 0xee, 0x0b, 0x1f, 0xa9, 0xf4, 0x63, 0x6b, 0x6a, 0x15, 426 | 0xe9, 0x0c, 0xbd, 0x66, 0xd0, 0x94, 0xc6, 0x06, 0x1d, 0xe1, 0x39, 0x71, 0x88, 0x70, 0x2c, 0xd9, 427 | 0x2e, 0x40, 0x1d, 0xd8, 0x6f, 0x49, 0xaa, 0x77, 0x4f, 0x3f, 0xfe, 0x98, 0xb2, 0xab, 0x5a, 0xd2, 428 | 0x47, 0x47, 0xf0, 0x75, 0x22, 0xe7, 0xb0, 0x22, 0x8e, 0xd5, 0x6f, 0x3d, 0xd1, 0x25, 0x1c, 0x73, 429 | 0x57, 0x29, 0x6c, 0x92, 0x27, 0x5c, 0xe0, 0xb9, 0x7d, 0xc6, 0xb9, 0xb1, 0x0e, 0xa9, 0x08, 0x7e, 430 | 0x83, 0x57, 0xc2, 0x5e, 0x71, 0xda, 0xf4, 0x70, 0x35, 0x3d, 0x8b, 0xbc, 0x1a, 0x3b, 0x6e, 0x0a, 431 | 0xe5, 0x26, 0x98, 0xb9, 0xa0, 0x24, 0x27, 0x31, 0xd4, 0xc2, 0x80, 0x5c, 0xef, 0x45, 0xc0, 0x2a, 432 | 0x97, 0x8d, 0x27, 0x64, 0xcf, 0x96, 0x72, 0x72, 0xfb, 0x64, 0x7e, 0x45, 0x9a, 0x5d, 0x84, 0x18, 433 | 0x09, 0x79, 0xaf, 0x5a, 0xd7, 0x87, 0x62, 0x18, 0x8a, 0xaa, 0x5b, 0xb7, 0x72, 0x24, 0x5f, 0x6c, 434 | 0x32, 0x26, 0xb5, 0xe5, 0x5c, 0xf8, 0xe9, 0xc0, 0xce, 0x55, 0x0a, 0xa8, 0x61, 0xa6, 0x82, 0xd2, 435 | 0x65, 0xe5, 0x7f, 0x80, 0x0a, 0x33, 0x4a, 0x04, 0xd3, 0x6e, 0xfc, 0x47, 0x87, 0x7d, 0x5e, 0x3d, 436 | 0x07, 0x90, 0x2f, 0xbb, 0xc7, 0xdc, 0x2a, 0x8a, 0xfe, 0xd3, 0x83, 0x1e, 0xd3, 0xbe, 0x67, 0x2a, 437 | 0xd4, 0x40, 0x22, 0x6e, 0x2d, 0x19, 0x1f, 0x21, 0xa8, 0xbb, 0x7e, 0x23, 0x84, 0x8c, 0x16, 0xe8, 438 | 0x37, 0x48, 0xb8, 0xbf, 0x10, 0xc1, 0x14, 0xb0, 0x5f, 0xc0, 0xb4, 0x63, 0xe6, 0x65, 0xbd, 0x29, 439 | 0xbb, 0x6b, 0x31, 0x8f, 0x99, 0xbe, 0xce, 0x7a, 0xde, 0x06, 0x0a, 0x37, 0xac, 0x31, 0x36, 0xb6, 440 | 0x00, 0x19, 0xb6, 0x8d, 0xdc, 0xfd, 0x17, 0x80, 0x3d, 0xdb, 0x5e, 0x60, 0x3b, 0x1e, 0x0b, 0x8b, 441 | 0x84, 0xbd, 0x87, 0xbb, 0x42, 0xe0, 0xbc, 0xef, 0x15, 0xe2, 0x90, 0xba, 0x85, 0x40, 0x92, 0x54, 442 | 0x89, 0xb2, 0x8b, 0x5d, 0x73, 0x44, 0x50, 0x03, 0x0a, 0xdf, 0xbd, 0x28, 0x55, 0x7d, 0x80, 0x30, 443 | 0x1b, 0xb2, 0x29, 0x7c, 0xd5, 0x5a, 0x89, 0x77, 0x45, 0xbf, 0x70, 0xe7, 0x0b, 0x65, 0x08, 0x02, 444 | 0xf5, 0xcb, 0xd9, 0x47, 0xb4, 0x9d, 0x55, 0xde, 0x46, 0x35, 0x8d, 0x52, 0x7e, 0x1d, 0xee, 0x77, 445 | 0x57, 0x59, 0x49, 0x2d, 0xd8, 0x89, 0x0a, 0x0f, 0x61, 0x27, 0x55, 0x21, 0xac, 0x60, 0xb5, 0xa1, 446 | 0xaa, 0xeb, 0x65, 0xea, 0x0c, 0x0a, 0x48, 0xcd, 0xe0, 0x29, 0x3f, 0x9d, 0x2f, 0xd5, 0x89, 0xeb, 447 | 0x37, 0x60, 0x9b, 0xd4, 0x7e, 0xce, 0x2b, 0x3c, 0xaa, 0x61, 0x0c, 0xde, 0xcb, 0x33, 0x4e, 0x55, 448 | 0x44, 0x9a, 0xd4, 0x5f, 0x6f, 0x35, 0x92, 0xe0, 0x58, 0x2d, 0xf8, 0x4c, 0x20, 0x22, 0xf3, 0x14, 449 | 0x71, 0xda, 0xa6, 0x80, 0x3d, 0x0c, 0x4d, 0x48, 0xc7, 0x1a, 0xe9, 0xa9, 0xd3, 0x38, 0xa8, 0x3b, 450 | 0xc5, 0x77, 0xb7, 0x46, 0x02, 0xd4, 0xf6, 0xb1, 0x7a, 0x55, 0x49, 0x9b, 0x3b, 0x46, 0x2e, 0x9f, 451 | 0xa6, 0x89, 0x24, 0x0d, 0x30, 0xc0, 0x64, 0x4c, 0xaf, 0x61, 0x12, 0x24, 0xdb, 0x7a, 0xf4, 0x00, 452 | 0x62, 0x59, 0x41, 0xa9, 0x44, 0x87, 0x9e, 0x8d, 0xc5, 0x7b, 0xe2, 0x30, 0x94, 0x37, 0xc0, 0xa3, 453 | 0xeb, 0x1f, 0xc8, 0xc8, 0xb9, 0x0d, 0xb2, 0x35, 0xe3, 0x52, 0x99, 0x5d, 0x2c, 0xa0, 0xe7, 0x47, 454 | 0x69, 0xab, 0x66, 0xa1, 0x75, 0x2d, 0x73, 0x50, 0x91, 0x5b, 0xf3, 0xa5, 0x2e, 0x7a, 0xfd, 0xcc, 455 | 0x48, 0x02, 0x0d, 0xaa, 0xbf, 0x40, 0x8c, 0x1f, 0xfb, 0xe9, 0x50, 0x82, 0x48, 0x61, 0xb8, 0x8d, 456 | 0x53, 0xd8, 0xf0, 0x2a, 0x29, 0x08, 0xd8, 0x4e, 0xea, 0x32, 0xb4, 0x5a, 0xd4, 0x15, 0xb1, 0x93, 457 | 0xc9, 0x9e, 0x90, 0x96, 0x1e, 0xc0, 0x57, 0xe8, 0x23, 0xfd, 0x12, 0x7e, 0x9e, 0x33, 0xe1, 0xf5, 458 | 0x55, 0x0e, 0x5b, 0xb8, 0x8d, 0x71, 0x15, 0xaf, 0xf7, 0x7f, 0x44, 0x11, 0xe2, 0xe9, 0xca, 0x4b, 459 | 0xd8, 0xed, 0xe1, 0xa3, 0xe9, 0xd2, 0xec, 0x0d, 0xfe, 0xc5, 0x79, 0xce, 0xde, 0x3c, 0xde, 0xc0, 460 | 0xf9, 0xa4, 0x1f, 0xa4, 0xaf, 0x23, 0x46, 0x72, 0x98, 0xa9, 0xfa, 0xc7, 0xb5, 0xc5, 0xd9, 0x39, 461 | 0xc7, 0x9a, 0x12, 0xb5, 0xe6, 0x07, 0x99, 0x36, 0xfc, 0x88, 0xee, 0xc6, 0x04, 0xca, 0x72, 0xed, 462 | 0x7d, 0x8a, 0x87, 0x95, 0xa7, 0x32, 0x54, 0x48, 0x3a, 0x5e, 0x0e, 0xfb, 0xcb, 0x78, 0x1c, 0x1e, 463 | 0x36, 0x5e, 0xa1, 0x04, 0x0b, 0x99, 0x75, 0x5d, 0xf2, 0x0f, 0xa8, 0xa9, 0xc8, 0x7f, 0xa4, 0x7e, 464 | 0xc7, 0x06, 0x8d, 0xa6, 0x69, 0x66, 0x50, 0x28, 0x64, 0xb9, 0xcd, 0x62, 0x7e, 0xae, 0xab, 0x84, 465 | 0x67, 0x6d, 0xf5, 0x84, 0x5b, 0x03, 0xae, 0xae, 0x36, 0x63, 0xed, 0x98, 0x99, 0x28, 0x3e, 0xaf, 466 | 0x48, 0x97, 0x3d, 0x72, 0xff, 0xbc, 0x89, 0xfd, 0xbd, 0xcb, 0x45, 0x5f, 0x24, 0x2a, 0x74, 0x43, 467 | 0xd4, 0x19, 0x70, 0x6a, 0xa3, 0xaa, 0x5c, 0x4a, 0x0a, 0x06, 0x6a, 0xf3, 0xe7, 0x20, 0xfe, 0xcb, 468 | 0x2a, 0x05, 0x28, 0xf0, 0x5b, 0x77, 0xa3, 0xde, 0x92, 0xf8, 0x80, 0x80, 0xa0, 0x2f, 0x9f, 0x55, 469 | 0xa9, 0xe6, 0x8e, 0x91, 0x16, 0x09, 0x84, 0x9b, 0x15, 0x2d, 0xa0, 0x39, 0xbf, 0xab, 0xbd, 0x54, 470 | 0x2c, 0x7e, 0x9b, 0x82, 0xff, 0x1e, 0xd9, 0x4c, 0xda, 0xcb, 0x8d, 0xff, 0x1f, 0x65, 0xa4, 0x93, 471 | 0x1c, 0x7a, 0x0b, 0xba, 0xe9, 0xe6, 0x13, 0xc2, 0x87, 0x97, 0xa3, 0xfa, 0x07, 0x7b, 0x0d, 0x52, 472 | 0xb3, 0x82, 0xbe, 0x0a, 0x4b, 0x0f, 0x78, 0x53, 0x0e, 0x56, 0xc6, 0x50, 0x35, 0x41, 0x28, 0xbb, 473 | 0x1d, 0x5b, 0x76, 0xac, 0xf7, 0xa9, 0x08, 0xf7, 0xdd, 0x77, 0x91, 0x14, 0x6b, 0x28, 0xa5, 0x39, 474 | 0x56, 0xb0, 0x1b, 0x6c, 0x8e, 0xf7, 0xf8, 0x3a, 0xc9, 0x9a, 0x6c, 0xe9, 0xba, 0x73, 0x04, 0xcf, 475 | 0x82, 0x2f, 0x62, 0x41, 0xe6, 0x05, 0xd1, 0xca, 0x2a, 0x7c, 0x6f, 0x4e, 0x6e, 0xd5, 0x5e, 0x12, 476 | 0xc2, 0xe1, 0x88, 0xa1, 0x01, 0xf7, 0xda, 0xd5, 0xf3, 0xeb, 0x6f, 0xff, 0x78, 0xc4, 0x19, 0x6e, 477 | 0xfa, 0xa2, 0xc7, 0x10, 0xd3, 0xd9, 0x0e, 0xc6, 0x30, 0xca, 0x88, 0x48, 0x8d, 0xce, 0xed, 0x15, 478 | 0x86, 0xf4, 0x85, 0x55, 0xdc, 0x84, 0x2b, 0x79, 0xad, 0x4c, 0xdb, 0x67, 0x23, 0x5f, 0xd1, 0xab, 479 | 0x90, 0xd7, 0x47, 0x22, 0x13, 0x83, 0xaf, 0xaf, 0xdf, 0xda, 0x6a, 0x69, 0x6b, 0x4f, 0xa6, 0x38, 480 | 0x4d, 0x18, 0x93, 0x19, 0x5c, 0x49, 0xe4, 0x1f, 0x34, 0xc8, 0xc0, 0x45, 0xb0, 0x64, 0x46, 0xa7, 481 | 0xd6, 0x22, 0xbd, 0x2f, 0xf6, 0xc8, 0x10, 0x7e, 0xb0, 0xdf, 0x03, 0x9a, 0x19, 0x51, 0xbc, 0xcc, 482 | 0x77, 0x81, 0x15, 0x23, 0xd1, 0x74, 0x4c, 0x81, 0xae, 0xe5, 0xb3, 0x15, 0xcc, 0x99, 0xf4, 0x78, 483 | 0x50, 0xc3, 0x9c, 0x59, 0x18, 0x14, 0x64, 0x5e, 0x88, 0x4e, 0x71, 0x88, 0xd7, 0xbb, 0x88, 0xd2, 484 | 0x8c, 0x82, 0x79, 0xfd, 0x1b, 0xb6, 0x96, 0x81, 0xd8, 0xf3, 0xbb, 0x02, 0xe3, 0xf1, 0xe4, 0x43, 485 | 0x5a, 0x62, 0xb4, 0xc7, 0x44, 0xda, 0xa0, 0x13, 0x20, 0xdb, 0x09, 0x67, 0x9b, 0x7e, 0x93, 0x79, 486 | 0x3f, 0x02, 0x22, 0xe9, 0x45, 0xdd, 0x49, 0xf6, 0x11, 0x08, 0x4d, 0x6f, 0x97, 0xc4, 0x39, 0xb9, 487 | 0xc7, 0xa6, 0x8b, 0x18, 0xae, 0x76, 0x4c, 0x11, 0xc8, 0x7b, 0xe3, 0x50, 0x16, 0xf3, 0xf8, 0x48, 488 | 0x1f, 0xc6, 0xf8, 0x0e, 0x8e, 0x36, 0x05, 0xec, 0x11, 0x5e, 0xf4, 0x12, 0x43, 0x09, 0x08, 0x3c, 489 | 0x43, 0x93, 0x74, 0xf5, 0xb7, 0xf3, 0x8a, 0x2c, 0x8c, 0x9c, 0x4e, 0x64, 0xdb, 0xa5, 0x13, 0xbc, 490 | 0xed, 0x87, 0x94, 0xf6, 0x3a, 0x39, 0x41, 0x9f, 0x9e, 0x64, 0xce, 0x85, 0x19, 0xc8, 0x22, 0x61, 491 | 0x54, 0xa7, 0xae, 0xbf, 0x7e, 0xd2, 0xef, 0x30, 0x3e, 0x08, 0xef, 0xba, 0xa2, 0xd9, 0xc2, 0x09, 492 | 0x5c, 0xb0, 0x50, 0x41, 0xc2, 0xa2, 0x01, 0x3f, 0x02, 0x46, 0x2e, 0x8e, 0xe9, 0x7f, 0xc1, 0x0f, 493 | 0x91, 0xf9, 0x3d, 0x19, 0x09, 0xb1, 0x2b, 0x3b, 0x91, 0x0c, 0x3d, 0x92, 0x2d, 0x68, 0xa3, 0x46, 494 | 0x7d, 0x64, 0x84, 0x47, 0x00, 0x8e, 0x40, 0x0d, 0x7d, 0xf8, 0x2e, 0x1d, 0xff, 0xe8, 0x60, 0x66, 495 | 0xda, 0x57, 0x0a, 0xc8, 0x7e, 0x27, 0x7e, 0x12, 0xb2, 0x23, 0x54, 0xf4, 0x17, 0x1b, 0xe4, 0xa9, 496 | 0xd0, 0x3c, 0x07, 0x63, 0xc3, 0x5c, 0xe3, 0xfb, 0xda, 0x73, 0xd0, 0x2b, 0x6f, 0x28, 0x96, 0xee, 497 | 0x68, 0xfb, 0xee, 0xa5, 0xcc, 0x54, 0x87, 0xde, 0x6a, 0x65, 0x5c, 0xfa, 0xcb, 0x0f, 0xbc, 0x11, 498 | 0x74, 0x34, 0x21, 0xc9, 0x37, 0x45, 0x73, 0xf1, 0xae, 0x2b, 0xf4, 0x5e, 0xb8, 0x05, 0x83, 0x9b, 499 | 0x0d, 0x7b, 0xb4, 0x79, 0xcd, 0x74, 0x65, 0x54, 0xb9, 0x9e, 0x37, 0x36, 0x7f, 0xb4, 0x72, 0x52, 500 | 0x73, 0xeb, 0xa9, 0xb2, 0xff, 0xbd, 0x2f, 0xfc, 0x28, 0x86, 0x5c, 0x26, 0x6f, 0xba, 0xd2, 0x64, 501 | 0x60, 0xcc, 0xc1, 0x56, 0x60, 0xf0, 0xf9, 0x02, 0xaf, 0xa7, 0x69, 0x3f, 0xda, 0xfd, 0xcf, 0xf1, 502 | 0x5e, 0x7b, 0xef, 0x47, 0x2d, 0xe5, 0x2b, 0x74, 0xb9, 0x9e, 0x0f, 0xa6, 0x8b, 0x8b, 0x06, 0x1e, 503 | 0xe5, 0x70, 0xf3, 0x43, 0x6e, 0xb5, 0x0a, 0xa3, 0x4e, 0x50, 0x04, 0x3a, 0x94, 0xd1, 0x34, 0x94, 504 | 0x7f, 0x3e, 0x71, 0x1e, 0x60, 0xd4, 0x04, 0x21, 0xbc, 0xa1, 0x26, 0x15, 0xe1, 0x85, 0x00, 0x5a, 505 | 0x95, 0x04, 0x79, 0x6f, 0xc4, 0xdd, 0x56, 0x13, 0xfe, 0xf8, 0x7f, 0xc8, 0x41, 0xb2, 0x7c, 0x3a, 506 | 0xd2, 0x3c, 0xec, 0xf4, 0xf7, 0x27, 0xd3, 0xf4, 0xc8, 0xef, 0xae, 0x38, 0xaf, 0x0a, 0x2b, 0x98, 507 | 0xfb, 0x81, 0x11, 0x24, 0x63, 0x6e, 0xde, 0xe7, 0xac, 0x32, 0xe7, 0x84, 0x00, 0x98, 0xa1, 0xdc, 508 | 0xd1, 0x88, 0xa6, 0x70, 0xed, 0xcd, 0x91, 0xff, 0xd9, 0x07, 0x40, 0x82, 0x7b, 0xf6, 0x05, 0x51, 509 | 0x42, 0x22, 0x15, 0x89, 0xca, 0xbc, 0x4e, 0x9b, 0x4f, 0x58, 0xc9, 0x79, 0x4f, 0xcf, 0xc0, 0xad, 510 | 0xae, 0x4b, 0x56, 0x0a, 0xd1, 0x3d, 0x99, 0xf1, 0x7d, 0x3a, 0x3e, 0x6b, 0x12, 0xc5, 0xf9, 0xa1, 511 | 0xe4, 0x1a, 0xda, 0x52, 0x49, 0x64, 0x1b, 0x19, 0xca, 0xf9, 0xd4, 0x16, 0xe8, 0x91, 0x7f, 0xe0, 512 | 0x7d, 0xbd, 0xe7, 0x48, 0xe2, 0x7a, 0x94, 0x2d, 0x1b, 0x5e, 0xec, 0xd2, 0xa7, 0x2e, 0xd5, 0x9f, 513 | 0x3e, 0x73, 0xbe, 0x9f, 0x8e, 0xa4, 0x93, 0x46, 0x07, 0x2b, 0x2d, 0x8f, 0xe3, 0x15, 0xa7, 0x66, 514 | 0x5e, 0xb4, 0x0a, 0xa6, 0x20, 0x1e, 0x27, 0x2a, 0xf8, 0x84, 0x41, 0x5a, 0xea, 0x49, 0x3a, 0xc5, 515 | }; 516 | --------------------------------------------------------------------------------