~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to camellia.cpp

  • Committer: weidai
  • Date: 2010-06-18 01:52:34 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:485
avoid SecBlock of arrays

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
// camellia.cpp - by Kevin Springle, 2003
2
2
// This code is hereby placed in the public domain.
3
3
 
 
4
/*
 
5
Optimisations and defense against timing attacks added in Jan 2007 by Wei Dai.
 
6
 
 
7
The first 2 rounds and the last round seem especially vulnerable to timing
 
8
attacks. The protection is similar to what was implemented for Rijndael.
 
9
See comments at top of rijndael.cpp for more details.
 
10
*/
 
11
 
4
12
#include "pch.h"
5
13
 
6
 
#ifdef WORD64_AVAILABLE
7
 
 
8
14
#include "camellia.h"
9
15
#include "misc.h"
 
16
#include "cpu.h"
10
17
 
11
18
NAMESPACE_BEGIN(CryptoPP)
12
19
 
13
 
// Define internal Camellia function macros
14
 
 
15
 
inline word64 Camellia::Base::F(word64 X)
16
 
{
17
 
        word32 t1 = (word32)(X >> 32);
18
 
        word32 t2 = (word32)(X & 0xFFFFFFFFL);
19
 
        t2=     (s2[GETBYTE(t2, 3)] << 24) |
20
 
                (s3[GETBYTE(t2, 2)] << 16) |
21
 
                (s4[GETBYTE(t2, 1)] <<  8) |
22
 
                (s1[GETBYTE(t2, 0)]);
23
 
        t1=     (s1[GETBYTE(t1, 3)] << 24) |
24
 
                (s2[GETBYTE(t1, 2)] << 16) |
25
 
                (s3[GETBYTE(t1, 1)] <<  8) |
26
 
                (s4[GETBYTE(t1, 0)]);
27
 
        t1 ^= rotlFixed(t2, 8);
28
 
        t2 ^= rotlFixed(t1, 16);
29
 
        t1 ^= rotlFixed(t2, 24);
30
 
        t2 ^= rotlFixed(t1, 24);
31
 
        return ((word64)t2 << 32) | (word64)t1;
32
 
}
33
 
 
34
 
#define ROUND2(Xp, K1, K2) \
35
 
        { (Xp)[1] ^= F((Xp)[0] ^ K1); (Xp)[0] ^= F((Xp)[1] ^ K2); }
36
 
 
37
 
inline void Camellia::Base::FLlayer(word64 *x, word64 K1, word64 K2)
38
 
{
39
 
        word32 Xl = (word32)(x[0] >> 32);
40
 
        word32 Xr = (word32)(x[0] & 0xFFFFFFFFL);
41
 
        Xr ^= rotlFixed(Xl & (word32)(K1 >> 32), 1);
42
 
        Xl ^= (Xr | (word32)(K1 & 0xFFFFFFFFL));
43
 
    x[0] = ((word64)Xl << 32) | (word64)Xr;
44
 
 
45
 
        Xl = (word32)(x[1] >> 32);
46
 
        Xr = (word32)(x[1] & 0xFFFFFFFFL);
47
 
        Xl ^= (Xr | (word32)(K2 & 0xFFFFFFFFL));
48
 
        Xr ^= rotlFixed(Xl & (word32)(K2 >> 32), 1);
49
 
    x[1] = ((word64)Xl << 32) | (word64)Xr;
50
 
}
51
 
 
52
 
inline void rotl128(word64 *x, unsigned int bits)
53
 
{
54
 
        word64 temp = x[0] >> (64 - bits);
55
 
        x[0] = (x[0] << bits) | (x[1] >> (64 - bits));
56
 
        x[1] = (x[1] << bits) | temp;
57
 
}
58
 
 
59
 
void Camellia::Base::UncheckedSetKey(CipherDir dir, const byte *key, unsigned int keylen)
60
 
{
61
 
        AssertValidKeyLength(keylen);
62
 
 
 
20
// round implementation that uses a small table for protection against timing attacks
 
21
#define SLOW_ROUND(lh, ll, rh, rl, kh, kl)      {                                                       \
 
22
        word32 zr = ll ^ kl;                                                                                            \
 
23
        word32 zl = lh ^ kh;                                                                                            \
 
24
        zr=     rotlFixed(s1[GETBYTE(zr, 3)], 1) |                                                              \
 
25
                (rotrFixed(s1[GETBYTE(zr, 2)], 1) << 24) |                                              \
 
26
                (s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zr, 1),1)] << 16) |             \
 
27
                (s1[GETBYTE(zr, 0)] << 8);                                                                              \
 
28
        zl=     (s1[GETBYTE(zl, 3)] << 24) |                                                                    \
 
29
                (rotlFixed(s1[GETBYTE(zl, 2)], 1) << 16) |                                              \
 
30
                (rotrFixed(s1[GETBYTE(zl, 1)], 1) << 8) |                                               \
 
31
                s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zl, 0), 1)];                             \
 
32
        zl ^= zr;                                                                                                                       \
 
33
        zr = zl ^ rotlFixed(zr, 8);                                                                                     \
 
34
        zl = zr ^ rotrFixed(zl, 8);                                                                                     \
 
35
        rh ^= rotlFixed(zr, 16);                                                                                        \
 
36
        rh ^= zl;                                                                                                                       \
 
37
        rl ^= rotlFixed(zl, 8);                                                                                         \
 
38
        }
 
39
 
 
40
// normal round - same output as above but using larger tables for faster speed
 
41
#define ROUND(lh, ll, rh, rl, kh, kl)   {       \
 
42
        word32 th = lh ^ kh;                                    \
 
43
        word32 tl = ll ^ kl;                                    \
 
44
        word32 d = SP[0][GETBYTE(tl,0)] ^ SP[1][GETBYTE(tl,3)] ^ SP[2][GETBYTE(tl,2)] ^ SP[3][GETBYTE(tl,1)];   \
 
45
        word32 u = SP[0][GETBYTE(th,3)] ^ SP[1][GETBYTE(th,2)] ^ SP[2][GETBYTE(th,1)] ^ SP[3][GETBYTE(th,0)];   \
 
46
        d ^= u;                                                                 \
 
47
        rh ^= d;                                                                \
 
48
        rl ^= d;                                                                \
 
49
        rl ^= rotrFixed(u, 8);}
 
50
 
 
51
#define DOUBLE_ROUND(lh, ll, rh, rl, k0, k1, k2, k3)    \
 
52
        ROUND(lh, ll, rh, rl, k0, k1)                                           \
 
53
        ROUND(rh, rl, lh, ll, k2, k3)
 
54
 
 
55
#ifdef IS_LITTLE_ENDIAN
 
56
#define EFI(i) (1-(i))
 
57
#else
 
58
#define EFI(i) (i)
 
59
#endif
 
60
 
 
61
void Camellia::Base::UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs &)
 
62
{
63
63
        m_rounds = (keylen >= 24) ? 4 : 3;
64
64
        unsigned int kslen = (8 * m_rounds + 2);
65
 
        m_key.New(8 * kslen);
66
 
        word64 *ks = m_key;
67
 
 
68
 
        FixedSizeSecBlock<word64, 32> keyword;
69
 
        word64 *kw = keyword;
70
 
 
71
 
#define KL      (kw+0)
72
 
#define KR      (kw+2)
73
 
#define KA      (kw+4)
74
 
#define KB      (kw+6)
 
65
        m_key.New(kslen*2);
 
66
        word32 *ks32 = m_key.data();
 
67
        int m=0, a=0;
 
68
        if (!IsForwardTransformation())
 
69
                m = -1, a = kslen-1;
 
70
 
 
71
        word32 kl0, kl1, kl2, kl3;
 
72
        GetBlock<word32, BigEndian> getBlock(key);
 
73
        getBlock(kl0)(kl1)(kl2)(kl3);
 
74
        word32 k0=kl0, k1=kl1, k2=kl2, k3=kl3;
 
75
 
 
76
#define CALC_ADDR2(base, i, j)  ((byte *)(base)+8*(i)+4*(j)+((-16*(i))&m))
 
77
#define CALC_ADDR(base, i)      CALC_ADDR2(base, i, 0)
 
78
 
 
79
#if 1
 
80
        word64 kwl, kwr;
 
81
        ks32 += 2*a;
 
82
#define PREPARE_KS_ROUNDS                       \
 
83
        kwl = (word64(k0) << 32) | k1;  \
 
84
        kwr = (word64(k2) << 32) | k3
 
85
#define KS_ROUND_0(i)                                                   \
 
86
        *(word64*)CALC_ADDR(ks32, i+EFI(0)) = kwl;      \
 
87
        *(word64*)CALC_ADDR(ks32, i+EFI(1)) = kwr
 
88
#define KS_ROUND(i, r, which)                                                                                                                                                                           \
 
89
        if (which & (1<<int(r<64))) *(word64*)CALC_ADDR(ks32, i+EFI(r<64)) = (kwr << (r%64)) | (kwl >> (64 - (r%64)));  \
 
90
        if (which & (1<<int(r>64))) *(word64*)CALC_ADDR(ks32, i+EFI(r>64)) = (kwl << (r%64)) | (kwr >> (64 - (r%64)))
 
91
#else
 
92
        // SSE2 version is 30% faster on Intel Core 2. Doesn't seem worth the hassle of maintenance, but left here
 
93
        // #if'd out in case someone needs it.
 
94
        __m128i kw, kw2;
 
95
        __m128i *ks128 = (__m128i *)ks32+a/2;
 
96
        ks32 += 2*a;
 
97
#define PREPARE_KS_ROUNDS                                                                                                       \
 
98
        kw = _mm_set_epi32(k0, k1, k2, k3);                                                                             \
 
99
        if (m) kw2 = kw, kw = _mm_shuffle_epi32(kw, _MM_SHUFFLE(1, 0, 3, 2));   \
 
100
        else kw2 = _mm_shuffle_epi32(kw, _MM_SHUFFLE(1, 0, 3, 2))
 
101
#define KS_ROUND_0(i)                                                                           \
 
102
        _mm_store_si128((__m128i *)CALC_ADDR(ks128, i), kw)
 
103
#define KS_ROUND(i, r, which)   {                                                                                                                                                               \
 
104
        __m128i temp;                                                                                                                                                                                           \
 
105
        if (r<64 && (which!=1 || m)) temp = _mm_or_si128(_mm_slli_epi64(kw, r%64), _mm_srli_epi64(kw2, 64-r%64));       \
 
106
        else temp = _mm_or_si128(_mm_slli_epi64(kw2, r%64), _mm_srli_epi64(kw, 64-r%64));                                                       \
 
107
        if (which & 2) _mm_store_si128((__m128i *)CALC_ADDR(ks128, i), temp);                                                                           \
 
108
        else _mm_storel_epi64((__m128i*)CALC_ADDR(ks32, i+EFI(0)), temp);                                                                                       \
 
109
        }
 
110
#endif
75
111
 
76
112
        if (keylen == 16)
77
113
        {
78
 
                GetUserKey(BIG_ENDIAN_ORDER, kw, 2, key, keylen);
79
 
                KA[0] = KL[0];
80
 
                KA[1] = KL[1];
 
114
                // KL
 
115
                PREPARE_KS_ROUNDS;
 
116
                KS_ROUND_0(0);
 
117
                KS_ROUND(4, 15, 3);
 
118
                KS_ROUND(10, 45, 3);
 
119
                KS_ROUND(12, 60, 2);
 
120
                KS_ROUND(16, 77, 3);
 
121
                KS_ROUND(18, 94, 3);
 
122
                KS_ROUND(22, 111, 3);
 
123
 
 
124
                // KA
 
125
                k0=kl0, k1=kl1, k2=kl2, k3=kl3;
 
126
                DOUBLE_ROUND(k0, k1, k2, k3, 0xA09E667Ful, 0x3BCC908Bul, 0xB67AE858ul, 0x4CAA73B2ul);
 
127
                k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
 
128
                DOUBLE_ROUND(k0, k1, k2, k3, 0xC6EF372Ful, 0xE94F82BEul, 0x54FF53A5ul, 0xF1D36F1Cul);
 
129
 
 
130
                PREPARE_KS_ROUNDS;
 
131
                KS_ROUND_0(2);
 
132
                KS_ROUND(6, 15, 3);
 
133
                KS_ROUND(8, 30, 3);
 
134
                KS_ROUND(12, 45, 1);
 
135
                KS_ROUND(14, 60, 3);
 
136
                KS_ROUND(20, 94, 3);
 
137
                KS_ROUND(24, 47, 3);
81
138
        }
82
139
        else
83
140
        {
 
141
                // KL
 
142
                PREPARE_KS_ROUNDS;
 
143
                KS_ROUND_0(0);
 
144
                KS_ROUND(12, 45, 3);
 
145
                KS_ROUND(16, 60, 3);
 
146
                KS_ROUND(22, 77, 3);
 
147
                KS_ROUND(30, 111, 3);
 
148
 
 
149
                // KR
 
150
                word32 kr0, kr1, kr2, kr3;
 
151
                GetBlock<word32, BigEndian>(key+16)(kr0)(kr1);
84
152
                if (keylen == 24)
85
 
                {
86
 
                        GetUserKey(BIG_ENDIAN_ORDER, kw, 3, key, keylen);
87
 
                        KR[1] = ~KR[0];
88
 
                }
 
153
                        kr2 = ~kr0, kr3 = ~kr1;
89
154
                else
90
 
                {
91
 
                        GetUserKey(BIG_ENDIAN_ORDER, kw, 4, key, keylen);
92
 
                }
93
 
                KA[0] = KL[0] ^ KR[0];
94
 
                KA[1] = KL[1] ^ KR[1];
95
 
        }
96
 
        ROUND2(KA, W64LIT(0xA09E667F3BCC908B), W64LIT(0xB67AE8584CAA73B2));
97
 
        KA[0] ^= KL[0];
98
 
        KA[1] ^= KL[1];
99
 
        ROUND2(KA, W64LIT(0xC6EF372FE94F82BE), W64LIT(0x54FF53A5F1D36F1C));
100
 
 
101
 
        if (keylen == 16)
102
 
        {
103
 
                ks[0] = KL[0]; ks[1] = KL[1];
104
 
                rotl128(KL, 15);
105
 
                ks[4] = KL[0]; ks[5] = KL[1];
106
 
                rotl128(KL, 30);
107
 
                ks[10] = KL[0]; ks[11] = KL[1];
108
 
                rotl128(KL, 15);
109
 
                ks[13] = KL[1];
110
 
                rotl128(KL, 17);
111
 
                ks[16] = KL[0]; ks[17] = KL[1];
112
 
                rotl128(KL, 17);
113
 
                ks[18] = KL[0]; ks[19] = KL[1];
114
 
                rotl128(KL, 17);
115
 
                ks[22] = KL[0]; ks[23] = KL[1];
116
 
 
117
 
                ks[2] = KA[0]; ks[3] = KA[1];
118
 
                rotl128(KA, 15);
119
 
                ks[6] = KA[0]; ks[7] = KA[1];
120
 
                rotl128(KA, 15);
121
 
                ks[8] = KA[0]; ks[9] = KA[1];
122
 
                rotl128(KA, 15);
123
 
                ks[12] = KA[0];
124
 
                rotl128(KA, 15);
125
 
                ks[14] = KA[0]; ks[15] = KA[1];
126
 
                rotl128(KA, 34);
127
 
                ks[20] = KA[0]; ks[21] = KA[1];
128
 
                rotl128(KA, 17);
129
 
                ks[24] = KA[0]; ks[25] = KA[1];
130
 
        }
131
 
        else
132
 
        {
133
 
                KB[0] = KA[0] ^ KR[0];
134
 
                KB[1] = KA[1] ^ KR[1];
135
 
                ROUND2(KB, W64LIT(0x10E527FADE682D1D), W64LIT(0xB05688C2B3E6C1FD));
136
 
 
137
 
                ks[0] = KL[0]; ks[1] = KL[1];
138
 
                rotl128(KL, 45);
139
 
                ks[12] = KL[0]; ks[13] = KL[1];
140
 
                rotl128(KL, 15);
141
 
                ks[16] = KL[0]; ks[17] = KL[1];
142
 
                rotl128(KL, 17);
143
 
                ks[22] = KL[0]; ks[23] = KL[1];
144
 
                rotl128(KL, 34);
145
 
                ks[30] = KL[0]; ks[31] = KL[1];
146
 
 
147
 
                rotl128(KR, 15);
148
 
                ks[4] = KR[0]; ks[5] = KR[1];
149
 
                rotl128(KR, 15);
150
 
                ks[8] = KR[0]; ks[9] = KR[1];
151
 
                rotl128(KR, 30);
152
 
                ks[18] = KR[0]; ks[19] = KR[1];
153
 
                rotl128(KR, 34);
154
 
                ks[26] = KR[0]; ks[27] = KR[1];
155
 
 
156
 
                rotl128(KA, 15);
157
 
                ks[6] = KA[0]; ks[7] = KA[1];
158
 
                rotl128(KA, 30);
159
 
                ks[14] = KA[0]; ks[15] = KA[1];
160
 
                rotl128(KA, 32);
161
 
                ks[24] = KA[0]; ks[25] = KA[1];
162
 
                rotl128(KA, 17);
163
 
                ks[28] = KA[0]; ks[29] = KA[1];
164
 
 
165
 
                ks[2] = KB[0]; ks[3] = KB[1];
166
 
                rotl128(KB, 30);
167
 
                ks[10] = KB[0]; ks[11] = KB[1];
168
 
                rotl128(KB, 30);
169
 
                ks[20] = KB[0]; ks[21] = KB[1];
170
 
                rotl128(KB, 51);
171
 
                ks[32] = KB[0]; ks[33] = KB[1];
172
 
        }
173
 
 
174
 
        if (dir == DECRYPTION)  // reverse key schedule order
175
 
        {
176
 
                std::swap(ks[0], ks[kslen-2]);
177
 
                std::swap(ks[1], ks[kslen-1]);
178
 
                for (unsigned int i=2; i<kslen/2; i++)
179
 
                {
180
 
                        std::swap(ks[i], ks[kslen-1-i]);
181
 
                }
 
155
                        GetBlock<word32, BigEndian>(key+24)(kr2)(kr3);
 
156
                k0=kr0, k1=kr1, k2=kr2, k3=kr3;
 
157
 
 
158
                PREPARE_KS_ROUNDS;
 
159
                KS_ROUND(4, 15, 3);
 
160
                KS_ROUND(8, 30, 3);
 
161
                KS_ROUND(18, 60, 3);
 
162
                KS_ROUND(26, 94, 3);
 
163
 
 
164
                // KA
 
165
                k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
 
166
                DOUBLE_ROUND(k0, k1, k2, k3, 0xA09E667Ful, 0x3BCC908Bul, 0xB67AE858ul, 0x4CAA73B2ul);
 
167
                k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
 
168
                DOUBLE_ROUND(k0, k1, k2, k3, 0xC6EF372Ful, 0xE94F82BEul, 0x54FF53A5ul, 0xF1D36F1Cul);
 
169
 
 
170
                PREPARE_KS_ROUNDS;
 
171
                KS_ROUND(6, 15, 3);
 
172
                KS_ROUND(14, 45, 3);
 
173
                KS_ROUND(24, 77, 3);
 
174
                KS_ROUND(28, 94, 3);
 
175
 
 
176
                // KB
 
177
                k0^=kr0, k1^=kr1, k2^=kr2, k3^=kr3;
 
178
                DOUBLE_ROUND(k0, k1, k2, k3, 0x10E527FAul, 0xDE682D1Dul, 0xB05688C2ul, 0xB3E6C1FDul);
 
179
 
 
180
                PREPARE_KS_ROUNDS;
 
181
                KS_ROUND_0(2);
 
182
                KS_ROUND(10, 30, 3);
 
183
                KS_ROUND(20, 60, 3);
 
184
                KS_ROUND(32, 47, 3);
182
185
        }
183
186
}
184
187
 
185
 
typedef BlockGetAndPut<word64, BigEndian> Block;
186
 
 
187
188
void Camellia::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
188
189
{
189
 
        FixedSizeSecBlock<word64, 16> mb;
190
 
        word64 *m = mb;
191
 
        const word64 *ks = m_key;
192
 
 
193
 
        Block::Get(inBlock)(m[0])(m[1]);
194
 
 
195
 
        m[0] ^= ks[0];
196
 
        m[1] ^= ks[1];
197
 
        ks += 2;
198
 
        for (unsigned int i = m_rounds; i > 0; --i)
 
190
#define KS(i, j) ks[i*4 + EFI(j/2)*2 + EFI(j%2)]
 
191
 
 
192
#define FL(klh, kll, krh, krl)          \
 
193
        ll ^= rotlFixed(lh & klh, 1);   \
 
194
        lh ^= (ll | kll);                               \
 
195
        rh ^= (rl | krl);                               \
 
196
        rl ^= rotlFixed(rh & krh, 1);
 
197
 
 
198
        word32 lh, ll, rh, rl;
 
199
        typedef BlockGetAndPut<word32, BigEndian> Block;
 
200
        Block::Get(inBlock)(lh)(ll)(rh)(rl);
 
201
        const word32 *ks = m_key.data();
 
202
        lh ^= KS(0,0);
 
203
        ll ^= KS(0,1);
 
204
        rh ^= KS(0,2);
 
205
        rl ^= KS(0,3);
 
206
 
 
207
        // timing attack countermeasure. see comments at top for more details
 
208
        const int cacheLineSize = GetCacheLineSize();
 
209
        unsigned int i;
 
210
        word32 u = 0;
 
211
        for (i=0; i<256; i+=cacheLineSize)
 
212
                u &= *(const word32 *)(s1+i);
 
213
        u &= *(const word32 *)(s1+252);
 
214
        lh |= u; ll |= u;
 
215
 
 
216
        SLOW_ROUND(lh, ll, rh, rl, KS(1,0), KS(1,1))
 
217
        SLOW_ROUND(rh, rl, lh, ll, KS(1,2), KS(1,3))
 
218
        for (i = m_rounds-1; i > 0; --i)
199
219
        {
200
 
                ROUND2(m, ks[0], ks[1]);
201
 
                ROUND2(m, ks[2], ks[3]);
202
 
                ROUND2(m, ks[4], ks[5]);
203
 
                if (i != 1)
204
 
                {
205
 
                        FLlayer(m, ks[6], ks[7]);
206
 
                        ks += 8;
207
 
                }
208
 
                else
209
 
                {
210
 
                        m[0] ^= ks[7];
211
 
                        m[1] ^= ks[6];
212
 
                }
 
220
                DOUBLE_ROUND(lh, ll, rh, rl, KS(2,0), KS(2,1), KS(2,2), KS(2,3))
 
221
                DOUBLE_ROUND(lh, ll, rh, rl, KS(3,0), KS(3,1), KS(3,2), KS(3,3))
 
222
                FL(KS(4,0), KS(4,1), KS(4,2), KS(4,3));
 
223
                DOUBLE_ROUND(lh, ll, rh, rl, KS(5,0), KS(5,1), KS(5,2), KS(5,3))
 
224
                ks += 16;
213
225
        }
214
 
 
215
 
        Block::Put(xorBlock, outBlock)(m[1])(m[0]);
 
226
        DOUBLE_ROUND(lh, ll, rh, rl, KS(2,0), KS(2,1), KS(2,2), KS(2,3))
 
227
        ROUND(lh, ll, rh, rl, KS(3,0), KS(3,1))
 
228
        SLOW_ROUND(rh, rl, lh, ll, KS(3,2), KS(3,3))
 
229
        lh ^= KS(4,0);
 
230
        ll ^= KS(4,1);
 
231
        rh ^= KS(4,2);
 
232
        rl ^= KS(4,3);
 
233
        Block::Put(xorBlock, outBlock)(rh)(rl)(lh)(ll);
216
234
}
217
235
 
218
236
// The Camellia s-boxes
237
255
        64,40,211,123,187,201,67,193,21,227,173,244,119,199,128,158
238
256
};
239
257
 
240
 
const byte Camellia::Base::s2[256] =
241
 
{
242
 
        224,5,88,217,103,78,129,203,201,11,174,106,213,24,93,130,
243
 
        70,223,214,39,138,50,75,66,219,28,158,156,58,202,37,123,
244
 
        13,113,95,31,248,215,62,157,124,96,185,190,188,139,22,52,
245
 
        77,195,114,149,171,142,186,122,179,2,180,173,162,172,216,154,
246
 
        23,26,53,204,247,153,97,90,232,36,86,64,225,99,9,51,
247
 
        191,152,151,133,104,252,236,10,218,111,83,98,163,46,8,175,
248
 
        40,176,116,194,189,54,34,56,100,30,57,44,166,48,229,68,
249
 
        253,136,159,101,135,107,244,35,72,16,209,81,192,249,210,160,
250
 
        85,161,65,250,67,19,196,47,168,182,60,43,193,255,200,165,
251
 
        32,137,0,144,71,239,234,183,21,6,205,181,18,126,187,41,
252
 
        15,184,7,4,155,148,33,102,230,206,237,231,59,254,127,197,
253
 
        164,55,177,76,145,110,141,118,3,45,222,150,38,125,198,92,
254
 
        211,242,79,25,63,220,121,29,82,235,243,109,94,251,105,178,
255
 
        240,49,12,212,207,140,226,117,169,74,87,132,17,69,27,245,
256
 
        228,14,115,170,241,221,89,20,108,146,84,208,120,112,227,73,
257
 
        128,80,167,246,119,147,134,131,42,199,91,233,238,143,1,61
258
 
};
259
 
 
260
 
const byte Camellia::Base::s3[256] =
261
 
{
262
 
        56,65,22,118,217,147,96,242,114,194,171,154,117,6,87,160,
263
 
        145,247,181,201,162,140,210,144,246,7,167,39,142,178,73,222,
264
 
        67,92,215,199,62,245,143,103,31,24,110,175,47,226,133,13,
265
 
        83,240,156,101,234,163,174,158,236,128,45,107,168,43,54,166,
266
 
        197,134,77,51,253,102,88,150,58,9,149,16,120,216,66,204,
267
 
        239,38,229,97,26,63,59,130,182,219,212,152,232,139,2,235,
268
 
        10,44,29,176,111,141,136,14,25,135,78,11,169,12,121,17,
269
 
        127,34,231,89,225,218,61,200,18,4,116,84,48,126,180,40,
270
 
        85,104,80,190,208,196,49,203,42,173,15,202,112,255,50,105,
271
 
        8,98,0,36,209,251,186,237,69,129,115,109,132,159,238,74,
272
 
        195,46,193,1,230,37,72,153,185,179,123,249,206,191,223,113,
273
 
        41,205,108,19,100,155,99,157,192,75,183,165,137,95,177,23,
274
 
        244,188,211,70,207,55,94,71,148,250,252,91,151,254,90,172,
275
 
        60,76,3,53,243,35,184,93,106,146,213,33,68,81,198,125,
276
 
        57,131,220,170,124,119,86,5,27,164,21,52,30,28,248,82,
277
 
        32,20,233,189,221,228,161,224,138,241,214,122,187,227,64,79
278
 
};
279
 
 
280
 
const byte Camellia::Base::s4[256] =
281
 
{
282
 
        112,44,179,192,228,87,234,174,35,107,69,165,237,79,29,146,
283
 
        134,175,124,31,62,220,94,11,166,57,213,93,217,90,81,108,
284
 
        139,154,251,176,116,43,240,132,223,203,52,118,109,169,209,4,
285
 
        20,58,222,17,50,156,83,242,254,207,195,122,36,232,96,105,
286
 
        170,160,161,98,84,30,224,100,16,0,163,117,138,230,9,221,
287
 
        135,131,205,144,115,246,157,191,82,216,200,198,129,111,19,99,
288
 
        233,167,159,188,41,249,47,180,120,6,231,113,212,171,136,141,
289
 
        114,185,248,172,54,42,60,241,64,211,187,67,21,173,119,128,
290
 
        130,236,39,229,133,53,12,65,239,147,25,33,14,78,101,189,
291
 
        184,143,235,206,48,95,197,26,225,202,71,61,1,214,86,77,
292
 
        13,102,204,45,18,32,177,153,76,194,126,5,183,49,23,215,
293
 
        88,97,27,28,15,22,24,34,68,178,181,145,8,168,252,80,
294
 
        208,125,137,151,91,149,255,210,196,72,247,219,3,218,63,148,
295
 
        92,2,74,51,103,243,127,226,155,38,55,59,150,75,190,46,
296
 
        121,140,110,142,245,182,253,89,152,106,70,186,37,66,162,250,
297
 
        7,85,238,10,73,104,56,164,40,123,201,193,227,244,199,158
298
 
};
 
258
const word32 Camellia::Base::SP[4][256] = {
 
259
        {
 
260
        0x70707000, 0x82828200, 0x2c2c2c00, 0xececec00,
 
261
        0xb3b3b300, 0x27272700, 0xc0c0c000, 0xe5e5e500,
 
262
        0xe4e4e400, 0x85858500, 0x57575700, 0x35353500,
 
263
        0xeaeaea00, 0x0c0c0c00, 0xaeaeae00, 0x41414100,
 
264
        0x23232300, 0xefefef00, 0x6b6b6b00, 0x93939300,
 
265
        0x45454500, 0x19191900, 0xa5a5a500, 0x21212100,
 
266
        0xededed00, 0x0e0e0e00, 0x4f4f4f00, 0x4e4e4e00,
 
267
        0x1d1d1d00, 0x65656500, 0x92929200, 0xbdbdbd00,
 
268
        0x86868600, 0xb8b8b800, 0xafafaf00, 0x8f8f8f00,
 
269
        0x7c7c7c00, 0xebebeb00, 0x1f1f1f00, 0xcecece00,
 
270
        0x3e3e3e00, 0x30303000, 0xdcdcdc00, 0x5f5f5f00,
 
271
        0x5e5e5e00, 0xc5c5c500, 0x0b0b0b00, 0x1a1a1a00,
 
272
        0xa6a6a600, 0xe1e1e100, 0x39393900, 0xcacaca00,
 
273
        0xd5d5d500, 0x47474700, 0x5d5d5d00, 0x3d3d3d00,
 
274
        0xd9d9d900, 0x01010100, 0x5a5a5a00, 0xd6d6d600,
 
275
        0x51515100, 0x56565600, 0x6c6c6c00, 0x4d4d4d00,
 
276
        0x8b8b8b00, 0x0d0d0d00, 0x9a9a9a00, 0x66666600,
 
277
        0xfbfbfb00, 0xcccccc00, 0xb0b0b000, 0x2d2d2d00,
 
278
        0x74747400, 0x12121200, 0x2b2b2b00, 0x20202000,
 
279
        0xf0f0f000, 0xb1b1b100, 0x84848400, 0x99999900,
 
280
        0xdfdfdf00, 0x4c4c4c00, 0xcbcbcb00, 0xc2c2c200,
 
281
        0x34343400, 0x7e7e7e00, 0x76767600, 0x05050500,
 
282
        0x6d6d6d00, 0xb7b7b700, 0xa9a9a900, 0x31313100,
 
283
        0xd1d1d100, 0x17171700, 0x04040400, 0xd7d7d700,
 
284
        0x14141400, 0x58585800, 0x3a3a3a00, 0x61616100,
 
285
        0xdedede00, 0x1b1b1b00, 0x11111100, 0x1c1c1c00,
 
286
        0x32323200, 0x0f0f0f00, 0x9c9c9c00, 0x16161600,
 
287
        0x53535300, 0x18181800, 0xf2f2f200, 0x22222200,
 
288
        0xfefefe00, 0x44444400, 0xcfcfcf00, 0xb2b2b200,
 
289
        0xc3c3c300, 0xb5b5b500, 0x7a7a7a00, 0x91919100,
 
290
        0x24242400, 0x08080800, 0xe8e8e800, 0xa8a8a800,
 
291
        0x60606000, 0xfcfcfc00, 0x69696900, 0x50505000,
 
292
        0xaaaaaa00, 0xd0d0d000, 0xa0a0a000, 0x7d7d7d00,
 
293
        0xa1a1a100, 0x89898900, 0x62626200, 0x97979700,
 
294
        0x54545400, 0x5b5b5b00, 0x1e1e1e00, 0x95959500,
 
295
        0xe0e0e000, 0xffffff00, 0x64646400, 0xd2d2d200,
 
296
        0x10101000, 0xc4c4c400, 0x00000000, 0x48484800,
 
297
        0xa3a3a300, 0xf7f7f700, 0x75757500, 0xdbdbdb00,
 
298
        0x8a8a8a00, 0x03030300, 0xe6e6e600, 0xdadada00,
 
299
        0x09090900, 0x3f3f3f00, 0xdddddd00, 0x94949400,
 
300
        0x87878700, 0x5c5c5c00, 0x83838300, 0x02020200,
 
301
        0xcdcdcd00, 0x4a4a4a00, 0x90909000, 0x33333300,
 
302
        0x73737300, 0x67676700, 0xf6f6f600, 0xf3f3f300,
 
303
        0x9d9d9d00, 0x7f7f7f00, 0xbfbfbf00, 0xe2e2e200,
 
304
        0x52525200, 0x9b9b9b00, 0xd8d8d800, 0x26262600,
 
305
        0xc8c8c800, 0x37373700, 0xc6c6c600, 0x3b3b3b00,
 
306
        0x81818100, 0x96969600, 0x6f6f6f00, 0x4b4b4b00,
 
307
        0x13131300, 0xbebebe00, 0x63636300, 0x2e2e2e00,
 
308
        0xe9e9e900, 0x79797900, 0xa7a7a700, 0x8c8c8c00,
 
309
        0x9f9f9f00, 0x6e6e6e00, 0xbcbcbc00, 0x8e8e8e00,
 
310
        0x29292900, 0xf5f5f500, 0xf9f9f900, 0xb6b6b600,
 
311
        0x2f2f2f00, 0xfdfdfd00, 0xb4b4b400, 0x59595900,
 
312
        0x78787800, 0x98989800, 0x06060600, 0x6a6a6a00,
 
313
        0xe7e7e700, 0x46464600, 0x71717100, 0xbababa00,
 
314
        0xd4d4d400, 0x25252500, 0xababab00, 0x42424200,
 
315
        0x88888800, 0xa2a2a200, 0x8d8d8d00, 0xfafafa00,
 
316
        0x72727200, 0x07070700, 0xb9b9b900, 0x55555500,
 
317
        0xf8f8f800, 0xeeeeee00, 0xacacac00, 0x0a0a0a00,
 
318
        0x36363600, 0x49494900, 0x2a2a2a00, 0x68686800,
 
319
        0x3c3c3c00, 0x38383800, 0xf1f1f100, 0xa4a4a400,
 
320
        0x40404000, 0x28282800, 0xd3d3d300, 0x7b7b7b00,
 
321
        0xbbbbbb00, 0xc9c9c900, 0x43434300, 0xc1c1c100,
 
322
        0x15151500, 0xe3e3e300, 0xadadad00, 0xf4f4f400,
 
323
        0x77777700, 0xc7c7c700, 0x80808000, 0x9e9e9e00
 
324
        },
 
325
        {
 
326
        0x00e0e0e0, 0x00050505, 0x00585858, 0x00d9d9d9,
 
327
        0x00676767, 0x004e4e4e, 0x00818181, 0x00cbcbcb,
 
328
        0x00c9c9c9, 0x000b0b0b, 0x00aeaeae, 0x006a6a6a,
 
329
        0x00d5d5d5, 0x00181818, 0x005d5d5d, 0x00828282,
 
330
        0x00464646, 0x00dfdfdf, 0x00d6d6d6, 0x00272727,
 
331
        0x008a8a8a, 0x00323232, 0x004b4b4b, 0x00424242,
 
332
        0x00dbdbdb, 0x001c1c1c, 0x009e9e9e, 0x009c9c9c,
 
333
        0x003a3a3a, 0x00cacaca, 0x00252525, 0x007b7b7b,
 
334
        0x000d0d0d, 0x00717171, 0x005f5f5f, 0x001f1f1f,
 
335
        0x00f8f8f8, 0x00d7d7d7, 0x003e3e3e, 0x009d9d9d,
 
336
        0x007c7c7c, 0x00606060, 0x00b9b9b9, 0x00bebebe,
 
337
        0x00bcbcbc, 0x008b8b8b, 0x00161616, 0x00343434,
 
338
        0x004d4d4d, 0x00c3c3c3, 0x00727272, 0x00959595,
 
339
        0x00ababab, 0x008e8e8e, 0x00bababa, 0x007a7a7a,
 
340
        0x00b3b3b3, 0x00020202, 0x00b4b4b4, 0x00adadad,
 
341
        0x00a2a2a2, 0x00acacac, 0x00d8d8d8, 0x009a9a9a,
 
342
        0x00171717, 0x001a1a1a, 0x00353535, 0x00cccccc,
 
343
        0x00f7f7f7, 0x00999999, 0x00616161, 0x005a5a5a,
 
344
        0x00e8e8e8, 0x00242424, 0x00565656, 0x00404040,
 
345
        0x00e1e1e1, 0x00636363, 0x00090909, 0x00333333,
 
346
        0x00bfbfbf, 0x00989898, 0x00979797, 0x00858585,
 
347
        0x00686868, 0x00fcfcfc, 0x00ececec, 0x000a0a0a,
 
348
        0x00dadada, 0x006f6f6f, 0x00535353, 0x00626262,
 
349
        0x00a3a3a3, 0x002e2e2e, 0x00080808, 0x00afafaf,
 
350
        0x00282828, 0x00b0b0b0, 0x00747474, 0x00c2c2c2,
 
351
        0x00bdbdbd, 0x00363636, 0x00222222, 0x00383838,
 
352
        0x00646464, 0x001e1e1e, 0x00393939, 0x002c2c2c,
 
353
        0x00a6a6a6, 0x00303030, 0x00e5e5e5, 0x00444444,
 
354
        0x00fdfdfd, 0x00888888, 0x009f9f9f, 0x00656565,
 
355
        0x00878787, 0x006b6b6b, 0x00f4f4f4, 0x00232323,
 
356
        0x00484848, 0x00101010, 0x00d1d1d1, 0x00515151,
 
357
        0x00c0c0c0, 0x00f9f9f9, 0x00d2d2d2, 0x00a0a0a0,
 
358
        0x00555555, 0x00a1a1a1, 0x00414141, 0x00fafafa,
 
359
        0x00434343, 0x00131313, 0x00c4c4c4, 0x002f2f2f,
 
360
        0x00a8a8a8, 0x00b6b6b6, 0x003c3c3c, 0x002b2b2b,
 
361
        0x00c1c1c1, 0x00ffffff, 0x00c8c8c8, 0x00a5a5a5,
 
362
        0x00202020, 0x00898989, 0x00000000, 0x00909090,
 
363
        0x00474747, 0x00efefef, 0x00eaeaea, 0x00b7b7b7,
 
364
        0x00151515, 0x00060606, 0x00cdcdcd, 0x00b5b5b5,
 
365
        0x00121212, 0x007e7e7e, 0x00bbbbbb, 0x00292929,
 
366
        0x000f0f0f, 0x00b8b8b8, 0x00070707, 0x00040404,
 
367
        0x009b9b9b, 0x00949494, 0x00212121, 0x00666666,
 
368
        0x00e6e6e6, 0x00cecece, 0x00ededed, 0x00e7e7e7,
 
369
        0x003b3b3b, 0x00fefefe, 0x007f7f7f, 0x00c5c5c5,
 
370
        0x00a4a4a4, 0x00373737, 0x00b1b1b1, 0x004c4c4c,
 
371
        0x00919191, 0x006e6e6e, 0x008d8d8d, 0x00767676,
 
372
        0x00030303, 0x002d2d2d, 0x00dedede, 0x00969696,
 
373
        0x00262626, 0x007d7d7d, 0x00c6c6c6, 0x005c5c5c,
 
374
        0x00d3d3d3, 0x00f2f2f2, 0x004f4f4f, 0x00191919,
 
375
        0x003f3f3f, 0x00dcdcdc, 0x00797979, 0x001d1d1d,
 
376
        0x00525252, 0x00ebebeb, 0x00f3f3f3, 0x006d6d6d,
 
377
        0x005e5e5e, 0x00fbfbfb, 0x00696969, 0x00b2b2b2,
 
378
        0x00f0f0f0, 0x00313131, 0x000c0c0c, 0x00d4d4d4,
 
379
        0x00cfcfcf, 0x008c8c8c, 0x00e2e2e2, 0x00757575,
 
380
        0x00a9a9a9, 0x004a4a4a, 0x00575757, 0x00848484,
 
381
        0x00111111, 0x00454545, 0x001b1b1b, 0x00f5f5f5,
 
382
        0x00e4e4e4, 0x000e0e0e, 0x00737373, 0x00aaaaaa,
 
383
        0x00f1f1f1, 0x00dddddd, 0x00595959, 0x00141414,
 
384
        0x006c6c6c, 0x00929292, 0x00545454, 0x00d0d0d0,
 
385
        0x00787878, 0x00707070, 0x00e3e3e3, 0x00494949,
 
386
        0x00808080, 0x00505050, 0x00a7a7a7, 0x00f6f6f6,
 
387
        0x00777777, 0x00939393, 0x00868686, 0x00838383,
 
388
        0x002a2a2a, 0x00c7c7c7, 0x005b5b5b, 0x00e9e9e9,
 
389
        0x00eeeeee, 0x008f8f8f, 0x00010101, 0x003d3d3d
 
390
        },
 
391
        {
 
392
        0x38003838, 0x41004141, 0x16001616, 0x76007676,
 
393
        0xd900d9d9, 0x93009393, 0x60006060, 0xf200f2f2,
 
394
        0x72007272, 0xc200c2c2, 0xab00abab, 0x9a009a9a,
 
395
        0x75007575, 0x06000606, 0x57005757, 0xa000a0a0,
 
396
        0x91009191, 0xf700f7f7, 0xb500b5b5, 0xc900c9c9,
 
397
        0xa200a2a2, 0x8c008c8c, 0xd200d2d2, 0x90009090,
 
398
        0xf600f6f6, 0x07000707, 0xa700a7a7, 0x27002727,
 
399
        0x8e008e8e, 0xb200b2b2, 0x49004949, 0xde00dede,
 
400
        0x43004343, 0x5c005c5c, 0xd700d7d7, 0xc700c7c7,
 
401
        0x3e003e3e, 0xf500f5f5, 0x8f008f8f, 0x67006767,
 
402
        0x1f001f1f, 0x18001818, 0x6e006e6e, 0xaf00afaf,
 
403
        0x2f002f2f, 0xe200e2e2, 0x85008585, 0x0d000d0d,
 
404
        0x53005353, 0xf000f0f0, 0x9c009c9c, 0x65006565,
 
405
        0xea00eaea, 0xa300a3a3, 0xae00aeae, 0x9e009e9e,
 
406
        0xec00ecec, 0x80008080, 0x2d002d2d, 0x6b006b6b,
 
407
        0xa800a8a8, 0x2b002b2b, 0x36003636, 0xa600a6a6,
 
408
        0xc500c5c5, 0x86008686, 0x4d004d4d, 0x33003333,
 
409
        0xfd00fdfd, 0x66006666, 0x58005858, 0x96009696,
 
410
        0x3a003a3a, 0x09000909, 0x95009595, 0x10001010,
 
411
        0x78007878, 0xd800d8d8, 0x42004242, 0xcc00cccc,
 
412
        0xef00efef, 0x26002626, 0xe500e5e5, 0x61006161,
 
413
        0x1a001a1a, 0x3f003f3f, 0x3b003b3b, 0x82008282,
 
414
        0xb600b6b6, 0xdb00dbdb, 0xd400d4d4, 0x98009898,
 
415
        0xe800e8e8, 0x8b008b8b, 0x02000202, 0xeb00ebeb,
 
416
        0x0a000a0a, 0x2c002c2c, 0x1d001d1d, 0xb000b0b0,
 
417
        0x6f006f6f, 0x8d008d8d, 0x88008888, 0x0e000e0e,
 
418
        0x19001919, 0x87008787, 0x4e004e4e, 0x0b000b0b,
 
419
        0xa900a9a9, 0x0c000c0c, 0x79007979, 0x11001111,
 
420
        0x7f007f7f, 0x22002222, 0xe700e7e7, 0x59005959,
 
421
        0xe100e1e1, 0xda00dada, 0x3d003d3d, 0xc800c8c8,
 
422
        0x12001212, 0x04000404, 0x74007474, 0x54005454,
 
423
        0x30003030, 0x7e007e7e, 0xb400b4b4, 0x28002828,
 
424
        0x55005555, 0x68006868, 0x50005050, 0xbe00bebe,
 
425
        0xd000d0d0, 0xc400c4c4, 0x31003131, 0xcb00cbcb,
 
426
        0x2a002a2a, 0xad00adad, 0x0f000f0f, 0xca00caca,
 
427
        0x70007070, 0xff00ffff, 0x32003232, 0x69006969,
 
428
        0x08000808, 0x62006262, 0x00000000, 0x24002424,
 
429
        0xd100d1d1, 0xfb00fbfb, 0xba00baba, 0xed00eded,
 
430
        0x45004545, 0x81008181, 0x73007373, 0x6d006d6d,
 
431
        0x84008484, 0x9f009f9f, 0xee00eeee, 0x4a004a4a,
 
432
        0xc300c3c3, 0x2e002e2e, 0xc100c1c1, 0x01000101,
 
433
        0xe600e6e6, 0x25002525, 0x48004848, 0x99009999,
 
434
        0xb900b9b9, 0xb300b3b3, 0x7b007b7b, 0xf900f9f9,
 
435
        0xce00cece, 0xbf00bfbf, 0xdf00dfdf, 0x71007171,
 
436
        0x29002929, 0xcd00cdcd, 0x6c006c6c, 0x13001313,
 
437
        0x64006464, 0x9b009b9b, 0x63006363, 0x9d009d9d,
 
438
        0xc000c0c0, 0x4b004b4b, 0xb700b7b7, 0xa500a5a5,
 
439
        0x89008989, 0x5f005f5f, 0xb100b1b1, 0x17001717,
 
440
        0xf400f4f4, 0xbc00bcbc, 0xd300d3d3, 0x46004646,
 
441
        0xcf00cfcf, 0x37003737, 0x5e005e5e, 0x47004747,
 
442
        0x94009494, 0xfa00fafa, 0xfc00fcfc, 0x5b005b5b,
 
443
        0x97009797, 0xfe00fefe, 0x5a005a5a, 0xac00acac,
 
444
        0x3c003c3c, 0x4c004c4c, 0x03000303, 0x35003535,
 
445
        0xf300f3f3, 0x23002323, 0xb800b8b8, 0x5d005d5d,
 
446
        0x6a006a6a, 0x92009292, 0xd500d5d5, 0x21002121,
 
447
        0x44004444, 0x51005151, 0xc600c6c6, 0x7d007d7d,
 
448
        0x39003939, 0x83008383, 0xdc00dcdc, 0xaa00aaaa,
 
449
        0x7c007c7c, 0x77007777, 0x56005656, 0x05000505,
 
450
        0x1b001b1b, 0xa400a4a4, 0x15001515, 0x34003434,
 
451
        0x1e001e1e, 0x1c001c1c, 0xf800f8f8, 0x52005252,
 
452
        0x20002020, 0x14001414, 0xe900e9e9, 0xbd00bdbd,
 
453
        0xdd00dddd, 0xe400e4e4, 0xa100a1a1, 0xe000e0e0,
 
454
        0x8a008a8a, 0xf100f1f1, 0xd600d6d6, 0x7a007a7a,
 
455
        0xbb00bbbb, 0xe300e3e3, 0x40004040, 0x4f004f4f
 
456
        },
 
457
        {
 
458
        0x70700070, 0x2c2c002c, 0xb3b300b3, 0xc0c000c0,
 
459
        0xe4e400e4, 0x57570057, 0xeaea00ea, 0xaeae00ae,
 
460
        0x23230023, 0x6b6b006b, 0x45450045, 0xa5a500a5,
 
461
        0xeded00ed, 0x4f4f004f, 0x1d1d001d, 0x92920092,
 
462
        0x86860086, 0xafaf00af, 0x7c7c007c, 0x1f1f001f,
 
463
        0x3e3e003e, 0xdcdc00dc, 0x5e5e005e, 0x0b0b000b,
 
464
        0xa6a600a6, 0x39390039, 0xd5d500d5, 0x5d5d005d,
 
465
        0xd9d900d9, 0x5a5a005a, 0x51510051, 0x6c6c006c,
 
466
        0x8b8b008b, 0x9a9a009a, 0xfbfb00fb, 0xb0b000b0,
 
467
        0x74740074, 0x2b2b002b, 0xf0f000f0, 0x84840084,
 
468
        0xdfdf00df, 0xcbcb00cb, 0x34340034, 0x76760076,
 
469
        0x6d6d006d, 0xa9a900a9, 0xd1d100d1, 0x04040004,
 
470
        0x14140014, 0x3a3a003a, 0xdede00de, 0x11110011,
 
471
        0x32320032, 0x9c9c009c, 0x53530053, 0xf2f200f2,
 
472
        0xfefe00fe, 0xcfcf00cf, 0xc3c300c3, 0x7a7a007a,
 
473
        0x24240024, 0xe8e800e8, 0x60600060, 0x69690069,
 
474
        0xaaaa00aa, 0xa0a000a0, 0xa1a100a1, 0x62620062,
 
475
        0x54540054, 0x1e1e001e, 0xe0e000e0, 0x64640064,
 
476
        0x10100010, 0x00000000, 0xa3a300a3, 0x75750075,
 
477
        0x8a8a008a, 0xe6e600e6, 0x09090009, 0xdddd00dd,
 
478
        0x87870087, 0x83830083, 0xcdcd00cd, 0x90900090,
 
479
        0x73730073, 0xf6f600f6, 0x9d9d009d, 0xbfbf00bf,
 
480
        0x52520052, 0xd8d800d8, 0xc8c800c8, 0xc6c600c6,
 
481
        0x81810081, 0x6f6f006f, 0x13130013, 0x63630063,
 
482
        0xe9e900e9, 0xa7a700a7, 0x9f9f009f, 0xbcbc00bc,
 
483
        0x29290029, 0xf9f900f9, 0x2f2f002f, 0xb4b400b4,
 
484
        0x78780078, 0x06060006, 0xe7e700e7, 0x71710071,
 
485
        0xd4d400d4, 0xabab00ab, 0x88880088, 0x8d8d008d,
 
486
        0x72720072, 0xb9b900b9, 0xf8f800f8, 0xacac00ac,
 
487
        0x36360036, 0x2a2a002a, 0x3c3c003c, 0xf1f100f1,
 
488
        0x40400040, 0xd3d300d3, 0xbbbb00bb, 0x43430043,
 
489
        0x15150015, 0xadad00ad, 0x77770077, 0x80800080,
 
490
        0x82820082, 0xecec00ec, 0x27270027, 0xe5e500e5,
 
491
        0x85850085, 0x35350035, 0x0c0c000c, 0x41410041,
 
492
        0xefef00ef, 0x93930093, 0x19190019, 0x21210021,
 
493
        0x0e0e000e, 0x4e4e004e, 0x65650065, 0xbdbd00bd,
 
494
        0xb8b800b8, 0x8f8f008f, 0xebeb00eb, 0xcece00ce,
 
495
        0x30300030, 0x5f5f005f, 0xc5c500c5, 0x1a1a001a,
 
496
        0xe1e100e1, 0xcaca00ca, 0x47470047, 0x3d3d003d,
 
497
        0x01010001, 0xd6d600d6, 0x56560056, 0x4d4d004d,
 
498
        0x0d0d000d, 0x66660066, 0xcccc00cc, 0x2d2d002d,
 
499
        0x12120012, 0x20200020, 0xb1b100b1, 0x99990099,
 
500
        0x4c4c004c, 0xc2c200c2, 0x7e7e007e, 0x05050005,
 
501
        0xb7b700b7, 0x31310031, 0x17170017, 0xd7d700d7,
 
502
        0x58580058, 0x61610061, 0x1b1b001b, 0x1c1c001c,
 
503
        0x0f0f000f, 0x16160016, 0x18180018, 0x22220022,
 
504
        0x44440044, 0xb2b200b2, 0xb5b500b5, 0x91910091,
 
505
        0x08080008, 0xa8a800a8, 0xfcfc00fc, 0x50500050,
 
506
        0xd0d000d0, 0x7d7d007d, 0x89890089, 0x97970097,
 
507
        0x5b5b005b, 0x95950095, 0xffff00ff, 0xd2d200d2,
 
508
        0xc4c400c4, 0x48480048, 0xf7f700f7, 0xdbdb00db,
 
509
        0x03030003, 0xdada00da, 0x3f3f003f, 0x94940094,
 
510
        0x5c5c005c, 0x02020002, 0x4a4a004a, 0x33330033,
 
511
        0x67670067, 0xf3f300f3, 0x7f7f007f, 0xe2e200e2,
 
512
        0x9b9b009b, 0x26260026, 0x37370037, 0x3b3b003b,
 
513
        0x96960096, 0x4b4b004b, 0xbebe00be, 0x2e2e002e,
 
514
        0x79790079, 0x8c8c008c, 0x6e6e006e, 0x8e8e008e,
 
515
        0xf5f500f5, 0xb6b600b6, 0xfdfd00fd, 0x59590059,
 
516
        0x98980098, 0x6a6a006a, 0x46460046, 0xbaba00ba,
 
517
        0x25250025, 0x42420042, 0xa2a200a2, 0xfafa00fa,
 
518
        0x07070007, 0x55550055, 0xeeee00ee, 0x0a0a000a,
 
519
        0x49490049, 0x68680068, 0x38380038, 0xa4a400a4,
 
520
        0x28280028, 0x7b7b007b, 0xc9c900c9, 0xc1c100c1,
 
521
        0xe3e300e3, 0xf4f400f4, 0xc7c700c7, 0x9e9e009e
 
522
        }};
299
523
 
300
524
NAMESPACE_END
301
 
 
302
 
#endif // WORD64_AVAILABLE