1ceb24b598ba9b4cacb86db181a92933a7b8eeca
[ffmpeg.git] / libavutil / ripemd.c
1 /*
2  * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (C) 2013 James Almer
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <string.h>
23
24 #include "attributes.h"
25 #include "avutil.h"
26 #include "bswap.h"
27 #include "intreadwrite.h"
28 #include "ripemd.h"
29 #include "mem.h"
30
31 /** hash context */
32 typedef struct AVRIPEMD {
33     uint8_t  digest_len;  ///< digest length in 32-bit words
34     uint64_t count;       ///< number of bytes in buffer
35     uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
36     uint32_t state[10];   ///< current hash value
37     uint8_t  ext;         ///< extension (0 for 128 and 160, 1 for 256 and 320)
38     /** function used to update hash for 512-bit input block */
39     void     (*transform)(uint32_t *state, const uint8_t buffer[64], int ext);
40 } AVRIPEMD;
41
42 const int av_ripemd_size = sizeof(AVRIPEMD);
43
44 struct AVRIPEMD *av_ripemd_alloc(void)
45 {
46     return av_mallocz(sizeof(struct AVRIPEMD));
47 }
48
49 static const uint32_t KA[4] = {
50     0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
51 };
52
53 static const uint32_t KB[4] = {
54     0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
55 };
56
57 static const int ROTA[80] = {
58     11, 14, 15, 12,  5,  8,  7 , 9, 11, 13, 14, 15,  6,  7,  9,  8,
59      7 , 6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
60     11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
61     11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
62      9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6
63 };
64
65 static const int ROTB[80] = {
66      8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
67      9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
68      9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
69     15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
70      8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11
71 };
72
73 static const int WA[80] = {
74      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
75      7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
76      3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
77      1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
78      4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13
79 };
80
81 static const int WB[80] = {
82      5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
83      6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
84     15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
85      8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
86     12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11
87 };
88
89 #define rol(value, bits) ((value << bits) | (value >> (32 - bits)))
90
91 #define SWAP(a,b) if (ext) { t = a; a = b; b = t; }
92
93 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h)                               \
94     a = rol(a + ((  b ^ c  ^ d)      + block[WA[n]]),         ROTA[n]); \
95     e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
96     n++
97
98 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h)                              \
99     a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
100     e = rol(e + (((~g | f) ^ h)      + block[WB[n]] + KB[1]), ROTB[n]); \
101     n++
102
103 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h)                              \
104     a = rol(a + (((~c | b) ^ d)      + block[WA[n]] + KA[1]), ROTA[n]); \
105     e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
106     n++
107
108 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h)                              \
109     a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
110     e = rol(e + ((  f ^ g  ^ h)      + block[WB[n]]),         ROTB[n]); \
111     n++
112
113 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64], int ext)
114 {
115     uint32_t a, b, c, d, e, f, g, h, t;
116     uint32_t block[16];
117     int n;
118
119     if (ext) {
120         a = state[0]; b = state[1]; c = state[2]; d = state[3];
121         e = state[4]; f = state[5]; g = state[6]; h = state[7];
122     } else {
123         a = e = state[0];
124         b = f = state[1];
125         c = g = state[2];
126         d = h = state[3];
127     }
128
129     for (n = 0; n < 16; n++)
130         block[n] = AV_RL32(buffer + 4 * n);
131     n = 0;
132
133 #if CONFIG_SMALL
134     for (; n < 16;) {
135         ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
136         t = d; d = c; c = b; b = a; a = t;
137         t = h; h = g; g = f; f = e; e = t;
138     }
139     SWAP(a,e)
140
141     for (; n < 32;) {
142         ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
143         t = d; d = c; c = b; b = a; a = t;
144         t = h; h = g; g = f; f = e; e = t;
145     }
146     SWAP(b,f)
147
148     for (; n < 48;) {
149         ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
150         t = d; d = c; c = b; b = a; a = t;
151         t = h; h = g; g = f; f = e; e = t;
152     }
153     SWAP(c,g)
154
155     for (; n < 64;) {
156         ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
157         t = d; d = c; c = b; b = a; a = t;
158         t = h; h = g; g = f; f = e; e = t;
159     }
160     SWAP(d,h)
161 #else
162
163 #define R128_0                         \
164     ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
165     ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
166     ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
167     ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
168
169     R128_0; R128_0; R128_0; R128_0;
170     SWAP(a,e)
171
172 #define R128_16                         \
173     ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
174     ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
175     ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
176     ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
177
178     R128_16; R128_16; R128_16; R128_16;
179     SWAP(b,f)
180
181 #define R128_32                         \
182     ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
183     ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
184     ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
185     ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
186
187     R128_32; R128_32; R128_32; R128_32;
188     SWAP(c,g)
189
190 #define R128_48                         \
191     ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
192     ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
193     ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
194     ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
195
196     R128_48; R128_48; R128_48; R128_48;
197     SWAP(d,h)
198 #endif
199
200     if (ext) {
201         state[0] += a; state[1] += b; state[2] += c; state[3] += d;
202         state[4] += e; state[5] += f; state[6] += g; state[7] += h;
203     } else {
204         h += c + state[1];
205         state[1] = state[2] + d + e;
206         state[2] = state[3] + a + f;
207         state[3] = state[0] + b + g;
208         state[0] = h;
209     }
210 }
211
212 #define ROTATE(x,y) \
213     x = rol(x, 10); \
214     y = rol(y, 10); \
215     n++
216
217 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j)                               \
218     a = rol(a + ((  b ^ c  ^ d)      + block[WA[n]]),         ROTA[n]) + e; \
219     f = rol(f + (((~i | h) ^ g)      + block[WB[n]] + KB[0]), ROTB[n]) + j; \
220     ROTATE(c,h)
221
222 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)                              \
223     a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
224     f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
225     ROTATE(c,h)
226
227 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j)                              \
228     a = rol(a + (((~c | b) ^ d)      + block[WA[n]] + KA[1]), ROTA[n]) + e; \
229     f = rol(f + (((~h | g) ^ i)      + block[WB[n]] + KB[2]), ROTB[n]) + j; \
230     ROTATE(c,h)
231
232 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j)                              \
233     a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
234     f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
235     ROTATE(c,h)
236
237 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j)                              \
238     a = rol(a + (((~d | c) ^ b)      + block[WA[n]] + KA[3]), ROTA[n]) + e; \
239     f = rol(f + ((  g ^ h  ^ i)      + block[WB[n]]),         ROTB[n]) + j; \
240     ROTATE(c,h)
241
242 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64], int ext)
243 {
244     uint32_t a, b, c, d, e, f, g, h, i, j, t;
245     uint32_t block[16];
246     int n;
247
248     if (ext) {
249         a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
250         f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
251     } else {
252         a = f = state[0];
253         b = g = state[1];
254         c = h = state[2];
255         d = i = state[3];
256         e = j = state[4];
257     }
258
259     for (n = 0; n < 16; n++)
260         block[n] = AV_RL32(buffer + 4 * n);
261     n = 0;
262
263 #if CONFIG_SMALL
264     for (; n < 16;) {
265         ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
266         t = e; e = d; d = c; c = b; b = a; a = t;
267         t = j; j = i; i = h; h = g; g = f; f = t;
268     }
269     SWAP(b,g)
270
271     for (; n < 32;) {
272         ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
273         t = e; e = d; d = c; c = b; b = a; a = t;
274         t = j; j = i; i = h; h = g; g = f; f = t;
275     }
276     SWAP(d,i)
277
278     for (; n < 48;) {
279         ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
280         t = e; e = d; d = c; c = b; b = a; a = t;
281         t = j; j = i; i = h; h = g; g = f; f = t;
282     }
283     SWAP(a,f)
284
285     for (; n < 64;) {
286         ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
287         t = e; e = d; d = c; c = b; b = a; a = t;
288         t = j; j = i; i = h; h = g; g = f; f = t;
289     }
290     SWAP(c,h)
291
292     for (; n < 80;) {
293         ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
294         t = e; e = d; d = c; c = b; b = a; a = t;
295         t = j; j = i; i = h; h = g; g = f; f = t;
296     }
297     SWAP(e,j)
298 #else
299
300 #define R160_0                             \
301     ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \
302     ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \
303     ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \
304     ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \
305     ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f)
306
307     R160_0; R160_0; R160_0;
308     ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
309     SWAP(a,f)
310
311 #define R160_16                             \
312     ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \
313     ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \
314     ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \
315     ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \
316     ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)
317
318     R160_16; R160_16; R160_16;
319     ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
320     SWAP(b,g)
321
322 #define R160_32                             \
323     ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \
324     ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \
325     ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \
326     ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \
327     ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i)
328
329     R160_32; R160_32; R160_32;
330     ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
331     SWAP(c,h)
332
333 #define R160_48                             \
334     ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \
335     ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \
336     ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \
337     ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \
338     ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h)
339
340     R160_48; R160_48; R160_48;
341     ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
342     SWAP(d,i)
343
344 #define R160_64                             \
345     ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \
346     ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \
347     ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \
348     ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \
349     ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g)
350
351     R160_64; R160_64; R160_64;
352     ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
353     SWAP(e,j)
354 #endif
355
356     if (ext) {
357         state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
358         state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
359     } else {
360         i += c + state[1];
361         state[1] = state[2] + d + j;
362         state[2] = state[3] + e + f;
363         state[3] = state[4] + a + g;
364         state[4] = state[0] + b + h;
365         state[0] = i;
366     }
367 }
368
369 av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
370 {
371     ctx->digest_len = bits >> 5;
372     switch (bits) {
373     case 128: // RIPEMD-128
374         ctx->state[0] = 0x67452301;
375         ctx->state[1] = 0xEFCDAB89;
376         ctx->state[2] = 0x98BADCFE;
377         ctx->state[3] = 0x10325476;
378         ctx->transform = ripemd128_transform;
379         ctx->ext = 0;
380         break;
381     case 160: // RIPEMD-160
382         ctx->state[0] = 0x67452301;
383         ctx->state[1] = 0xEFCDAB89;
384         ctx->state[2] = 0x98BADCFE;
385         ctx->state[3] = 0x10325476;
386         ctx->state[4] = 0xC3D2E1F0;
387         ctx->transform = ripemd160_transform;
388         ctx->ext = 0;
389         break;
390     case 256: // RIPEMD-256
391         ctx->state[0] = 0x67452301;
392         ctx->state[1] = 0xEFCDAB89;
393         ctx->state[2] = 0x98BADCFE;
394         ctx->state[3] = 0x10325476;
395         ctx->state[4] = 0x76543210;
396         ctx->state[5] = 0xFEDCBA98;
397         ctx->state[6] = 0x89ABCDEF;
398         ctx->state[7] = 0x01234567;
399         ctx->transform = ripemd128_transform;
400         ctx->ext = 1;
401         break;
402     case 320: // RIPEMD-320
403         ctx->state[0] = 0x67452301;
404         ctx->state[1] = 0xEFCDAB89;
405         ctx->state[2] = 0x98BADCFE;
406         ctx->state[3] = 0x10325476;
407         ctx->state[4] = 0xC3D2E1F0;
408         ctx->state[5] = 0x76543210;
409         ctx->state[6] = 0xFEDCBA98;
410         ctx->state[7] = 0x89ABCDEF;
411         ctx->state[8] = 0x01234567;
412         ctx->state[9] = 0x3C2D1E0F;
413         ctx->transform = ripemd160_transform;
414         ctx->ext = 1;
415         break;
416     default:
417         return -1;
418     }
419     ctx->count = 0;
420     return 0;
421 }
422
423 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, unsigned int len)
424 {
425     unsigned int i, j;
426
427     j = ctx->count & 63;
428     ctx->count += len;
429 #if CONFIG_SMALL
430     for (i = 0; i < len; i++) {
431         ctx->buffer[j++] = data[i];
432         if (64 == j) {
433             ctx->transform(ctx->state, ctx->buffer, ctx->ext);
434             j = 0;
435         }
436     }
437 #else
438     if ((j + len) > 63) {
439         memcpy(&ctx->buffer[j], data, (i = 64 - j));
440         ctx->transform(ctx->state, ctx->buffer, ctx->ext);
441         for (; i + 63 < len; i += 64)
442             ctx->transform(ctx->state, &data[i], ctx->ext);
443         j = 0;
444     } else
445         i = 0;
446     memcpy(&ctx->buffer[j], &data[i], len - i);
447 #endif
448 }
449
450 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
451 {
452     int i;
453     uint64_t finalcount = av_le2ne64(ctx->count << 3);
454
455     av_ripemd_update(ctx, "\200", 1);
456     while ((ctx->count & 63) != 56)
457         av_ripemd_update(ctx, "", 1);
458     av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
459     for (i = 0; i < ctx->digest_len; i++)
460         AV_WL32(digest + i*4, ctx->state[i]);
461 }
462
463 #ifdef TEST
464 #include <stdio.h>
465
466 int main(void)
467 {
468     int i, j, k;
469     AVRIPEMD ctx;
470     unsigned char digest[40];
471     static const int lengths[4] = { 128, 160, 256, 320 };
472
473     for (j = 0; j < 4; j++) {
474         printf("Testing RIPEMD-%d\n", lengths[j]);
475         for (k = 0; k < 3; k++) {
476             av_ripemd_init(&ctx, lengths[j]);
477             if (k == 0)
478                 av_ripemd_update(&ctx, "abc", 3);
479             else if (k == 1)
480                 av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
481             else
482                 for (i = 0; i < 1000*1000; i++)
483                     av_ripemd_update(&ctx, "a", 1);
484             av_ripemd_final(&ctx, digest);
485             for (i = 0; i < lengths[j] >> 3; i++)
486                 printf("%02X", digest[i]);
487             putchar('\n');
488         }
489         switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
490         case 0:
491             printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
492                    "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
493                    "4a7f5723 f954eba1 216c9d8f 6320431f\n");
494             break;
495         case 1:
496             printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
497                    "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
498                    "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
499             break;
500         case 2:
501             printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
502                    "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
503                    "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
504             break;
505         case 3:
506             printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
507                    "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
508                    "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");
509             break;
510         }
511     }
512
513     return 0;
514 }
515 #endif