← Back to branch summary

~vadim-tk/percona-server/percona-galera-5.1.57

« back to all changes in this revision

Viewing changes to extra/yassl/taocrypt/src/aes.cpp

  • Committer: root
  • Date: 2011-07-10 16:09:24 UTC
  • Revision ID: root@r815.office.percona.com-20110710160924-fyffqsbaclgu6vui
Initial port

Show diffs side-by-side

added added

removed removed

Lines of Context:
extra/yassl/taocrypt/src/aes.cpp
 
1
/*
 
2
   Copyright (C) 2000-2007 MySQL AB
 
3
 
 
4
   This program is free software; you can redistribute it and/or modify
 
5
   it under the terms of the GNU General Public License as published by
 
6
   the Free Software Foundation; version 2 of the License.
 
7
 
 
8
   This program is distributed in the hope that it will be useful,
 
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
   GNU General Public License for more details.
 
12
 
 
13
   You should have received a copy of the GNU General Public License
 
14
   along with this program; see the file COPYING. If not, write to the
 
15
   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
 
16
   MA  02110-1301  USA.
 
17
*/
 
18
 
 
19
/* C++ based on Wei Dai's aes.cpp from CryptoPP */
 
20
/* x86 asm original */
 
21
 
 
22
#if defined(TAOCRYPT_KERNEL_MODE)
 
23
    #define DO_TAOCRYPT_KERNEL_MODE
 
24
#endif                                  // only some modules now support this
 
25
 
 
26
#include "runtime.hpp"
 
27
#include "aes.hpp"
 
28
 
 
29
 
 
30
namespace TaoCrypt {
 
31
 
 
32
 
 
33
#if defined(DO_AES_ASM)
 
34
 
 
35
// ia32 optimized version
 
36
void AES::Process(byte* out, const byte* in, word32 sz)
 
37
{
 
38
    if (!isMMX) {
 
39
        Mode_BASE::Process(out, in, sz);
 
40
        return;
 
41
    }
 
42
 
 
43
    word32 blocks = sz / BLOCK_SIZE;
 
44
 
 
45
    if (mode_ == ECB)
 
46
        while (blocks--) {
 
47
            if (dir_ == ENCRYPTION)
 
48
                AsmEncrypt(in, out, (void*)Te0);
 
49
            else
 
50
                AsmDecrypt(in, out, (void*)Td0);               
 
51
            out += BLOCK_SIZE;
 
52
            in  += BLOCK_SIZE;
 
53
        }
 
54
    else if (mode_ == CBC) {
 
55
        if (dir_ == ENCRYPTION)
 
56
            while (blocks--) {
 
57
                r_[0] ^= *(word32*)in;
 
58
                r_[1] ^= *(word32*)(in +  4);
 
59
                r_[2] ^= *(word32*)(in +  8);
 
60
                r_[3] ^= *(word32*)(in + 12);
 
61
 
 
62
                AsmEncrypt((byte*)r_, (byte*)r_, (void*)Te0);
 
63
 
 
64
                memcpy(out, r_, BLOCK_SIZE);
 
65
                out += BLOCK_SIZE;
 
66
                in  += BLOCK_SIZE;
 
67
            }
 
68
        else
 
69
            while (blocks--) {
 
70
                AsmDecrypt(in, out, (void*)Td0);
 
71
                
 
72
                *(word32*)out        ^= r_[0];
 
73
                *(word32*)(out +  4) ^= r_[1];
 
74
                *(word32*)(out +  8) ^= r_[2];
 
75
                *(word32*)(out + 12) ^= r_[3];
 
76
 
 
77
                memcpy(r_, in, BLOCK_SIZE);
 
78
                out += BLOCK_SIZE;
 
79
                in  += BLOCK_SIZE;
 
80
            }
 
81
    }
 
82
}
 
83
 
 
84
#endif // DO_AES_ASM
 
85
 
 
86
 
 
87
void AES::SetKey(const byte* userKey, word32 keylen, CipherDir /*dummy*/)
 
88
{
 
89
    assert( (keylen == 16) || (keylen == 24) || (keylen == 32) );
 
90
 
 
91
    rounds_ = keylen/4 + 6;
 
92
 
 
93
    word32 temp, *rk = key_;
 
94
    unsigned int i=0;
 
95
 
 
96
    GetUserKey(BigEndianOrder, rk, keylen/4, userKey, keylen);
 
97
 
 
98
    switch(keylen)
 
99
    {
 
100
    case 16:
 
101
        while (true)
 
102
        {
 
103
            temp  = rk[3];
 
104
            rk[4] = rk[0] ^
 
105
                (Te4[GETBYTE(temp, 2)] & 0xff000000) ^
 
106
                (Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
 
107
                (Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
 
108
                (Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
 
109
                rcon_[i];
 
110
            rk[5] = rk[1] ^ rk[4];
 
111
            rk[6] = rk[2] ^ rk[5];
 
112
            rk[7] = rk[3] ^ rk[6];
 
113
            if (++i == 10)
 
114
                break;
 
115
            rk += 4;
 
116
        }
 
117
        break;
 
118
 
 
119
    case 24:
 
120
        while (true)    // for (;;) here triggers a bug in VC60 SP4 w/ Pro Pack
 
121
        {
 
122
            temp = rk[ 5];
 
123
            rk[ 6] = rk[ 0] ^
 
124
                (Te4[GETBYTE(temp, 2)] & 0xff000000) ^
 
125
                (Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
 
126
                (Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
 
127
                (Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
 
128
                rcon_[i];
 
129
            rk[ 7] = rk[ 1] ^ rk[ 6];
 
130
            rk[ 8] = rk[ 2] ^ rk[ 7];
 
131
            rk[ 9] = rk[ 3] ^ rk[ 8];
 
132
            if (++i == 8)
 
133
                break;
 
134
            rk[10] = rk[ 4] ^ rk[ 9];
 
135
            rk[11] = rk[ 5] ^ rk[10];
 
136
            rk += 6;
 
137
        }
 
138
        break;
 
139
 
 
140
    case 32:
 
141
        while (true)
 
142
        {
 
143
            temp = rk[ 7];
 
144
            rk[ 8] = rk[ 0] ^
 
145
                (Te4[GETBYTE(temp, 2)] & 0xff000000) ^
 
146
                (Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
 
147
                (Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
 
148
                (Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
 
149
                rcon_[i];
 
150
            rk[ 9] = rk[ 1] ^ rk[ 8];
 
151
            rk[10] = rk[ 2] ^ rk[ 9];
 
152
            rk[11] = rk[ 3] ^ rk[10];
 
153
            if (++i == 7)
 
154
                break;
 
155
            temp = rk[11];
 
156
            rk[12] = rk[ 4] ^
 
157
                (Te4[GETBYTE(temp, 3)] & 0xff000000) ^
 
158
                (Te4[GETBYTE(temp, 2)] & 0x00ff0000) ^
 
159
                (Te4[GETBYTE(temp, 1)] & 0x0000ff00) ^
 
160
                (Te4[GETBYTE(temp, 0)] & 0x000000ff);
 
161
            rk[13] = rk[ 5] ^ rk[12];
 
162
            rk[14] = rk[ 6] ^ rk[13];
 
163
            rk[15] = rk[ 7] ^ rk[14];
 
164
 
 
165
            rk += 8;
 
166
        }
 
167
        break;
 
168
    }
 
169
 
 
170
    if (dir_ == DECRYPTION)
 
171
    {
 
172
        unsigned int i, j;
 
173
        rk = key_;
 
174
 
 
175
        /* invert the order of the round keys: */
 
176
        for (i = 0, j = 4*rounds_; i < j; i += 4, j -= 4) {
 
177
            temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;
 
178
            temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
 
179
            temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
 
180
            temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
 
181
        }
 
182
        // apply the inverse MixColumn transform to all round keys but the
 
183
        // first and the last:
 
184
        for (i = 1; i < rounds_; i++) {
 
185
            rk += 4;
 
186
            rk[0] =
 
187
                Td0[Te4[GETBYTE(rk[0], 3)] & 0xff] ^
 
188
                Td1[Te4[GETBYTE(rk[0], 2)] & 0xff] ^
 
189
                Td2[Te4[GETBYTE(rk[0], 1)] & 0xff] ^
 
190
                Td3[Te4[GETBYTE(rk[0], 0)] & 0xff];
 
191
            rk[1] =
 
192
                Td0[Te4[GETBYTE(rk[1], 3)] & 0xff] ^
 
193
                Td1[Te4[GETBYTE(rk[1], 2)] & 0xff] ^
 
194
                Td2[Te4[GETBYTE(rk[1], 1)] & 0xff] ^
 
195
                Td3[Te4[GETBYTE(rk[1], 0)] & 0xff];
 
196
            rk[2] =
 
197
                Td0[Te4[GETBYTE(rk[2], 3)] & 0xff] ^
 
198
                Td1[Te4[GETBYTE(rk[2], 2)] & 0xff] ^
 
199
                Td2[Te4[GETBYTE(rk[2], 1)] & 0xff] ^
 
200
                Td3[Te4[GETBYTE(rk[2], 0)] & 0xff];
 
201
            rk[3] =
 
202
                Td0[Te4[GETBYTE(rk[3], 3)] & 0xff] ^
 
203
                Td1[Te4[GETBYTE(rk[3], 2)] & 0xff] ^
 
204
                Td2[Te4[GETBYTE(rk[3], 1)] & 0xff] ^
 
205
                Td3[Te4[GETBYTE(rk[3], 0)] & 0xff];
 
206
        }
 
207
    }
 
208
}
 
209
 
 
210
 
 
211
void AES::ProcessAndXorBlock(const byte* in, const byte* xOr, byte* out) const
 
212
{
 
213
    if (dir_ == ENCRYPTION)
 
214
        encrypt(in, xOr, out);
 
215
    else
 
216
        decrypt(in, xOr, out);
 
217
}
 
218
 
 
219
 
 
220
typedef BlockGetAndPut<word32, BigEndian> gpBlock;
 
221
 
 
222
        
 
223
void AES::encrypt(const byte* inBlock, const byte* xorBlock,
 
224
                  byte* outBlock) const
 
225
{
 
226
    word32 s0, s1, s2, s3;
 
227
    word32 t0, t1, t2, t3;
 
228
 
 
229
    const word32 *rk = key_;
 
230
    /*
 
231
     * map byte array block to cipher state
 
232
     * and add initial round key:
 
233
     */
 
234
    gpBlock::Get(inBlock)(s0)(s1)(s2)(s3);
 
235
    s0 ^= rk[0];
 
236
    s1 ^= rk[1];
 
237
    s2 ^= rk[2];
 
238
    s3 ^= rk[3];
 
239
   
 
240
    /*
 
241
     * Nr - 1 full rounds:
 
242
     */
 
243
 
 
244
    unsigned int r = rounds_ >> 1;
 
245
    for (;;) {
 
246
        t0 =
 
247
            Te0[GETBYTE(s0, 3)] ^
 
248
            Te1[GETBYTE(s1, 2)] ^
 
249
            Te2[GETBYTE(s2, 1)] ^
 
250
            Te3[GETBYTE(s3, 0)] ^
 
251
            rk[4];
 
252
        t1 =
 
253
            Te0[GETBYTE(s1, 3)] ^
 
254
            Te1[GETBYTE(s2, 2)] ^
 
255
            Te2[GETBYTE(s3, 1)] ^
 
256
            Te3[GETBYTE(s0, 0)] ^
 
257
            rk[5];
 
258
        t2 =
 
259
            Te0[GETBYTE(s2, 3)] ^
 
260
            Te1[GETBYTE(s3, 2)] ^
 
261
            Te2[GETBYTE(s0, 1)] ^
 
262
            Te3[GETBYTE(s1, 0)] ^
 
263
            rk[6];
 
264
        t3 =
 
265
            Te0[GETBYTE(s3, 3)] ^
 
266
            Te1[GETBYTE(s0, 2)] ^
 
267
            Te2[GETBYTE(s1, 1)] ^
 
268
            Te3[GETBYTE(s2, 0)] ^
 
269
            rk[7];
 
270
 
 
271
        rk += 8;
 
272
        if (--r == 0) {
 
273
            break;
 
274
        }
 
275
 
 
276
        s0 =
 
277
            Te0[GETBYTE(t0, 3)] ^
 
278
            Te1[GETBYTE(t1, 2)] ^
 
279
            Te2[GETBYTE(t2, 1)] ^
 
280
            Te3[GETBYTE(t3, 0)] ^
 
281
            rk[0];
 
282
        s1 =
 
283
            Te0[GETBYTE(t1, 3)] ^
 
284
            Te1[GETBYTE(t2, 2)] ^
 
285
            Te2[GETBYTE(t3, 1)] ^
 
286
            Te3[GETBYTE(t0, 0)] ^
 
287
            rk[1];
 
288
        s2 =
 
289
            Te0[GETBYTE(t2, 3)] ^
 
290
            Te1[GETBYTE(t3, 2)] ^
 
291
            Te2[GETBYTE(t0, 1)] ^
 
292
            Te3[GETBYTE(t1, 0)] ^
 
293
            rk[2];
 
294
        s3 =
 
295
            Te0[GETBYTE(t3, 3)] ^
 
296
            Te1[GETBYTE(t0, 2)] ^
 
297
            Te2[GETBYTE(t1, 1)] ^
 
298
            Te3[GETBYTE(t2, 0)] ^
 
299
            rk[3];
 
300
    }
 
301
 
 
302
    /*
 
303
     * apply last round and
 
304
     * map cipher state to byte array block:
 
305
     */
 
306
 
 
307
    s0 =
 
308
        (Te4[GETBYTE(t0, 3)] & 0xff000000) ^
 
309
        (Te4[GETBYTE(t1, 2)] & 0x00ff0000) ^
 
310
        (Te4[GETBYTE(t2, 1)] & 0x0000ff00) ^
 
311
        (Te4[GETBYTE(t3, 0)] & 0x000000ff) ^
 
312
        rk[0];
 
313
    s1 =
 
314
        (Te4[GETBYTE(t1, 3)] & 0xff000000) ^
 
315
        (Te4[GETBYTE(t2, 2)] & 0x00ff0000) ^
 
316
        (Te4[GETBYTE(t3, 1)] & 0x0000ff00) ^
 
317
        (Te4[GETBYTE(t0, 0)] & 0x000000ff) ^
 
318
        rk[1];
 
319
    s2 =
 
320
        (Te4[GETBYTE(t2, 3)] & 0xff000000) ^
 
321
        (Te4[GETBYTE(t3, 2)] & 0x00ff0000) ^
 
322
        (Te4[GETBYTE(t0, 1)] & 0x0000ff00) ^
 
323
        (Te4[GETBYTE(t1, 0)] & 0x000000ff) ^
 
324
        rk[2];
 
325
    s3 =
 
326
        (Te4[GETBYTE(t3, 3)] & 0xff000000) ^
 
327
        (Te4[GETBYTE(t0, 2)] & 0x00ff0000) ^
 
328
        (Te4[GETBYTE(t1, 1)] & 0x0000ff00) ^
 
329
        (Te4[GETBYTE(t2, 0)] & 0x000000ff) ^
 
330
        rk[3];
 
331
 
 
332
 
 
333
    gpBlock::Put(xorBlock, outBlock)(s0)(s1)(s2)(s3);
 
334
}
 
335
 
 
336
 
 
337
void AES::decrypt(const byte* inBlock, const byte* xorBlock,
 
338
                  byte* outBlock) const
 
339
{
 
340
    word32 s0, s1, s2, s3;
 
341
    word32 t0, t1, t2, t3;
 
342
    const word32* rk = key_;
 
343
 
 
344
    /*
 
345
     * map byte array block to cipher state
 
346
     * and add initial round key:
 
347
     */
 
348
    gpBlock::Get(inBlock)(s0)(s1)(s2)(s3);
 
349
    s0 ^= rk[0];
 
350
    s1 ^= rk[1];
 
351
    s2 ^= rk[2];
 
352
    s3 ^= rk[3];
 
353
 
 
354
    /*
 
355
     * Nr - 1 full rounds:
 
356
     */
 
357
 
 
358
    unsigned int r = rounds_ >> 1;
 
359
    for (;;) {
 
360
        t0 =
 
361
            Td0[GETBYTE(s0, 3)] ^
 
362
            Td1[GETBYTE(s3, 2)] ^
 
363
            Td2[GETBYTE(s2, 1)] ^
 
364
            Td3[GETBYTE(s1, 0)] ^
 
365
            rk[4];
 
366
        t1 =
 
367
            Td0[GETBYTE(s1, 3)] ^
 
368
            Td1[GETBYTE(s0, 2)] ^
 
369
            Td2[GETBYTE(s3, 1)] ^
 
370
            Td3[GETBYTE(s2, 0)] ^
 
371
            rk[5];
 
372
        t2 =
 
373
            Td0[GETBYTE(s2, 3)] ^
 
374
            Td1[GETBYTE(s1, 2)] ^
 
375
            Td2[GETBYTE(s0, 1)] ^
 
376
            Td3[GETBYTE(s3, 0)] ^
 
377
            rk[6];
 
378
        t3 =
 
379
            Td0[GETBYTE(s3, 3)] ^
 
380
            Td1[GETBYTE(s2, 2)] ^
 
381
            Td2[GETBYTE(s1, 1)] ^
 
382
            Td3[GETBYTE(s0, 0)] ^
 
383
            rk[7];
 
384
 
 
385
        rk += 8;
 
386
        if (--r == 0) {
 
387
            break;
 
388
        }
 
389
 
 
390
        s0 =
 
391
            Td0[GETBYTE(t0, 3)] ^
 
392
            Td1[GETBYTE(t3, 2)] ^
 
393
            Td2[GETBYTE(t2, 1)] ^
 
394
            Td3[GETBYTE(t1, 0)] ^
 
395
            rk[0];
 
396
        s1 =
 
397
            Td0[GETBYTE(t1, 3)] ^
 
398
            Td1[GETBYTE(t0, 2)] ^
 
399
            Td2[GETBYTE(t3, 1)] ^
 
400
            Td3[GETBYTE(t2, 0)] ^
 
401
            rk[1];
 
402
        s2 =
 
403
            Td0[GETBYTE(t2, 3)] ^
 
404
            Td1[GETBYTE(t1, 2)] ^
 
405
            Td2[GETBYTE(t0, 1)] ^
 
406
            Td3[GETBYTE(t3, 0)] ^
 
407
            rk[2];
 
408
        s3 =
 
409
            Td0[GETBYTE(t3, 3)] ^
 
410
            Td1[GETBYTE(t2, 2)] ^
 
411
            Td2[GETBYTE(t1, 1)] ^
 
412
            Td3[GETBYTE(t0, 0)] ^
 
413
            rk[3];
 
414
    }
 
415
    /*
 
416
     * apply last round and
 
417
     * map cipher state to byte array block:
 
418
     */
 
419
    s0 =
 
420
        (Td4[GETBYTE(t0, 3)] & 0xff000000) ^
 
421
        (Td4[GETBYTE(t3, 2)] & 0x00ff0000) ^
 
422
        (Td4[GETBYTE(t2, 1)] & 0x0000ff00) ^
 
423
        (Td4[GETBYTE(t1, 0)] & 0x000000ff) ^
 
424
    rk[0];
 
425
    s1 =
 
426
        (Td4[GETBYTE(t1, 3)] & 0xff000000) ^
 
427
        (Td4[GETBYTE(t0, 2)] & 0x00ff0000) ^
 
428
        (Td4[GETBYTE(t3, 1)] & 0x0000ff00) ^
 
429
        (Td4[GETBYTE(t2, 0)] & 0x000000ff) ^
 
430
        rk[1];
 
431
    s2 =
 
432
        (Td4[GETBYTE(t2, 3)] & 0xff000000) ^
 
433
        (Td4[GETBYTE(t1, 2)] & 0x00ff0000) ^
 
434
        (Td4[GETBYTE(t0, 1)] & 0x0000ff00) ^
 
435
        (Td4[GETBYTE(t3, 0)] & 0x000000ff) ^
 
436
        rk[2];
 
437
    s3 =
 
438
        (Td4[GETBYTE(t3, 3)] & 0xff000000) ^
 
439
        (Td4[GETBYTE(t2, 2)] & 0x00ff0000) ^
 
440
        (Td4[GETBYTE(t1, 1)] & 0x0000ff00) ^
 
441
        (Td4[GETBYTE(t0, 0)] & 0x000000ff) ^
 
442
        rk[3];
 
443
 
 
444
    gpBlock::Put(xorBlock, outBlock)(s0)(s1)(s2)(s3);
 
445
}
 
446
 
 
447
 
 
448
#if defined(DO_AES_ASM)
 
449
    #ifdef __GNUC__
 
450
        #define AS1(x)    asm(#x);
 
451
        #define AS2(x, y) asm(#x ", " #y);
 
452
 
 
453
        #define PROLOG()  \
 
454
            asm(".intel_syntax noprefix"); \
 
455
            AS2(    movd  mm3, edi                      )   \
 
456
            AS2(    movd  mm4, ebx                      )   \
 
457
            AS2(    sub   esp, 4                        )   \
 
458
            AS2(    movd  mm7, ebp                      )   \
 
459
            AS2(    mov   [ebp - 4], esi                )   \
 
460
            AS2(    mov   ecx, DWORD PTR [ebp +  8]     )   \
 
461
            AS2(    mov   esi, DWORD PTR [ebp + 12]     )   \
 
462
            AS2(    mov   ebp, DWORD PTR [ebp + 20]     )
 
463
 
 
464
        #define EPILOG()  \
 
465
            AS2(    mov  esi, [ebp - 4]             )   \
 
466
            AS2(    mov  esp, ebp                   )   \
 
467
            AS2(    movd ebx, mm4                   )   \
 
468
            AS2(    movd edi, mm3                   )   \
 
469
            AS1(    emms                            )   \
 
470
            asm(".att_syntax");
 
471
    #else
 
472
        #define AS1(x)    __asm x
 
473
        #define AS2(x, y) __asm x, y
 
474
 
 
475
        #define PROLOG() \
 
476
            AS1(    push  ebp                           )   \
 
477
            AS2(    mov   ebp, esp                      )   \
 
478
            AS2(    movd  mm3, edi                      )   \
 
479
            AS2(    movd  mm4, ebx                      )   \
 
480
            AS2(    sub   esp, 4                        )   \
 
481
            AS2(    movd  mm7, ebp                      )   \
 
482
            AS2(    mov   [ebp - 4], esi                )   \
 
483
            AS2(    mov   esi, DWORD PTR [ebp +  8]     )   \
 
484
            AS2(    mov   ebp, DWORD PTR [ebp + 16]     )
 
485
 
 
486
        // ebp is restored at end
 
487
        #define EPILOG()  \
 
488
            AS2(    mov   esi, [ebp - 4]                )   \
 
489
            AS2(    movd  ebx, mm4                      )   \
 
490
            AS2(    movd  edi, mm3                      )   \
 
491
            AS2(    mov   esp, ebp                      )   \
 
492
            AS1(    pop   ebp                           )   \
 
493
            AS1(    emms                                )   \
 
494
            AS1(    ret   12                            )
 
495
            
 
496
            
 
497
    #endif
 
498
 
 
499
 
 
500
#ifdef _MSC_VER
 
501
    __declspec(naked) 
 
502
#endif
 
503
void AES::AsmEncrypt(const byte* inBlock, byte* outBlock, void* boxes) const
 
504
{
 
505
 
 
506
    PROLOG()
 
507
 
 
508
    #ifdef OLD_GCC_OFFSET
 
509
        AS2(    mov   edx, DWORD PTR [ecx + 60]     )   // rounds
 
510
        AS2(    lea   edi, [ecx + 64]               )   // rk
 
511
    #else
 
512
        AS2(    mov   edx, DWORD PTR [ecx + 56]     )   // rounds
 
513
        AS2(    lea   edi, [ecx + 60]               )   // rk
 
514
    #endif
 
515
 
 
516
    AS1(    dec   edx                           )
 
517
    AS2(    movd  mm6, edi                      )   // save rk
 
518
    AS2(    movd  mm5, edx                      )   // save rounds
 
519
  
 
520
    AS2(    mov   eax, DWORD PTR [esi]                                  )
 
521
    AS2(    mov   ebx, DWORD PTR [esi + 4]                              )
 
522
    AS2(    mov   ecx, DWORD PTR [esi + 8]                              )
 
523
    AS2(    mov   edx, DWORD PTR [esi + 12]                             )
 
524
 
 
525
    AS1(    bswap eax                                                   )
 
526
    AS1(    bswap ebx                                                   )
 
527
    AS1(    bswap ecx                                                   )
 
528
    AS1(    bswap edx                                                   )
 
529
 
 
530
    AS2(    xor   eax, DWORD PTR [edi]               )   // s0
 
531
    AS2(    xor   ebx, DWORD PTR [edi +  4]          )   // s1
 
532
    AS2(    xor   ecx, DWORD PTR [edi +  8]          )   // s2
 
533
    AS2(    xor   edx, DWORD PTR [edi + 12]          )   // s3
 
534
 
 
535
    AS1(loop1:                                                          )
 
536
            /* Put0 (mm0) =  
 
537
                Te0[get0,rs 24] ^
 
538
                Te1[get1,rs 16] ^
 
539
                Te2[get2,rs  8] ^
 
540
                Te3[get3,rs  0]
 
541
            */
 
542
       
 
543
    AS2(    mov   esi, eax                                              )
 
544
    AS2(    shr   esi, 24                                               )
 
545
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
546
                                                    
 
547
    AS2(    mov   edi, ebx                                              )
 
548
    AS2(    shr   edi, 16                                               )
 
549
    AS2(    and   edi, 255                                              )
 
550
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
551
 
 
552
    AS2(    movzx edi, ch                                               )
 
553
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
554
 
 
555
    AS2(    movzx edi, dl                                               )
 
556
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
557
 
 
558
    AS2(    movd  mm0, esi                                              )
 
559
 
 
560
             /* Put1 (mm1) =  
 
561
                Te0[get1,rs 24] ^
 
562
                Te1[get2,rs 16] ^
 
563
                Te2[get3,rs  8] ^
 
564
                Te3[get0,rs  0]
 
565
            */
 
566
 
 
567
    AS2(    mov   esi, ebx                                              )
 
568
    AS2(    shr   esi, 24                                               )
 
569
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
570
 
 
571
    AS2(    mov   edi, ecx                                              )
 
572
    AS2(    shr   edi, 16                                               )
 
573
    AS2(    and   edi, 255                                              )
 
574
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
575
 
 
576
    AS2(    movzx edi, dh                                               )
 
577
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
578
 
 
579
    AS2(    movzx edi, al                                               )
 
580
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
581
 
 
582
    AS2(    movd  mm1, esi                                              )
 
583
 
 
584
 
 
585
             /* Put2 (mm2) =  
 
586
                Te0[get2,rs 24] ^
 
587
                Te1[get3,rs 16] ^
 
588
                Te2[get0,rs  8] ^
 
589
                Te3[get1,rs  0] 
 
590
            */
 
591
 
 
592
    AS2(    mov   esi, ecx                                              )
 
593
    AS2(    shr   esi, 24                                               )
 
594
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
595
 
 
596
    AS2(    mov   edi, edx                                              )
 
597
    AS2(    shr   edi, 16                                               )
 
598
    AS2(    and   edi, 255                                              )
 
599
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
600
 
 
601
    AS2(    movzx edi, ah                                               )
 
602
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
603
 
 
604
    AS2(    movzx edi, bl                                               )
 
605
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
606
 
 
607
    AS2(    movd  mm2, esi                                              )
 
608
 
 
609
             /* Put3 (edx) =  
 
610
                Te0[get3,rs 24] ^
 
611
                Te1[get0,rs 16] ^
 
612
                Te2[get1,rs  8] ^
 
613
                Te3[get2,rs  0] 
 
614
            */
 
615
 
 
616
    AS2(    mov   esi, edx                                              )
 
617
    AS2(    shr   esi, 24                                               )
 
618
    AS2(    mov   edx, DWORD PTR [ebp + esi*4]                          )
 
619
 
 
620
    AS2(    mov   edi, eax                                              )
 
621
    AS2(    shr   edi, 16                                               )
 
622
    AS2(    and   edi, 255                                              )
 
623
    AS2(    xor   edx, DWORD PTR [ebp + 1024 + edi*4]                   )
 
624
 
 
625
    AS2(    movzx esi, bh                                               )
 
626
    AS2(    xor   edx, DWORD PTR [ebp + 2048 + esi*4]                   )
 
627
 
 
628
    AS2(    movzx edi, cl                                               )
 
629
    AS2(    xor   edx, DWORD PTR [ebp + 3072 + edi*4]                   )
 
630
 
 
631
            // xOr
 
632
 
 
633
    AS2(    movd   esi, mm6                      )   //  rk
 
634
 
 
635
    AS2(    movd   eax, mm0                                             )
 
636
    AS2(    add    esi, 16                                              )
 
637
    AS2(    movd   ebx, mm1                                             )
 
638
    AS2(    movd   mm6, esi                      )   //  save back
 
639
    AS2(    movd   ecx, mm2                                             )
 
640
 
 
641
    AS2(    xor   eax, DWORD PTR [esi]                                  )
 
642
    AS2(    xor   ebx, DWORD PTR [esi +  4]                             )
 
643
    AS2(    movd  edi, mm5                                              )
 
644
    AS2(    xor   ecx, DWORD PTR [esi +  8]                             )
 
645
    AS2(    xor   edx, DWORD PTR [esi + 12]                             )
 
646
 
 
647
    AS1(    dec   edi                                                   )
 
648
    AS2(    movd  mm5, edi                                              )
 
649
 
 
650
    AS1(    jnz   loop1                                                 )
 
651
 
 
652
            // last round
 
653
            /*
 
654
            Put0 (mm0) =
 
655
                (Te4[get0, rs24] & 0xff000000) ^  h = 4278190080
 
656
                (Te4[get1, rs16] & 0x00ff0000) ^  h =   16711680
 
657
                (Te4[get2, rs 8] & 0x0000ff00) ^  h =      65280
 
658
                (Te4[get3, rs 0] & 0x000000ff)    h =        255
 
659
            */
 
660
    AS2(    mov   esi, eax                                              )
 
661
    AS2(    shr   esi, 24                                               )
 
662
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
663
    AS2(    and   esi, 4278190080                                       )
 
664
 
 
665
    AS2(    mov   edi, ebx                                              )
 
666
    AS2(    shr   edi, 16                                               )
 
667
    AS2(    and   edi, 255                                              )
 
668
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
669
    AS2(    and   edi, 16711680                                         )
 
670
    AS2(    xor   esi, edi                                              )
 
671
 
 
672
    AS2(    movzx edi, ch                                               )
 
673
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
674
    AS2(    and   edi, 65280                                            )
 
675
    AS2(    xor   esi, edi                                              )
 
676
 
 
677
    AS2(    movzx edi, dl                                               )
 
678
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
679
    AS2(    and   edi, 255                                              )
 
680
    AS2(    xor   esi, edi                                              )
 
681
 
 
682
    AS2(    movd  mm0, esi                                              )
 
683
 
 
684
            /*
 
685
            Put1 (mm1) =
 
686
                (Te4[get1, rs24] & 0xff000000) ^  h = 4278190080
 
687
                (Te4[get2, rs16] & 0x00ff0000) ^  h =   16711680
 
688
                (Te4[get3, rs 8] & 0x0000ff00) ^  h =      65280
 
689
                (Te4[get0, rs 0] & 0x000000ff)    h =        255
 
690
            */
 
691
    AS2(    mov   esi, ebx                                              )
 
692
    AS2(    shr   esi, 24                                               )
 
693
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
694
    AS2(    and   esi, 4278190080                                       )
 
695
 
 
696
    AS2(    mov   edi, ecx                                              )
 
697
    AS2(    shr   edi, 16                                               )
 
698
    AS2(    and   edi, 255                                              )
 
699
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
700
    AS2(    and   edi, 16711680                                         )
 
701
    AS2(    xor   esi, edi                                              )
 
702
 
 
703
    AS2(    movzx edi, dh                                               )
 
704
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
705
    AS2(    and   edi, 65280                                            )
 
706
    AS2(    xor   esi, edi                                              )
 
707
 
 
708
    AS2(    movzx edi, al                                               )
 
709
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
710
    AS2(    and   edi, 255                                              )
 
711
    AS2(    xor   esi, edi                                              )
 
712
 
 
713
    AS2(    movd  mm1, esi                                              )
 
714
 
 
715
            /*
 
716
            Put2 (mm2) =
 
717
                (Te4[get2, rs24] & 0xff000000) ^  h = 4278190080
 
718
                (Te4[get3, rs16] & 0x00ff0000) ^  h =   16711680
 
719
                (Te4[get0, rs 8] & 0x0000ff00) ^  h =      65280
 
720
                (Te4[get1, rs 0] & 0x000000ff)    h =        255
 
721
            */
 
722
    AS2(    mov   esi, ecx                                              )
 
723
    AS2(    shr   esi, 24                                               )
 
724
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
725
    AS2(    and   esi, 4278190080                                       )
 
726
 
 
727
    AS2(    mov   edi, edx                                              )
 
728
    AS2(    shr   edi, 16                                               )
 
729
    AS2(    and   edi, 255                                              )
 
730
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
731
    AS2(    and   edi, 16711680                                         )
 
732
    AS2(    xor   esi, edi                                              )
 
733
 
 
734
    AS2(    movzx edi, ah                                               )
 
735
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
736
    AS2(    and   edi, 65280                                            )
 
737
    AS2(    xor   esi, edi                                              )
 
738
 
 
739
    AS2(    movzx edi, bl                                               )
 
740
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
741
    AS2(    and   edi, 255                                              )
 
742
    AS2(    xor   esi, edi                                              )
 
743
 
 
744
    AS2(    movd  mm2, esi                                              )
 
745
 
 
746
            /*
 
747
            Put3 (edx) =
 
748
                (Te4[get3, rs24] & 0xff000000) ^  h = 4278190080
 
749
                (Te4[get0, rs16] & 0x00ff0000) ^  h =   16711680
 
750
                (Te4[get1, rs 8] & 0x0000ff00) ^  h =      65280
 
751
                (Te4[get2, rs 0] & 0x000000ff)    h =        255
 
752
            */
 
753
    AS2(    mov   esi, edx                                              )
 
754
    AS2(    shr   esi, 24                                               )
 
755
    AS2(    mov   edx, DWORD PTR [ebp + 4096 + esi*4]                   )
 
756
    AS2(    and   edx, 4278190080                                       )
 
757
 
 
758
    AS2(    mov   edi, eax                                              )
 
759
    AS2(    shr   edi, 16                                               )
 
760
    AS2(    and   edi, 255                                              )
 
761
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
762
    AS2(    and   esi, 16711680                                         )
 
763
    AS2(    xor   edx, esi                                              )
 
764
 
 
765
    AS2(    movzx esi, bh                                               )
 
766
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
767
    AS2(    and   edi, 65280                                            )
 
768
    AS2(    xor   edx, edi                                              )
 
769
 
 
770
    AS2(    movzx edi, cl                                               )
 
771
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
772
    AS2(    and   esi, 255                                              )
 
773
    AS2(    xor   edx, esi                                              )
 
774
 
 
775
    
 
776
            // xOr
 
777
    AS2(    movd   eax, mm0                                             )
 
778
    AS2(    movd   esi, mm6                      )   //  rk
 
779
    AS2(    movd   ebx, mm1                                             )
 
780
    AS2(    add    esi, 16                                               )
 
781
    AS2(    movd   ecx, mm2                                             )
 
782
 
 
783
    AS2(    xor   eax, DWORD PTR [esi]                                  )
 
784
    AS2(    xor   ebx, DWORD PTR [esi +  4]                             )
 
785
    AS2(    xor   ecx, DWORD PTR [esi +  8]                             )
 
786
    AS2(    xor   edx, DWORD PTR [esi + 12]                             )
 
787
 
 
788
    // end
 
789
    AS2(    movd  ebp, mm7                                              )
 
790
 
 
791
            // swap
 
792
    AS1(    bswap eax                                                   )
 
793
    AS1(    bswap ebx                                                   )
 
794
 
 
795
            // store
 
796
    #ifdef __GNUC__
 
797
        AS2(    mov esi, DWORD PTR [ebp + 16]       )   //  outBlock
 
798
    #else
 
799
        AS2(    mov esi, DWORD PTR [ebp + 12]       )   //  outBlock
 
800
    #endif
 
801
 
 
802
    AS1(    bswap ecx                                                   )
 
803
    AS1(    bswap edx                                                   )
 
804
 
 
805
    AS2(    mov DWORD PTR [esi],      eax                               )
 
806
    AS2(    mov DWORD PTR [esi +  4], ebx                               )
 
807
    AS2(    mov DWORD PTR [esi +  8], ecx                               )
 
808
    AS2(    mov DWORD PTR [esi + 12], edx                               )
 
809
 
 
810
 
 
811
    EPILOG()
 
812
}
 
813
 
 
814
 
 
815
#ifdef _MSC_VER
 
816
    __declspec(naked) 
 
817
#endif
 
818
void AES::AsmDecrypt(const byte* inBlock, byte* outBlock, void* boxes) const
 
819
{
 
820
 
 
821
    PROLOG()
 
822
 
 
823
    #ifdef OLD_GCC_OFFSET
 
824
        AS2(    mov   edx, DWORD PTR [ecx + 60]     )   // rounds
 
825
        AS2(    lea   edi, [ecx + 64]               )   // rk 
 
826
    #else
 
827
        AS2(    mov   edx, DWORD PTR [ecx + 56]     )   // rounds
 
828
        AS2(    lea   edi, [ecx + 60]               )   // rk 
 
829
    #endif
 
830
   
 
831
    AS1(    dec   edx                           )
 
832
    AS2(    movd  mm6, edi                      )   // save rk
 
833
    AS2(    movd  mm5, edx                      )   // save rounds
 
834
 
 
835
    AS2(    mov   eax, DWORD PTR [esi]                                  )
 
836
    AS2(    mov   ebx, DWORD PTR [esi + 4]                              )
 
837
    AS2(    mov   ecx, DWORD PTR [esi + 8]                              )
 
838
    AS2(    mov   edx, DWORD PTR [esi + 12]                             )
 
839
 
 
840
    AS1(    bswap eax                                                   )
 
841
    AS1(    bswap ebx                                                   )
 
842
    AS1(    bswap ecx                                                   )
 
843
    AS1(    bswap edx                                                   )
 
844
 
 
845
    AS2(    xor   eax, DWORD PTR [edi]               )   // s0
 
846
    AS2(    xor   ebx, DWORD PTR [edi +  4]          )   // s1
 
847
    AS2(    xor   ecx, DWORD PTR [edi +  8]          )   // s2
 
848
    AS2(    xor   edx, DWORD PTR [edi + 12]          )   // s3
 
849
 
 
850
 
 
851
    AS1(loop2:                                                          )
 
852
       /*   Put0 (mm0) =
 
853
            Td0[GETBYTE(get0, rs24)] ^
 
854
            Td1[GETBYTE(get3, rs16)] ^
 
855
            Td2[GETBYTE(get2, rs 8)] ^
 
856
            Td3[GETBYTE(tet1,     )]  
 
857
        */
 
858
    AS2(    mov   esi, eax                                              )
 
859
    AS2(    shr   esi, 24                                               )
 
860
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
861
                                                    
 
862
    AS2(    mov   edi, edx                                              )
 
863
    AS2(    shr   edi, 16                                               )
 
864
    AS2(    and   edi, 255                                              )
 
865
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
866
 
 
867
    AS2(    movzx edi, ch                                               )
 
868
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
869
 
 
870
    AS2(    movzx edi, bl                                               )
 
871
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
872
 
 
873
    AS2(    movd  mm0, esi                                              )
 
874
 
 
875
      /*    Put1 (mm1) =
 
876
            Td0[GETBYTE(get1, rs24)] ^
 
877
            Td1[GETBYTE(get0, rs16)] ^
 
878
            Td2[GETBYTE(get3, rs 8)] ^
 
879
            Td3[GETBYTE(tet2,     )]  
 
880
        */
 
881
    AS2(    mov   esi, ebx                                              )
 
882
    AS2(    shr   esi, 24                                               )
 
883
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
884
                                                    
 
885
    AS2(    mov   edi, eax                                              )
 
886
    AS2(    shr   edi, 16                                               )
 
887
    AS2(    and   edi, 255                                              )
 
888
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
889
 
 
890
    AS2(    movzx edi, dh                                               )
 
891
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
892
 
 
893
    AS2(    movzx edi, cl                                               )
 
894
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
895
 
 
896
    AS2(    movd  mm1, esi                                              )
 
897
 
 
898
      /*    Put2 (mm2) =
 
899
            Td0[GETBYTE(get2, rs24)] ^
 
900
            Td1[GETBYTE(get1, rs16)] ^
 
901
            Td2[GETBYTE(get0, rs 8)] ^
 
902
            Td3[GETBYTE(tet3,     )]  
 
903
      */
 
904
    AS2(    mov   esi, ecx                                              )
 
905
    AS2(    shr   esi, 24                                               )
 
906
    AS2(    mov   esi, DWORD PTR [ebp + esi*4]                          )
 
907
                                                    
 
908
    AS2(    mov   edi, ebx                                              )
 
909
    AS2(    shr   edi, 16                                               )
 
910
    AS2(    and   edi, 255                                              )
 
911
    AS2(    xor   esi, DWORD PTR [ebp + 1024 + edi*4]                   )
 
912
 
 
913
    AS2(    movzx edi, ah                                               )
 
914
    AS2(    xor   esi, DWORD PTR [ebp + 2048 + edi*4]                   )
 
915
 
 
916
    AS2(    movzx edi, dl                                               )
 
917
    AS2(    xor   esi, DWORD PTR [ebp + 3072 + edi*4]                   )
 
918
 
 
919
    AS2(    movd  mm2, esi                                              )
 
920
 
 
921
      /*    Put3 (edx) =
 
922
            Td0[GETBYTE(get3, rs24)] ^
 
923
            Td1[GETBYTE(get2, rs16)] ^
 
924
            Td2[GETBYTE(get1, rs 8)] ^
 
925
            Td3[GETBYTE(tet0,     )]  
 
926
      */
 
927
    AS2(    mov   esi, edx                                              )
 
928
    AS2(    shr   esi, 24                                               )
 
929
    AS2(    mov   edx, DWORD PTR [ebp + esi*4]                          )
 
930
                                                    
 
931
    AS2(    mov   edi, ecx                                              )
 
932
    AS2(    shr   edi, 16                                               )
 
933
    AS2(    and   edi, 255                                              )
 
934
    AS2(    xor   edx, DWORD PTR [ebp + 1024 + edi*4]                   )
 
935
 
 
936
    AS2(    movzx esi, bh                                               )
 
937
    AS2(    xor   edx, DWORD PTR [ebp + 2048 + esi*4]                   )
 
938
 
 
939
    AS2(    movzx edi, al                                               )
 
940
    AS2(    xor   edx, DWORD PTR [ebp + 3072 + edi*4]                   )
 
941
 
 
942
 
 
943
            // xOr
 
944
 
 
945
    AS2(    movd  esi, mm6                      )   //  rk
 
946
    AS2(    add   esi, 16                                               )
 
947
    AS2(    movd  mm6, esi                      )   //  save back
 
948
 
 
949
    AS2(    movd  eax, mm0                                              )
 
950
    AS2(    movd  ebx, mm1                                              )
 
951
    AS2(    movd  ecx, mm2                                              )
 
952
 
 
953
    AS2(    xor   eax, DWORD PTR [esi]                                  )
 
954
    AS2(    xor   ebx, DWORD PTR [esi +  4]                             )
 
955
    AS2(    xor   ecx, DWORD PTR [esi +  8]                             )
 
956
    AS2(    xor   edx, DWORD PTR [esi + 12]                             )
 
957
 
 
958
    AS2(    movd  edi, mm5                                              )
 
959
    AS1(    dec   edi                                                   )
 
960
    AS2(    movd  mm5, edi                                              )
 
961
 
 
962
    AS1(    jnz   loop2                                                 )
 
963
 
 
964
            // last round
 
965
            /*
 
966
            Put0 (mm0) =
 
967
                (Td4[get0, rs24] & 0xff000000) ^  h = 4278190080
 
968
                (Td4[get3, rs16] & 0x00ff0000) ^  h =   16711680
 
969
                (Td4[get2, rs 8] & 0x0000ff00) ^  h =      65280
 
970
                (Td4[get1, rs 0] & 0x000000ff)    h =        255
 
971
            */
 
972
    AS2(    mov   esi, eax                                              )
 
973
    AS2(    shr   esi, 24                                               )
 
974
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
975
    AS2(    and   esi, 4278190080                                       )
 
976
 
 
977
    AS2(    mov   edi, edx                                              )
 
978
    AS2(    shr   edi, 16                                               )
 
979
    AS2(    and   edi, 255                                              )
 
980
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
981
    AS2(    and   edi, 16711680                                         )
 
982
    AS2(    xor   esi, edi                                              )
 
983
 
 
984
    AS2(    movzx edi, ch                                               )
 
985
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
986
    AS2(    and   edi, 65280                                            )
 
987
    AS2(    xor   esi, edi                                              )
 
988
 
 
989
    AS2(    movzx edi, bl                                               )
 
990
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
991
    AS2(    and   edi, 255                                              )
 
992
    AS2(    xor   esi, edi                                              )
 
993
 
 
994
    AS2(    movd  mm0, esi                                              )
 
995
 
 
996
            /*
 
997
            Put1 (mm1) =
 
998
                (Td4[get1, rs24] & 0xff000000) ^  h = 4278190080
 
999
                (Td4[get0, rs16] & 0x00ff0000) ^  h =   16711680
 
1000
                (Td4[get3, rs 8] & 0x0000ff00) ^  h =      65280
 
1001
                (Td4[get2, rs 0] & 0x000000ff)    h =        255
 
1002
            */
 
1003
    AS2(    mov   esi, ebx                                              )
 
1004
    AS2(    shr   esi, 24                                               )
 
1005
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
1006
    AS2(    and   esi, 4278190080                                       )
 
1007
 
 
1008
    AS2(    mov   edi, eax                                              )
 
1009
    AS2(    shr   edi, 16                                               )
 
1010
    AS2(    and   edi, 255                                              )
 
1011
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1012
    AS2(    and   edi, 16711680                                         )
 
1013
    AS2(    xor   esi, edi                                              )
 
1014
 
 
1015
    AS2(    movzx edi, dh                                               )
 
1016
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1017
    AS2(    and   edi, 65280                                            )
 
1018
    AS2(    xor   esi, edi                                              )
 
1019
 
 
1020
    AS2(    movzx edi, cl                                               )
 
1021
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1022
    AS2(    and   edi, 255                                              )
 
1023
    AS2(    xor   esi, edi                                              )
 
1024
 
 
1025
    AS2(    movd  mm1, esi                                              )
 
1026
 
 
1027
            /*
 
1028
            Put2 (mm2) =
 
1029
                (Td4[get2, rs24] & 0xff000000) ^  h = 4278190080
 
1030
                (Td4[get1, rs16] & 0x00ff0000) ^  h =   16711680
 
1031
                (Td4[get0, rs 8] & 0x0000ff00) ^  h =      65280
 
1032
                (Td4[get3, rs 0] & 0x000000ff)    h =        255
 
1033
            */
 
1034
    AS2(    mov   esi, ecx                                              )
 
1035
    AS2(    shr   esi, 24                                               )
 
1036
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
1037
    AS2(    and   esi, 4278190080                                       )
 
1038
 
 
1039
    AS2(    mov   edi, ebx                                              )
 
1040
    AS2(    shr   edi, 16                                               )
 
1041
    AS2(    and   edi, 255                                              )
 
1042
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1043
    AS2(    and   edi, 16711680                                         )
 
1044
    AS2(    xor   esi, edi                                              )
 
1045
 
 
1046
    AS2(    movzx edi, ah                                               )
 
1047
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1048
    AS2(    and   edi, 65280                                            )
 
1049
    AS2(    xor   esi, edi                                              )
 
1050
 
 
1051
    AS2(    movzx edi, dl                                               )
 
1052
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1053
    AS2(    and   edi, 255                                              )
 
1054
    AS2(    xor   esi, edi                                              )
 
1055
 
 
1056
    AS2(    movd  mm2, esi                                              )
 
1057
 
 
1058
            /*
 
1059
            Put3 (edx) =
 
1060
                (Td4[get3, rs24] & 0xff000000) ^  h = 4278190080
 
1061
                (Td4[get2, rs16] & 0x00ff0000) ^  h =   16711680
 
1062
                (Td4[get1, rs 8] & 0x0000ff00) ^  h =      65280
 
1063
                (Td4[get0, rs 0] & 0x000000ff)    h =        255
 
1064
            */
 
1065
    AS2(    mov   esi, edx                                              )
 
1066
    AS2(    shr   esi, 24                                               )
 
1067
    AS2(    mov   edx, DWORD PTR [ebp + 4096 + esi*4]                   )
 
1068
    AS2(    and   edx, 4278190080                                       )
 
1069
 
 
1070
    AS2(    mov   edi, ecx                                              )
 
1071
    AS2(    shr   edi, 16                                               )
 
1072
    AS2(    and   edi, 255                                              )
 
1073
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1074
    AS2(    and   esi, 16711680                                         )
 
1075
    AS2(    xor   edx, esi                                              )
 
1076
 
 
1077
    AS2(    movzx esi, bh                                               )
 
1078
    AS2(    mov   edi, DWORD PTR [ebp + 4096 + esi*4]                   )
 
1079
    AS2(    and   edi, 65280                                            )
 
1080
    AS2(    xor   edx, edi                                              )
 
1081
 
 
1082
    AS2(    movzx edi, al                                               )
 
1083
    AS2(    mov   esi, DWORD PTR [ebp + 4096 + edi*4]                   )
 
1084
    AS2(    and   esi, 255                                              )
 
1085
    AS2(    xor   edx, esi                                              )
 
1086
 
 
1087
 
 
1088
            // xOr
 
1089
    AS2(    movd  esi, mm6                      )   //  rk
 
1090
    AS2(    add   esi, 16                                               )
 
1091
 
 
1092
    AS2(    movd   eax, mm0                                             )
 
1093
    AS2(    movd   ebx, mm1                                             )
 
1094
    AS2(    movd   ecx, mm2                                             )
 
1095
 
 
1096
    AS2(    xor   eax, DWORD PTR [esi]                                  )
 
1097
    AS2(    xor   ebx, DWORD PTR [esi +  4]                             )
 
1098
    AS2(    xor   ecx, DWORD PTR [esi +  8]                             )
 
1099
    AS2(    xor   edx, DWORD PTR [esi + 12]                             )
 
1100
 
 
1101
    // end
 
1102
    AS2(    movd  ebp, mm7                                              )
 
1103
 
 
1104
            // swap
 
1105
    AS1(    bswap eax                                                   )
 
1106
    AS1(    bswap ebx                                                   )
 
1107
    AS1(    bswap ecx                                                   )
 
1108
    AS1(    bswap edx                                                   )
 
1109
 
 
1110
            // store
 
1111
    #ifdef __GNUC__
 
1112
        AS2(    mov esi, DWORD PTR [ebp + 16]       )   //  outBlock
 
1113
    #else
 
1114
        AS2(    mov esi, DWORD PTR [ebp + 12]       )   //  outBlock
 
1115
    #endif
 
1116
    AS2(    mov DWORD PTR [esi],      eax                               )
 
1117
    AS2(    mov DWORD PTR [esi +  4], ebx                               )
 
1118
    AS2(    mov DWORD PTR [esi +  8], ecx                               )
 
1119
    AS2(    mov DWORD PTR [esi + 12], edx                               )
 
1120
 
 
1121
 
 
1122
    EPILOG()
 
1123
}
 
1124
 
 
1125
 
 
1126
 
 
1127
#endif // defined(DO_AES_ASM)
 
1128
 
 
1129
 
 
1130
 
 
1131
const word32 AES::Te[5][256] = {
 
1132
{
 
1133
    0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
 
1134
    0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
 
1135
    0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
 
1136
    0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
 
1137
    0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
 
1138
    0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
 
1139
    0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
 
1140
    0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
 
1141
    0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
 
1142
    0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
 
1143
    0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
 
1144
    0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
 
1145
    0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
 
1146
    0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
 
1147
    0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
 
1148
    0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
 
1149
    0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
 
1150
    0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
 
1151
    0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
 
1152
    0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
 
1153
    0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
 
1154
    0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
 
1155
    0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
 
1156
    0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
 
1157
    0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
 
1158
    0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
 
1159
    0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
 
1160
    0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
 
1161
    0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
 
1162
    0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
 
1163
    0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
 
1164
    0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
 
1165
    0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
 
1166
    0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
 
1167
    0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
 
1168
    0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
 
1169
    0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
 
1170
    0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
 
1171
    0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
 
1172
    0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
 
1173
    0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
 
1174
    0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
 
1175
    0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
 
1176
    0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
 
1177
    0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
 
1178
    0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
 
1179
    0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
 
1180
    0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
 
1181
    0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
 
1182
    0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
 
1183
    0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
 
1184
    0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
 
1185
    0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
 
1186
    0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
 
1187
    0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
 
1188
    0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
 
1189
    0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
 
1190
    0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
 
1191
    0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
 
1192
    0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
 
1193
    0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
 
1194
    0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
 
1195
    0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
 
1196
    0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
 
1197
},
 
1198
{
 
1199
    0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
 
1200
    0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,
 
1201
    0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,
 
1202
    0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,
 
1203
    0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,
 
1204
    0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,
 
1205
    0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,
 
1206
    0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,
 
1207
    0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,
 
1208
    0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,
 
1209
    0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,
 
1210
    0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,
 
1211
    0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,
 
1212
    0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,
 
1213
    0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,
 
1214
    0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,
 
1215
    0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,
 
1216
    0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,
 
1217
    0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,
 
1218
    0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,
 
1219
    0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,
 
1220
    0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,
 
1221
    0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,
 
1222
    0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,
 
1223
    0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,
 
1224
    0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,
 
1225
    0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,
 
1226
    0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,
 
1227
    0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,
 
1228
    0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,
 
1229
    0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,
 
1230
    0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,
 
1231
    0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,
 
1232
    0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,
 
1233
    0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,
 
1234
    0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,
 
1235
    0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,
 
1236
    0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,
 
1237
    0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,
 
1238
    0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,
 
1239
    0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,
 
1240
    0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,
 
1241
    0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,
 
1242
    0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,
 
1243
    0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,
 
1244
    0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,
 
1245
    0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,
 
1246
    0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,
 
1247
    0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,
 
1248
    0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,
 
1249
    0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,
 
1250
    0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,
 
1251
    0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,
 
1252
    0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,
 
1253
    0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,
 
1254
    0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,
 
1255
    0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,
 
1256
    0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,
 
1257
    0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,
 
1258
    0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,
 
1259
    0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,
 
1260
    0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,
 
1261
    0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,
 
1262
    0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
 
1263
},
 
1264
{
 
1265
    0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
 
1266
    0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
 
1267
    0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
 
1268
    0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,
 
1269
    0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,
 
1270
    0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,
 
1271
    0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,
 
1272
    0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,
 
1273
    0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,
 
1274
    0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,
 
1275
    0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,
 
1276
    0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,
 
1277
    0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,
 
1278
    0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,
 
1279
    0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,
 
1280
    0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,
 
1281
    0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,
 
1282
    0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,
 
1283
    0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,
 
1284
    0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,
 
1285
    0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,
 
1286
    0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,
 
1287
    0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,
 
1288
    0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,
 
1289
    0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,
 
1290
    0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,
 
1291
    0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,
 
1292
    0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,
 
1293
    0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,
 
1294
    0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,
 
1295
    0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,
 
1296
    0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,
 
1297
    0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,
 
1298
    0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,
 
1299
    0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,
 
1300
    0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,
 
1301
    0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,
 
1302
    0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,
 
1303
    0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,
 
1304
    0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,
 
1305
    0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,
 
1306
    0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,
 
1307
    0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,
 
1308
    0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,
 
1309
    0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,
 
1310
    0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,
 
1311
    0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,
 
1312
    0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,
 
1313
    0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,
 
1314
    0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,
 
1315
    0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,
 
1316
    0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,
 
1317
    0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,
 
1318
    0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,
 
1319
    0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,
 
1320
    0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,
 
1321
    0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,
 
1322
    0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,
 
1323
    0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,
 
1324
    0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,
 
1325
    0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,
 
1326
    0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,
 
1327
    0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,
 
1328
    0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,
 
1329
},
 
1330
{
 
1331
    0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,
 
1332
    0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,
 
1333
    0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,
 
1334
    0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,
 
1335
    0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,
 
1336
    0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,
 
1337
    0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,
 
1338
    0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,
 
1339
    0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,
 
1340
    0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,
 
1341
    0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,
 
1342
    0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,
 
1343
    0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,
 
1344
    0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,
 
1345
    0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,
 
1346
    0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,
 
1347
    0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,
 
1348
    0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,
 
1349
    0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,
 
1350
    0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,
 
1351
    0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,
 
1352
    0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,
 
1353
    0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,
 
1354
    0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,
 
1355
    0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,
 
1356
    0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,
 
1357
    0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,
 
1358
    0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,
 
1359
    0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,
 
1360
    0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,
 
1361
    0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,
 
1362
    0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,
 
1363
    0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,
 
1364
    0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,
 
1365
    0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,
 
1366
    0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,
 
1367
    0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,
 
1368
    0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,
 
1369
    0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,
 
1370
    0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,
 
1371
    0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,
 
1372
    0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,
 
1373
    0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,
 
1374
    0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,
 
1375
    0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,
 
1376
    0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,
 
1377
    0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,
 
1378
    0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,
 
1379
    0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,
 
1380
    0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,
 
1381
    0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,
 
1382
    0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,
 
1383
    0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,
 
1384
    0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,
 
1385
    0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,
 
1386
    0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,
 
1387
    0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,
 
1388
    0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,
 
1389
    0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,
 
1390
    0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,
 
1391
    0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,
 
1392
    0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,
 
1393
    0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,
 
1394
    0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,
 
1395
},
 
1396
{
 
1397
    0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
 
1398
    0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
 
1399
    0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
 
1400
    0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
 
1401
    0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
 
1402
    0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
 
1403
    0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
 
1404
    0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
 
1405
    0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
 
1406
    0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
 
1407
    0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
 
1408
    0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
 
1409
    0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
 
1410
    0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
 
1411
    0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
 
1412
    0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
 
1413
    0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
 
1414
    0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
 
1415
    0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
 
1416
    0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
 
1417
    0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
 
1418
    0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
 
1419
    0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
 
1420
    0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
 
1421
    0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
 
1422
    0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
 
1423
    0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
 
1424
    0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
 
1425
    0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
 
1426
    0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
 
1427
    0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
 
1428
    0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
 
1429
    0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
 
1430
    0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
 
1431
    0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
 
1432
    0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
 
1433
    0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
 
1434
    0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
 
1435
    0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
 
1436
    0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
 
1437
    0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
 
1438
    0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
 
1439
    0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
 
1440
    0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
 
1441
    0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
 
1442
    0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
 
1443
    0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
 
1444
    0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
 
1445
    0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
 
1446
    0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
 
1447
    0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
 
1448
    0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
 
1449
    0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
 
1450
    0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
 
1451
    0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
 
1452
    0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
 
1453
    0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
 
1454
    0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
 
1455
    0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
 
1456
    0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
 
1457
    0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
 
1458
    0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
 
1459
    0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
 
1460
    0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
 
1461
}
 
1462
};
 
1463
 
 
1464
 
 
1465
const word32 AES::Td[5][256] = {
 
1466
{
 
1467
    0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
 
1468
    0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
 
1469
    0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
 
1470
    0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
 
1471
    0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
 
1472
    0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
 
1473
    0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
 
1474
    0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
 
1475
    0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
 
1476
    0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
 
1477
    0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
 
1478
    0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
 
1479
    0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
 
1480
    0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
 
1481
    0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
 
1482
    0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
 
1483
    0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
 
1484
    0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
 
1485
    0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
 
1486
    0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
 
1487
    0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
 
1488
    0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
 
1489
    0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
 
1490
    0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
 
1491
    0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
 
1492
    0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
 
1493
    0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
 
1494
    0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
 
1495
    0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
 
1496
    0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
 
1497
    0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
 
1498
    0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
 
1499
    0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
 
1500
    0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
 
1501
    0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
 
1502
    0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
 
1503
    0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
 
1504
    0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
 
1505
    0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
 
1506
    0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
 
1507
    0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
 
1508
    0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
 
1509
    0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
 
1510
    0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
 
1511
    0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
 
1512
    0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
 
1513
    0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
 
1514
    0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
 
1515
    0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
 
1516
    0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
 
1517
    0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
 
1518
    0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
 
1519
    0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
 
1520
    0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
 
1521
    0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
 
1522
    0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
 
1523
    0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
 
1524
    0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
 
1525
    0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
 
1526
    0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
 
1527
    0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
 
1528
    0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
 
1529
    0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
 
1530
    0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
 
1531
},
 
1532
{
 
1533
    0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,
 
1534
    0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,
 
1535
    0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,
 
1536
    0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,
 
1537
    0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,
 
1538
    0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,
 
1539
    0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,
 
1540
    0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,
 
1541
    0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,
 
1542
    0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,
 
1543
    0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,
 
1544
    0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,
 
1545
    0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,
 
1546
    0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,
 
1547
    0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,
 
1548
    0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,
 
1549
    0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,
 
1550
    0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,
 
1551
    0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,
 
1552
    0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,
 
1553
    0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,
 
1554
    0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,
 
1555
    0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,
 
1556
    0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,
 
1557
    0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,
 
1558
    0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,
 
1559
    0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,
 
1560
    0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,
 
1561
    0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,
 
1562
    0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,
 
1563
    0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,
 
1564
    0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,
 
1565
    0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,
 
1566
    0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,
 
1567
    0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,
 
1568
    0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,
 
1569
    0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,
 
1570
    0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,
 
1571
    0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,
 
1572
    0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,
 
1573
    0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,
 
1574
    0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,
 
1575
    0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,
 
1576
    0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,
 
1577
    0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,
 
1578
    0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,
 
1579
    0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,
 
1580
    0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,
 
1581
    0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,
 
1582
    0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,
 
1583
    0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,
 
1584
    0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,
 
1585
    0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,
 
1586
    0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,
 
1587
    0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,
 
1588
    0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,
 
1589
    0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,
 
1590
    0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,
 
1591
    0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,
 
1592
    0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,
 
1593
    0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,
 
1594
    0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,
 
1595
    0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,
 
1596
    0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,
 
1597
},
 
1598
{
 
1599
    0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,
 
1600
    0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,
 
1601
    0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,
 
1602
    0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,
 
1603
    0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,
 
1604
    0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,
 
1605
    0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,
 
1606
    0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,
 
1607
    0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,
 
1608
    0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,
 
1609
    0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,
 
1610
    0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,
 
1611
    0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,
 
1612
    0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,
 
1613
    0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,
 
1614
    0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,
 
1615
    0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,
 
1616
    0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,
 
1617
    0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,
 
1618
    0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,
 
1619
 
 
1620
    0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,
 
1621
    0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,
 
1622
    0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,
 
1623
    0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,
 
1624
    0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,
 
1625
    0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,
 
1626
    0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,
 
1627
    0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,
 
1628
    0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,
 
1629
    0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,
 
1630
    0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,
 
1631
    0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,
 
1632
    0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,
 
1633
    0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,
 
1634
    0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,
 
1635
    0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,
 
1636
    0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,
 
1637
    0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,
 
1638
    0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,
 
1639
    0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,
 
1640
    0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,
 
1641
    0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,
 
1642
    0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,
 
1643
    0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,
 
1644
    0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,
 
1645
    0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,
 
1646
    0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,
 
1647
    0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,
 
1648
    0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,
 
1649
    0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,
 
1650
    0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,
 
1651
    0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,
 
1652
    0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,
 
1653
    0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,
 
1654
    0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,
 
1655
    0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,
 
1656
    0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,
 
1657
    0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,
 
1658
    0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,
 
1659
    0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,
 
1660
    0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,
 
1661
    0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,
 
1662
    0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,
 
1663
    0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,
 
1664
},
 
1665
{
 
1666
    0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,
 
1667
    0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,
 
1668
    0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,
 
1669
    0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,
 
1670
    0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,
 
1671
    0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,
 
1672
    0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,
 
1673
    0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,
 
1674
    0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,
 
1675
    0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,
 
1676
    0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,
 
1677
    0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,
 
1678
    0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,
 
1679
    0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,
 
1680
    0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,
 
1681
    0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,
 
1682
    0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,
 
1683
    0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,
 
1684
    0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,
 
1685
    0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,
 
1686
    0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,
 
1687
    0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,
 
1688
    0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,
 
1689
    0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,
 
1690
    0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,
 
1691
    0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,
 
1692
    0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,
 
1693
    0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,
 
1694
    0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,
 
1695
    0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,
 
1696
    0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,
 
1697
    0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,
 
1698
    0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,
 
1699
    0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,
 
1700
    0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,
 
1701
    0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,
 
1702
    0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,
 
1703
    0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,
 
1704
    0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,
 
1705
    0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,
 
1706
    0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,
 
1707
    0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,
 
1708
    0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,
 
1709
    0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,
 
1710
    0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,
 
1711
    0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,
 
1712
    0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,
 
1713
    0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,
 
1714
    0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,
 
1715
    0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,
 
1716
    0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,
 
1717
    0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,
 
1718
    0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,
 
1719
    0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,
 
1720
    0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,
 
1721
    0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,
 
1722
    0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,
 
1723
    0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,
 
1724
    0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,
 
1725
    0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,
 
1726
    0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,
 
1727
    0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,
 
1728
    0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,
 
1729
    0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,
 
1730
},
 
1731
{
 
1732
    0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,
 
1733
    0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,
 
1734
    0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,
 
1735
    0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,
 
1736
    0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,
 
1737
    0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,
 
1738
    0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,
 
1739
    0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,
 
1740
    0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,
 
1741
    0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,
 
1742
    0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,
 
1743
    0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,
 
1744
    0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,
 
1745
    0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,
 
1746
    0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,
 
1747
    0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,
 
1748
    0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,
 
1749
    0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,
 
1750
    0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,
 
1751
    0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,
 
1752
    0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,
 
1753
    0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,
 
1754
    0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,
 
1755
    0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,
 
1756
    0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,
 
1757
    0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,
 
1758
    0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,
 
1759
    0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,
 
1760
    0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,
 
1761
    0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,
 
1762
    0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,
 
1763
    0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,
 
1764
    0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,
 
1765
    0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,
 
1766
    0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,
 
1767
    0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,
 
1768
    0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,
 
1769
    0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,
 
1770
    0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,
 
1771
    0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,
 
1772
    0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,
 
1773
    0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,
 
1774
    0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,
 
1775
    0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,
 
1776
    0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,
 
1777
    0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,
 
1778
    0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,
 
1779
    0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,
 
1780
    0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,
 
1781
    0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,
 
1782
    0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,
 
1783
    0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,
 
1784
    0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,
 
1785
    0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,
 
1786
    0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,
 
1787
    0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,
 
1788
    0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,
 
1789
    0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,
 
1790
    0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,
 
1791
    0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,
 
1792
    0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,
 
1793
    0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,
 
1794
    0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,
 
1795
    0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
 
1796
}
 
1797
};
 
1798
 
 
1799
 
 
1800
const word32* AES::Te0 = AES::Te[0];
 
1801
const word32* AES::Te1 = AES::Te[1];
 
1802
const word32* AES::Te2 = AES::Te[2];
 
1803
const word32* AES::Te3 = AES::Te[3];
 
1804
const word32* AES::Te4 = AES::Te[4];
 
1805
 
 
1806
const word32* AES::Td0 = AES::Td[0];
 
1807
const word32* AES::Td1 = AES::Td[1];
 
1808
const word32* AES::Td2 = AES::Td[2];
 
1809
const word32* AES::Td3 = AES::Td[3];
 
1810
const word32* AES::Td4 = AES::Td[4];
 
1811
 
 
1812
 
 
1813
 
 
1814
} // namespace
 
1815