lib/crc32.c

   1 /*
   2  * Aug 8, 2011 Bob Pearson with help from Joakim Tjernlund and George Spelvin
   3  * cleaned up code to current version of sparse and added the slicing-by-8
   4  * algorithm to the closely similar existing slicing-by-4 algorithm.
   5  *
   6  * Oct 15, 2000 Matt Domsch <Matt_Domsch@dell.com>
   7  * Nicer crc32 functions/docs submitted by linux@horizon.com.  Thanks!
   8  * Code was from the public domain, copyright abandoned.  Code was
   9  * subsequently included in the kernel, thus was re-licensed under the
  10  * GNU GPL v2.
  11  *
  12  * Oct 12, 2000 Matt Domsch <Matt_Domsch@dell.com>
  13  * Same crc32 function was used in 5 other places in the kernel.
  14  * I made one version, and deleted the others.
  15  * There are various incantations of crc32().  Some use a seed of 0 or ~0.
  16  * Some xor at the end with ~0.  The generic crc32() function takes
  17  * seed as an argument, and doesn't xor at the end.  Then individual
  18  * users can do whatever they need.
  19  *   drivers/net/smc9194.c uses seed ~0, doesn't xor with ~0.
  20  *   fs/jffs2 uses seed 0, doesn't xor with ~0.
  21  *   fs/partitions/efi.c uses seed ~0, xor's with ~0.
  22  *
  23  * This source code is licensed under the GNU General Public License,
  24  * Version 2.  See the file COPYING for more details.
  25  */
  26
  27 /* see: Documentation/crc32.txt for a description of algorithms */
  28
  29 #include <linux/crc32.h>
  30 #include <linux/module.h>
  31 #include <linux/types.h>
  32 #include <linux/sched.h>
  33 #include "crc32defs.h"
  34
  35 #if CRC_LE_BITS > 8
  36 # define tole(x) ((__force u32) cpu_to_le32(x))
  37 #else
  38 # define tole(x) (x)
  39 #endif
  40
  41 #if CRC_BE_BITS > 8
  42 # define tobe(x) ((__force u32) cpu_to_be32(x))
  43 #else
  44 # define tobe(x) (x)
  45 #endif
  46
  47 #include "crc32table.h"
  48
  49 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");
  50 MODULE_DESCRIPTION("Various CRC32 calculations");
  51 MODULE_LICENSE("GPL");
  52
  53 #if CRC_LE_BITS > 8 || CRC_BE_BITS > 8
  54
  55 /* implements slicing-by-4 or slicing-by-8 algorithm */
  56 static inline u32 __pure
  57 crc32_body(u32 crc, unsigned char const *buf, size_t len, const u32 (*tab)[256])
  58 {
  59 # ifdef __LITTLE_ENDIAN
  60 #  define DO_CRC(x) crc = t0[(crc ^ (x)) & 255] ^ (crc >> 8)
  61 #  define DO_CRC4 (t3[(q) & 255] ^ t2[(q >> 8) & 255] ^ \
  62                    t1[(q >> 16) & 255] ^ t0[(q >> 24) & 255])
  63 #  define DO_CRC8 (t7[(q) & 255] ^ t6[(q >> 8) & 255] ^ \
  64                    t5[(q >> 16) & 255] ^ t4[(q >> 24) & 255])
  65 # else
  66 #  define DO_CRC(x) crc = t0[((crc >> 24) ^ (x)) & 255] ^ (crc << 8)
  67 #  define DO_CRC4 (t0[(q) & 255] ^ t1[(q >> 8) & 255] ^ \
  68                    t2[(q >> 16) & 255] ^ t3[(q >> 24) & 255])
  69 #  define DO_CRC8 (t4[(q) & 255] ^ t5[(q >> 8) & 255] ^ \
  70                    t6[(q >> 16) & 255] ^ t7[(q >> 24) & 255])
  71 # endif
  72         const u32 *b;
  73         size_t    rem_len;
  74 # ifdef CONFIG_X86
  75         size_t i;
  76 # endif
  77         const u32 *t0=tab[0], *t1=tab[1], *t2=tab[2], *t3=tab[3];
  78 # if CRC_LE_BITS != 32
  79         const u32 *t4 = tab[4], *t5 = tab[5], *t6 = tab[6], *t7 = tab[7];
  80 # endif
  81         u32 q;
  82
  83         /* Align it */
  84         if (unlikely((long)buf & 3 && len)) {
  85                 do {
  86                         DO_CRC(*buf++);
  87                 } while ((--len) && ((long)buf)&3);
  88         }
  89
  90 # if CRC_LE_BITS == 32
  91         rem_len = len & 3;
  92         len = len >> 2;
  93 # else
  94         rem_len = len & 7;
  95         len = len >> 3;
  96 # endif
  97
  98         b = (const u32 *)buf;
  99 # ifdef CONFIG_X86
 100         --b;
 101         for (i = 0; i < len; i++) {
 102 # else
 103         for (--b; len; --len) {
 104 # endif
 105                 q = crc ^ *++b; /* use pre increment for speed */
 106 # if CRC_LE_BITS == 32
 107                 crc = DO_CRC4;
 108 # else
 109                 crc = DO_CRC8;
 110                 q = *++b;
 111                 crc ^= DO_CRC4;
 112 # endif
 113         }
 114         len = rem_len;
 115         /* And the last few bytes */
 116         if (len) {
 117                 u8 *p = (u8 *)(b + 1) - 1;
 118 # ifdef CONFIG_X86
 119                 for (i = 0; i < len; i++)
 120                         DO_CRC(*++p); /* use pre increment for speed */
 121 # else
 122                 do {
 123                         DO_CRC(*++p); /* use pre increment for speed */
 124                 } while (--len);
 125 # endif
 126         }
 127         return crc;
 128 #undef DO_CRC
 129 #undef DO_CRC4
 130 #undef DO_CRC8
 131 }
 132 #endif
 133
 134
 135 /**
 136  * crc32_le_generic() - Calculate bitwise little-endian Ethernet AUTODIN II
 137  *                      CRC32/CRC32C
 138  * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for other
 139  *       uses, or the previous crc32/crc32c value if computing incrementally.
 140  * @p: pointer to buffer over which CRC32/CRC32C is run
 141  * @len: length of buffer @p
 142  * @tab: little-endian Ethernet table
 143  * @polynomial: CRC32/CRC32c LE polynomial
 144  */
 145 static inline u32 __pure crc32_le_generic(u32 crc, unsigned char const *p,
 146                                           size_t len, const u32 (*tab)[256],
 147                                           u32 polynomial)
 148 {
 149 #if CRC_LE_BITS == 1
 150         int i;
 151         while (len--) {
 152                 crc ^= *p++;
 153                 for (i = 0; i < 8; i++)
 154                         crc = (crc >> 1) ^ ((crc & 1) ? polynomial : 0);
 155         }
 156 # elif CRC_LE_BITS == 2
 157         while (len--) {
 158                 crc ^= *p++;
 159                 crc = (crc >> 2) ^ tab[0][crc & 3];
 160                 crc = (crc >> 2) ^ tab[0][crc & 3];
 161                 crc = (crc >> 2) ^ tab[0][crc & 3];
 162                 crc = (crc >> 2) ^ tab[0][crc & 3];
 163         }
 164 # elif CRC_LE_BITS == 4
 165         while (len--) {
 166                 crc ^= *p++;
 167                 crc = (crc >> 4) ^ tab[0][crc & 15];
 168                 crc = (crc >> 4) ^ tab[0][crc & 15];
 169         }
 170 # elif CRC_LE_BITS == 8
 171         /* aka Sarwate algorithm */
 172         while (len--) {
 173                 crc ^= *p++;
 174                 crc = (crc >> 8) ^ tab[0][crc & 255];
 175         }
 176 # else
 177         crc = (__force u32) __cpu_to_le32(crc);
 178         crc = crc32_body(crc, p, len, tab);
 179         crc = __le32_to_cpu((__force __le32)crc);
 180 #endif
 181         return crc;
 182 }
 183
 184 #if CRC_LE_BITS == 1
 185 u32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len)
 186 {
 187         return crc32_le_generic(crc, p, len, NULL, CRCPOLY_LE);
 188 }
 189 u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len)
 190 {
 191         return crc32_le_generic(crc, p, len, NULL, CRC32C_POLY_LE);
 192 }
 193 #else
 194 u32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len)
 195 {
 196         return crc32_le_generic(crc, p, len,
 197                         (const u32 (*)[256])crc32table_le, CRCPOLY_LE);
 198 }
 199 u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len)
 200 {
 201         return crc32_le_generic(crc, p, len,
 202                         (const u32 (*)[256])crc32ctable_le, CRC32C_POLY_LE);
 203 }
 204 #endif
 205 EXPORT_SYMBOL(crc32_le);
 206 EXPORT_SYMBOL(__crc32c_le);
 207
 208 /*
 209  * This multiplies the polynomials x and y modulo the given modulus.
 210  * This follows the "little-endian" CRC convention that the lsbit
 211  * represents the highest power of x, and the msbit represents x^0.
 212  */
 213 static u32 __attribute_const__ gf2_multiply(u32 x, u32 y, u32 modulus)
 214 {
 215         u32 product = x & 1 ? y : 0;
 216         int i;
 217
 218         for (i = 0; i < 31; i++) {
 219                 product = (product >> 1) ^ (product & 1 ? modulus : 0);
 220                 x >>= 1;
 221                 product ^= x & 1 ? y : 0;
 222         }
 223
 224         return product;
 225 }
 226
 227 /**
 228  * crc32_generic_shift - Append len 0 bytes to crc, in logarithmic time
 229  * @crc: The original little-endian CRC (i.e. lsbit is x^31 coefficient)
 230  * @len: The number of bytes. @crc is multiplied by x^(8*@len)
 231  * @polynomial: The modulus used to reduce the result to 32 bits.
 232  *
 233  * It's possible to parallelize CRC computations by computing a CRC
 234  * over separate ranges of a buffer, then summing them.
 235  * This shifts the given CRC by 8*len bits (i.e. produces the same effect
 236  * as appending len bytes of zero to the data), in time proportional
 237  * to log(len).
 238  */
 239 static u32 __attribute_const__ crc32_generic_shift(u32 crc, size_t len,
 240                                                    u32 polynomial)
 241 {
 242         u32 power = polynomial; /* CRC of x^32 */
 243         int i;
 244
 245         /* Shift up to 32 bits in the simple linear way */
 246         for (i = 0; i < 8 * (int)(len & 3); i++)
 247                 crc = (crc >> 1) ^ (crc & 1 ? polynomial : 0);
 248
 249         len >>= 2;
 250         if (!len)
 251                 return crc;
 252
 253         for (;;) {
 254                 /* "power" is x^(2^i), modulo the polynomial */
 255                 if (len & 1)
 256                         crc = gf2_multiply(crc, power, polynomial);
 257
 258                 len >>= 1;
 259                 if (!len)
 260                         break;
 261
 262                 /* Square power, advancing to x^(2^(i+1)) */
 263                 power = gf2_multiply(power, power, polynomial);
 264         }
 265
 266         return crc;
 267 }
 268
 269 u32 __attribute_const__ crc32_le_shift(u32 crc, size_t len)
 270 {
 271         return crc32_generic_shift(crc, len, CRCPOLY_LE);
 272 }
 273
 274 u32 __attribute_const__ __crc32c_le_shift(u32 crc, size_t len)
 275 {
 276         return crc32_generic_shift(crc, len, CRC32C_POLY_LE);
 277 }
 278 EXPORT_SYMBOL(crc32_le_shift);
 279 EXPORT_SYMBOL(__crc32c_le_shift);
 280
 281 /**
 282  * crc32_be_generic() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
 283  * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for
 284  *      other uses, or the previous crc32 value if computing incrementally.
 285  * @p: pointer to buffer over which CRC32 is run
 286  * @len: length of buffer @p
 287  * @tab: big-endian Ethernet table
 288  * @polynomial: CRC32 BE polynomial
 289  */
 290 static inline u32 __pure crc32_be_generic(u32 crc, unsigned char const *p,
 291                                           size_t len, const u32 (*tab)[256],
 292                                           u32 polynomial)
 293 {
 294 #if CRC_BE_BITS == 1
 295         int i;
 296         while (len--) {
 297                 crc ^= *p++ << 24;
 298                 for (i = 0; i < 8; i++)
 299                         crc =
 300                             (crc << 1) ^ ((crc & 0x80000000) ? polynomial :
 301                                           0);
 302         }
 303 # elif CRC_BE_BITS == 2
 304         while (len--) {
 305                 crc ^= *p++ << 24;
 306                 crc = (crc << 2) ^ tab[0][crc >> 30];
 307                 crc = (crc << 2) ^ tab[0][crc >> 30];
 308                 crc = (crc << 2) ^ tab[0][crc >> 30];
 309                 crc = (crc << 2) ^ tab[0][crc >> 30];
 310         }
 311 # elif CRC_BE_BITS == 4
 312         while (len--) {
 313                 crc ^= *p++ << 24;
 314                 crc = (crc << 4) ^ tab[0][crc >> 28];
 315                 crc = (crc << 4) ^ tab[0][crc >> 28];
 316         }
 317 # elif CRC_BE_BITS == 8
 318         while (len--) {
 319                 crc ^= *p++ << 24;
 320                 crc = (crc << 8) ^ tab[0][crc >> 24];
 321         }
 322 # else
 323         crc = (__force u32) __cpu_to_be32(crc);
 324         crc = crc32_body(crc, p, len, tab);
 325         crc = __be32_to_cpu((__force __be32)crc);
 326 # endif
 327         return crc;
 328 }
 329
 330 #if CRC_BE_BITS == 1
 331 u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
 332 {
 333         return crc32_be_generic(crc, p, len, NULL, CRCPOLY_BE);
 334 }
 335 #else
 336 u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
 337 {
 338         return crc32_be_generic(crc, p, len,
 339                         (const u32 (*)[256])crc32table_be, CRCPOLY_BE);
 340 }
 341 #endif
 342 EXPORT_SYMBOL(crc32_be);
 343
 344 #ifdef CONFIG_CRC32_SELFTEST
 345
 346 /* 4096 random bytes */
 347 static u8 const __aligned(8) test_buf[] __initconst =
 348 {
 349         0x5b, 0x85, 0x21, 0xcb, 0x09, 0x68, 0x7d, 0x30,
 350         0xc7, 0x69, 0xd7, 0x30, 0x92, 0xde, 0x59, 0xe4,
 351         0xc9, 0x6e, 0x8b, 0xdb, 0x98, 0x6b, 0xaa, 0x60,
 352         0xa8, 0xb5, 0xbc, 0x6c, 0xa9, 0xb1, 0x5b, 0x2c,
 353         0xea, 0xb4, 0x92, 0x6a, 0x3f, 0x79, 0x91, 0xe4,
 354         0xe9, 0x70, 0x51, 0x8c, 0x7f, 0x95, 0x6f, 0x1a,
 355         0x56, 0xa1, 0x5c, 0x27, 0x03, 0x67, 0x9f, 0x3a,
 356         0xe2, 0x31, 0x11, 0x29, 0x6b, 0x98, 0xfc, 0xc4,
 357         0x53, 0x24, 0xc5, 0x8b, 0xce, 0x47, 0xb2, 0xb9,
 358         0x32, 0xcb, 0xc1, 0xd0, 0x03, 0x57, 0x4e, 0xd4,
 359         0xe9, 0x3c, 0xa1, 0x63, 0xcf, 0x12, 0x0e, 0xca,
 360         0xe1, 0x13, 0xd1, 0x93, 0xa6, 0x88, 0x5c, 0x61,
 361         0x5b, 0xbb, 0xf0, 0x19, 0x46, 0xb4, 0xcf, 0x9e,
 362         0xb6, 0x6b, 0x4c, 0x3a, 0xcf, 0x60, 0xf9, 0x7a,
 363         0x8d, 0x07, 0x63, 0xdb, 0x40, 0xe9, 0x0b, 0x6f,
 364         0xad, 0x97, 0xf1, 0xed, 0xd0, 0x1e, 0x26, 0xfd,
 365         0xbf, 0xb7, 0xc8, 0x04, 0x94, 0xf8, 0x8b, 0x8c,
 366         0xf1, 0xab, 0x7a, 0xd4, 0xdd, 0xf3, 0xe8, 0x88,
 367         0xc3, 0xed, 0x17, 0x8a, 0x9b, 0x40, 0x0d, 0x53,
 368         0x62, 0x12, 0x03, 0x5f, 0x1b, 0x35, 0x32, 0x1f,
 369         0xb4, 0x7b, 0x93, 0x78, 0x0d, 0xdb, 0xce, 0xa4,
 370         0xc0, 0x47, 0xd5, 0xbf, 0x68, 0xe8, 0x5d, 0x74,
 371         0x8f, 0x8e, 0x75, 0x1c, 0xb2, 0x4f, 0x9a, 0x60,
 372         0xd1, 0xbe, 0x10, 0xf4, 0x5c, 0xa1, 0x53, 0x09,
 373         0xa5, 0xe0, 0x09, 0x54, 0x85, 0x5c, 0xdc, 0x07,
 374         0xe7, 0x21, 0x69, 0x7b, 0x8a, 0xfd, 0x90, 0xf1,
 375         0x22, 0xd0, 0xb4, 0x36, 0x28, 0xe6, 0xb8, 0x0f,
 376         0x39, 0xde, 0xc8, 0xf3, 0x86, 0x60, 0x34, 0xd2,
 377         0x5e, 0xdf, 0xfd, 0xcf, 0x0f, 0xa9, 0x65, 0xf0,
 378         0xd5, 0x4d, 0x96, 0x40, 0xe3, 0xdf, 0x3f, 0x95,
 379         0x5a, 0x39, 0x19, 0x93, 0xf4, 0x75, 0xce, 0x22,
 380         0x00, 0x1c, 0x93, 0xe2, 0x03, 0x66, 0xf4, 0x93,
 381         0x73, 0x86, 0x81, 0x8e, 0x29, 0x44, 0x48, 0x86,
 382         0x61, 0x7c, 0x48, 0xa3, 0x43, 0xd2, 0x9c, 0x8d,
 383         0xd4, 0x95, 0xdd, 0xe1, 0x22, 0x89, 0x3a, 0x40,
 384         0x4c, 0x1b, 0x8a, 0x04, 0xa8, 0x09, 0x69, 0x8b,
 385         0xea, 0xc6, 0x55, 0x8e, 0x57, 0xe6, 0x64, 0x35,
 386         0xf0, 0xc7, 0x16, 0x9f, 0x5d, 0x5e, 0x86, 0x40,
 387         0x46, 0xbb, 0xe5, 0x45, 0x88, 0xfe, 0xc9, 0x63,
 388         0x15, 0xfb, 0xf5, 0xbd, 0x71, 0x61, 0xeb, 0x7b,
 389         0x78, 0x70, 0x07, 0x31, 0x03, 0x9f, 0xb2, 0xc8,
 390         0xa7, 0xab, 0x47, 0xfd, 0xdf, 0xa0, 0x78, 0x72,
 391         0xa4, 0x2a, 0xe4, 0xb6, 0xba, 0xc0, 0x1e, 0x86,
 392         0x71, 0xe6, 0x3d, 0x18, 0x37, 0x70, 0xe6, 0xff,
 393         0xe0, 0xbc, 0x0b, 0x22, 0xa0, 0x1f, 0xd3, 0xed,
 394         0xa2, 0x55, 0x39, 0xab, 0xa8, 0x13, 0x73, 0x7c,
 395         0x3f, 0xb2, 0xd6, 0x19, 0xac, 0xff, 0x99, 0xed,
 396         0xe8, 0xe6, 0xa6, 0x22, 0xe3, 0x9c, 0xf1, 0x30,
 397         0xdc, 0x01, 0x0a, 0x56, 0xfa, 0xe4, 0xc9, 0x99,
 398         0xdd, 0xa8, 0xd8, 0xda, 0x35, 0x51, 0x73, 0xb4,
 399         0x40, 0x86, 0x85, 0xdb, 0x5c, 0xd5, 0x85, 0x80,
 400         0x14, 0x9c, 0xfd, 0x98, 0xa9, 0x82, 0xc5, 0x37,
 401         0xff, 0x32, 0x5d, 0xd0, 0x0b, 0xfa, 0xdc, 0x04,
 402         0x5e, 0x09, 0xd2, 0xca, 0x17, 0x4b, 0x1a, 0x8e,
 403         0x15, 0xe1, 0xcc, 0x4e, 0x52, 0x88, 0x35, 0xbd,
 404         0x48, 0xfe, 0x15, 0xa0, 0x91, 0xfd, 0x7e, 0x6c,
 405         0x0e, 0x5d, 0x79, 0x1b, 0x81, 0x79, 0xd2, 0x09,
 406         0x34, 0x70, 0x3d, 0x81, 0xec, 0xf6, 0x24, 0xbb,
 407         0xfb, 0xf1, 0x7b, 0xdf, 0x54, 0xea, 0x80, 0x9b,
 408         0xc7, 0x99, 0x9e, 0xbd, 0x16, 0x78, 0x12, 0x53,
 409         0x5e, 0x01, 0xa7, 0x4e, 0xbd, 0x67, 0xe1, 0x9b,
 410         0x4c, 0x0e, 0x61, 0x45, 0x97, 0xd2, 0xf0, 0x0f,
 411         0xfe, 0x15, 0x08, 0xb7, 0x11, 0x4c, 0xe7, 0xff,
 412         0x81, 0x53, 0xff, 0x91, 0x25, 0x38, 0x7e, 0x40,
 413         0x94, 0xe5, 0xe0, 0xad, 0xe6, 0xd9, 0x79, 0xb6,
 414         0x92, 0xc9, 0xfc, 0xde, 0xc3, 0x1a, 0x23, 0xbb,
 415         0xdd, 0xc8, 0x51, 0x0c, 0x3a, 0x72, 0xfa, 0x73,
 416         0x6f, 0xb7, 0xee, 0x61, 0x39, 0x03, 0x01, 0x3f,
 417         0x7f, 0x94, 0x2e, 0x2e, 0xba, 0x3a, 0xbb, 0xb4,
 418         0xfa, 0x6a, 0x17, 0xfe, 0xea, 0xef, 0x5e, 0x66,
 419         0x97, 0x3f, 0x32, 0x3d, 0xd7, 0x3e, 0xb1, 0xf1,
 420         0x6c, 0x14, 0x4c, 0xfd, 0x37, 0xd3, 0x38, 0x80,
 421         0xfb, 0xde, 0xa6, 0x24, 0x1e, 0xc8, 0xca, 0x7f,
 422         0x3a, 0x93, 0xd8, 0x8b, 0x18, 0x13, 0xb2, 0xe5,
 423         0xe4, 0x93, 0x05, 0x53, 0x4f, 0x84, 0x66, 0xa7,
 424         0x58, 0x5c, 0x7b, 0x86, 0x52, 0x6d, 0x0d, 0xce,
 425         0xa4, 0x30, 0x7d, 0xb6, 0x18, 0x9f, 0xeb, 0xff,
 426         0x22, 0xbb, 0x72, 0x29, 0xb9, 0x44, 0x0b, 0x48,
 427         0x1e, 0x84, 0x71, 0x81, 0xe3, 0x6d, 0x73, 0x26,
 428         0x92, 0xb4, 0x4d, 0x2a, 0x29, 0xb8, 0x1f, 0x72,
 429         0xed, 0xd0, 0xe1, 0x64, 0x77, 0xea, 0x8e, 0x88,
 430         0x0f, 0xef, 0x3f, 0xb1, 0x3b, 0xad, 0xf9, 0xc9,
 431         0x8b, 0xd0, 0xac, 0xc6, 0xcc, 0xa9, 0x40, 0xcc,
 432         0x76, 0xf6, 0x3b, 0x53, 0xb5, 0x88, 0xcb, 0xc8,
 433         0x37, 0xf1, 0xa2, 0xba, 0x23, 0x15, 0x99, 0x09,
 434         0xcc, 0xe7, 0x7a, 0x3b, 0x37, 0xf7, 0x58, 0xc8,
 435         0x46, 0x8c, 0x2b, 0x2f, 0x4e, 0x0e, 0xa6, 0x5c,
 436         0xea, 0x85, 0x55, 0xba, 0x02, 0x0e, 0x0e, 0x48,
 437         0xbc, 0xe1, 0xb1, 0x01, 0x35, 0x79, 0x13, 0x3d,
 438         0x1b, 0xc0, 0x53, 0x68, 0x11, 0xe7, 0x95, 0x0f,
 439         0x9d, 0x3f, 0x4c, 0x47, 0x7b, 0x4d, 0x1c, 0xae,
 440         0x50, 0x9b, 0xcb, 0xdd, 0x05, 0x8d, 0x9a, 0x97,
 441         0xfd, 0x8c, 0xef, 0x0c, 0x1d, 0x67, 0x73, 0xa8,
 442         0x28, 0x36, 0xd5, 0xb6, 0x92, 0x33, 0x40, 0x75,
 443         0x0b, 0x51, 0xc3, 0x64, 0xba, 0x1d, 0xc2, 0xcc,
 444         0xee, 0x7d, 0x54, 0x0f, 0x27, 0x69, 0xa7, 0x27,
 445         0x63, 0x30, 0x29, 0xd9, 0xc8, 0x84, 0xd8, 0xdf,
 446         0x9f, 0x68, 0x8d, 0x04, 0xca, 0xa6, 0xc5, 0xc7,
 447         0x7a, 0x5c, 0xc8, 0xd1, 0xcb, 0x4a, 0xec, 0xd0,
 448         0xd8, 0x20, 0x69, 0xc5, 0x17, 0xcd, 0x78, 0xc8,
 449         0x75, 0x23, 0x30, 0x69, 0xc9, 0xd4, 0xea, 0x5c,
 450         0x4f, 0x6b, 0x86, 0x3f, 0x8b, 0xfe, 0xee, 0x44,
 451         0xc9, 0x7c, 0xb7, 0xdd, 0x3e, 0xe5, 0xec, 0x54,
 452         0x03, 0x3e, 0xaa, 0x82, 0xc6, 0xdf, 0xb2, 0x38,
 453         0x0e, 0x5d, 0xb3, 0x88, 0xd9, 0xd3, 0x69, 0x5f,
 454         0x8f, 0x70, 0x8a, 0x7e, 0x11, 0xd9, 0x1e, 0x7b,
 455         0x38, 0xf1, 0x42, 0x1a, 0xc0, 0x35, 0xf5, 0xc7,
 456         0x36, 0x85, 0xf5, 0xf7, 0xb8, 0x7e, 0xc7, 0xef,
 457         0x18, 0xf1, 0x63, 0xd6, 0x7a, 0xc6, 0xc9, 0x0e,
 458         0x4d, 0x69, 0x4f, 0x84, 0xef, 0x26, 0x41, 0x0c,
 459         0xec, 0xc7, 0xe0, 0x7e, 0x3c, 0x67, 0x01, 0x4c,
 460         0x62, 0x1a, 0x20, 0x6f, 0xee, 0x47, 0x4d, 0xc0,
 461         0x99, 0x13, 0x8d, 0x91, 0x4a, 0x26, 0xd4, 0x37,
 462         0x28, 0x90, 0x58, 0x75, 0x66, 0x2b, 0x0a, 0xdf,
 463         0xda, 0xee, 0x92, 0x25, 0x90, 0x62, 0x39, 0x9e,
 464         0x44, 0x98, 0xad, 0xc1, 0x88, 0xed, 0xe4, 0xb4,
 465         0xaf, 0xf5, 0x8c, 0x9b, 0x48, 0x4d, 0x56, 0x60,
 466         0x97, 0x0f, 0x61, 0x59, 0x9e, 0xa6, 0x27, 0xfe,
 467         0xc1, 0x91, 0x15, 0x38, 0xb8, 0x0f, 0xae, 0x61,
 468         0x7d, 0x26, 0x13, 0x5a, 0x73, 0xff, 0x1c, 0xa3,
 469         0x61, 0x04, 0x58, 0x48, 0x55, 0x44, 0x11, 0xfe,
 470         0x15, 0xca, 0xc3, 0xbd, 0xca, 0xc5, 0xb4, 0x40,
 471         0x5d, 0x1b, 0x7f, 0x39, 0xb5, 0x9c, 0x35, 0xec,
 472         0x61, 0x15, 0x32, 0x32, 0xb8, 0x4e, 0x40, 0x9f,
 473         0x17, 0x1f, 0x0a, 0x4d, 0xa9, 0x91, 0xef, 0xb7,
 474         0xb0, 0xeb, 0xc2, 0x83, 0x9a, 0x6c, 0xd2, 0x79,
 475         0x43, 0x78, 0x5e, 0x2f, 0xe5, 0xdd, 0x1a, 0x3c,
 476         0x45, 0xab, 0x29, 0x40, 0x3a, 0x37, 0x5b, 0x6f,
 477         0xd7, 0xfc, 0x48, 0x64, 0x3c, 0x49, 0xfb, 0x21,
 478         0xbe, 0xc3, 0xff, 0x07, 0xfb, 0x17, 0xe9, 0xc9,
 479         0x0c, 0x4c, 0x5c, 0x15, 0x9e, 0x8e, 0x22, 0x30,
 480         0x0a, 0xde, 0x48, 0x7f, 0xdb, 0x0d, 0xd1, 0x2b,
 481         0x87, 0x38, 0x9e, 0xcc, 0x5a, 0x01, 0x16, 0xee,
 482         0x75, 0x49, 0x0d, 0x30, 0x01, 0x34, 0x6a, 0xb6,
 483         0x9a, 0x5a, 0x2a, 0xec, 0xbb, 0x48, 0xac, 0xd3,
 484         0x77, 0x83, 0xd8, 0x08, 0x86, 0x4f, 0x48, 0x09,
 485         0x29, 0x41, 0x79, 0xa1, 0x03, 0x12, 0xc4, 0xcd,
 486         0x90, 0x55, 0x47, 0x66, 0x74, 0x9a, 0xcc, 0x4f,
 487         0x35, 0x8c, 0xd6, 0x98, 0xef, 0xeb, 0x45, 0xb9,
 488         0x9a, 0x26, 0x2f, 0x39, 0xa5, 0x70, 0x6d, 0xfc,
 489         0xb4, 0x51, 0xee, 0xf4, 0x9c, 0xe7, 0x38, 0x59,
 490         0xad, 0xf4, 0xbc, 0x46, 0xff, 0x46, 0x8e, 0x60,
 491         0x9c, 0xa3, 0x60, 0x1d, 0xf8, 0x26, 0x72, 0xf5,
 492         0x72, 0x9d, 0x68, 0x80, 0x04, 0xf6, 0x0b, 0xa1,
 493         0x0a, 0xd5, 0xa7, 0x82, 0x3a, 0x3e, 0x47, 0xa8,
 494         0x5a, 0xde, 0x59, 0x4f, 0x7b, 0x07, 0xb3, 0xe9,
 495         0x24, 0x19, 0x3d, 0x34, 0x05, 0xec, 0xf1, 0xab,
 496         0x6e, 0x64, 0x8f, 0xd3, 0xe6, 0x41, 0x86, 0x80,
 497         0x70, 0xe3, 0x8d, 0x60, 0x9c, 0x34, 0x25, 0x01,
 498         0x07, 0x4d, 0x19, 0x41, 0x4e, 0x3d, 0x5c, 0x7e,
 499         0xa8, 0xf5, 0xcc, 0xd5, 0x7b, 0xe2, 0x7d, 0x3d,
 500         0x49, 0x86, 0x7d, 0x07, 0xb7, 0x10, 0xe3, 0x35,
 501         0xb8, 0x84, 0x6d, 0x76, 0xab, 0x17, 0xc6, 0x38,
 502         0xb4, 0xd3, 0x28, 0x57, 0xad, 0xd3, 0x88, 0x5a,
 503         0xda, 0xea, 0xc8, 0x94, 0xcc, 0x37, 0x19, 0xac,
 504         0x9c, 0x9f, 0x4b, 0x00, 0x15, 0xc0, 0xc8, 0xca,
 505         0x1f, 0x15, 0xaa, 0xe0, 0xdb, 0xf9, 0x2f, 0x57,
 506         0x1b, 0x24, 0xc7, 0x6f, 0x76, 0x29, 0xfb, 0xed,
 507         0x25, 0x0d, 0xc0, 0xfe, 0xbd, 0x5a, 0xbf, 0x20,
 508         0x08, 0x51, 0x05, 0xec, 0x71, 0xa3, 0xbf, 0xef,
 509         0x5e, 0x99, 0x75, 0xdb, 0x3c, 0x5f, 0x9a, 0x8c,
 510         0xbb, 0x19, 0x5c, 0x0e, 0x93, 0x19, 0xf8, 0x6a,
 511         0xbc, 0xf2, 0x12, 0x54, 0x2f, 0xcb, 0x28, 0x64,
 512         0x88, 0xb3, 0x92, 0x0d, 0x96, 0xd1, 0xa6, 0xe4,
 513         0x1f, 0xf1, 0x4d, 0xa4, 0xab, 0x1c, 0xee, 0x54,
 514         0xf2, 0xad, 0x29, 0x6d, 0x32, 0x37, 0xb2, 0x16,
 515         0x77, 0x5c, 0xdc, 0x2e, 0x54, 0xec, 0x75, 0x26,
 516         0xc6, 0x36, 0xd9, 0x17, 0x2c, 0xf1, 0x7a, 0xdc,
 517         0x4b, 0xf1, 0xe2, 0xd9, 0x95, 0xba, 0xac, 0x87,
 518         0xc1, 0xf3, 0x8e, 0x58, 0x08, 0xd8, 0x87, 0x60,
 519         0xc9, 0xee, 0x6a, 0xde, 0xa4, 0xd2, 0xfc, 0x0d,
 520         0xe5, 0x36, 0xc4, 0x5c, 0x52, 0xb3, 0x07, 0x54,
 521         0x65, 0x24, 0xc1, 0xb1, 0xd1, 0xb1, 0x53, 0x13,
 522         0x31, 0x79, 0x7f, 0x05, 0x76, 0xeb, 0x37, 0x59,
 523         0x15, 0x2b, 0xd1, 0x3f, 0xac, 0x08, 0x97, 0xeb,
 524         0x91, 0x98, 0xdf, 0x6c, 0x09, 0x0d, 0x04, 0x9f,
 525         0xdc, 0x3b, 0x0e, 0x60, 0x68, 0x47, 0x23, 0x15,
 526         0x16, 0xc6, 0x0b, 0x35, 0xf8, 0x77, 0xa2, 0x78,
 527         0x50, 0xd4, 0x64, 0x22, 0x33, 0xff, 0xfb, 0x93,
 528         0x71, 0x46, 0x50, 0x39, 0x1b, 0x9c, 0xea, 0x4e,
 529         0x8d, 0x0c, 0x37, 0xe5, 0x5c, 0x51, 0x3a, 0x31,
 530         0xb2, 0x85, 0x84, 0x3f, 0x41, 0xee, 0xa2, 0xc1,
 531         0xc6, 0x13, 0x3b, 0x54, 0x28, 0xd2, 0x18, 0x37,
 532         0xcc, 0x46, 0x9f, 0x6a, 0x91, 0x3d, 0x5a, 0x15,
 533         0x3c, 0x89, 0xa3, 0x61, 0x06, 0x7d, 0x2e, 0x78,
 534         0xbe, 0x7d, 0x40, 0xba, 0x2f, 0x95, 0xb1, 0x2f,
 535         0x87, 0x3b, 0x8a, 0xbe, 0x6a, 0xf4, 0xc2, 0x31,
 536         0x74, 0xee, 0x91, 0xe0, 0x23, 0xaa, 0x5d, 0x7f,
 537         0xdd, 0xf0, 0x44, 0x8c, 0x0b, 0x59, 0x2b, 0xfc,
 538         0x48, 0x3a, 0xdf, 0x07, 0x05, 0x38, 0x6c, 0xc9,
 539         0xeb, 0x18, 0x24, 0x68, 0x8d, 0x58, 0x98, 0xd3,
 540         0x31, 0xa3, 0xe4, 0x70, 0x59, 0xb1, 0x21, 0xbe,
 541         0x7e, 0x65, 0x7d, 0xb8, 0x04, 0xab, 0xf6, 0xe4,
 542         0xd7, 0xda, 0xec, 0x09, 0x8f, 0xda, 0x6d, 0x24,
 543         0x07, 0xcc, 0x29, 0x17, 0x05, 0x78, 0x1a, 0xc1,
 544         0xb1, 0xce, 0xfc, 0xaa, 0x2d, 0xe7, 0xcc, 0x85,
 545         0x84, 0x84, 0x03, 0x2a, 0x0c, 0x3f, 0xa9, 0xf8,
 546         0xfd, 0x84, 0x53, 0x59, 0x5c, 0xf0, 0xd4, 0x09,
 547         0xf0, 0xd2, 0x6c, 0x32, 0x03, 0xb0, 0xa0, 0x8c,
 548         0x52, 0xeb, 0x23, 0x91, 0x88, 0x43, 0x13, 0x46,
 549         0xf6, 0x1e, 0xb4, 0x1b, 0xf5, 0x8e, 0x3a, 0xb5,
 550         0x3d, 0x00, 0xf6, 0xe5, 0x08, 0x3d, 0x5f, 0x39,
 551         0xd3, 0x21, 0x69, 0xbc, 0x03, 0x22, 0x3a, 0xd2,
 552         0x5c, 0x84, 0xf8, 0x15, 0xc4, 0x80, 0x0b, 0xbc,
 553         0x29, 0x3c, 0xf3, 0x95, 0x98, 0xcd, 0x8f, 0x35,
 554         0xbc, 0xa5, 0x3e, 0xfc, 0xd4, 0x13, 0x9e, 0xde,
 555         0x4f, 0xce, 0x71, 0x9d, 0x09, 0xad, 0xf2, 0x80,
 556         0x6b, 0x65, 0x7f, 0x03, 0x00, 0x14, 0x7c, 0x15,
 557         0x85, 0x40, 0x6d, 0x70, 0xea, 0xdc, 0xb3, 0x63,
 558         0x35, 0x4f, 0x4d, 0xe0, 0xd9, 0xd5, 0x3c, 0x58,
 559         0x56, 0x23, 0x80, 0xe2, 0x36, 0xdd, 0x75, 0x1d,
 560         0x94, 0x11, 0x41, 0x8e, 0xe0, 0x81, 0x8e, 0xcf,
 561         0xe0, 0xe5, 0xf6, 0xde, 0xd1, 0xe7, 0x04, 0x12,
 562         0x79, 0x92, 0x2b, 0x71, 0x2a, 0x79, 0x8b, 0x7c,
 563         0x44, 0x79, 0x16, 0x30, 0x4e, 0xf4, 0xf6, 0x9b,
 564         0xb7, 0x40, 0xa3, 0x5a, 0xa7, 0x69, 0x3e, 0xc1,
 565         0x3a, 0x04, 0xd0, 0x88, 0xa0, 0x3b, 0xdd, 0xc6,
 566         0x9e, 0x7e, 0x1e, 0x1e, 0x8f, 0x44, 0xf7, 0x73,
 567         0x67, 0x1e, 0x1a, 0x78, 0xfa, 0x62, 0xf4, 0xa9,
 568         0xa8, 0xc6, 0x5b, 0xb8, 0xfa, 0x06, 0x7d, 0x5e,
 569         0x38, 0x1c, 0x9a, 0x39, 0xe9, 0x39, 0x98, 0x22,
 570         0x0b, 0xa7, 0xac, 0x0b, 0xf3, 0xbc, 0xf1, 0xeb,
 571         0x8c, 0x81, 0xe3, 0x48, 0x8a, 0xed, 0x42, 0xc2,
 572         0x38, 0xcf, 0x3e, 0xda, 0xd2, 0x89, 0x8d, 0x9c,
 573         0x53, 0xb5, 0x2f, 0x41, 0x01, 0x26, 0x84, 0x9c,
 574         0xa3, 0x56, 0xf6, 0x49, 0xc7, 0xd4, 0x9f, 0x93,
 575         0x1b, 0x96, 0x49, 0x5e, 0xad, 0xb3, 0x84, 0x1f,
 576         0x3c, 0xa4, 0xe0, 0x9b, 0xd1, 0x90, 0xbc, 0x38,
 577         0x6c, 0xdd, 0x95, 0x4d, 0x9d, 0xb1, 0x71, 0x57,
 578         0x2d, 0x34, 0xe8, 0xb8, 0x42, 0xc7, 0x99, 0x03,
 579         0xc7, 0x07, 0x30, 0x65, 0x91, 0x55, 0xd5, 0x90,
 580         0x70, 0x97, 0x37, 0x68, 0xd4, 0x11, 0xf9, 0xe8,
 581         0xce, 0xec, 0xdc, 0x34, 0xd5, 0xd3, 0xb7, 0xc4,
 582         0xb8, 0x97, 0x05, 0x92, 0xad, 0xf8, 0xe2, 0x36,
 583         0x64, 0x41, 0xc9, 0xc5, 0x41, 0x77, 0x52, 0xd7,
 584         0x2c, 0xa5, 0x24, 0x2f, 0xd9, 0x34, 0x0b, 0x47,
 585         0x35, 0xa7, 0x28, 0x8b, 0xc5, 0xcd, 0xe9, 0x46,
 586         0xac, 0x39, 0x94, 0x3c, 0x10, 0xc6, 0x29, 0x73,
 587         0x0e, 0x0e, 0x5d, 0xe0, 0x71, 0x03, 0x8a, 0x72,
 588         0x0e, 0x26, 0xb0, 0x7d, 0x84, 0xed, 0x95, 0x23,
 589         0x49, 0x5a, 0x45, 0x83, 0x45, 0x60, 0x11, 0x4a,
 590         0x46, 0x31, 0xd4, 0xd8, 0x16, 0x54, 0x98, 0x58,
 591         0xed, 0x6d, 0xcc, 0x5d, 0xd6, 0x50, 0x61, 0x9f,
 592         0x9d, 0xc5, 0x3e, 0x9d, 0x32, 0x47, 0xde, 0x96,
 593         0xe1, 0x5d, 0xd8, 0xf8, 0xb4, 0x69, 0x6f, 0xb9,
 594         0x15, 0x90, 0x57, 0x7a, 0xf6, 0xad, 0xb0, 0x5b,
 595         0xf5, 0xa6, 0x36, 0x94, 0xfd, 0x84, 0xce, 0x1c,
 596         0x0f, 0x4b, 0xd0, 0xc2, 0x5b, 0x6b, 0x56, 0xef,
 597         0x73, 0x93, 0x0b, 0xc3, 0xee, 0xd9, 0xcf, 0xd3,
 598         0xa4, 0x22, 0x58, 0xcd, 0x50, 0x6e, 0x65, 0xf4,
 599         0xe9, 0xb7, 0x71, 0xaf, 0x4b, 0xb3, 0xb6, 0x2f,
 600         0x0f, 0x0e, 0x3b, 0xc9, 0x85, 0x14, 0xf5, 0x17,
 601         0xe8, 0x7a, 0x3a, 0xbf, 0x5f, 0x5e, 0xf8, 0x18,
 602         0x48, 0xa6, 0x72, 0xab, 0x06, 0x95, 0xe9, 0xc8,
 603         0xa7, 0xf4, 0x32, 0x44, 0x04, 0x0c, 0x84, 0x98,
 604         0x73, 0xe3, 0x89, 0x8d, 0x5f, 0x7e, 0x4a, 0x42,
 605         0x8f, 0xc5, 0x28, 0xb1, 0x82, 0xef, 0x1c, 0x97,
 606         0x31, 0x3b, 0x4d, 0xe0, 0x0e, 0x10, 0x10, 0x97,
 607         0x93, 0x49, 0x78, 0x2f, 0x0d, 0x86, 0x8b, 0xa1,
 608         0x53, 0xa9, 0x81, 0x20, 0x79, 0xe7, 0x07, 0x77,
 609         0xb6, 0xac, 0x5e, 0xd2, 0x05, 0xcd, 0xe9, 0xdb,
 610         0x8a, 0x94, 0x82, 0x8a, 0x23, 0xb9, 0x3d, 0x1c,
 611         0xa9, 0x7d, 0x72, 0x4a, 0xed, 0x33, 0xa3, 0xdb,
 612         0x21, 0xa7, 0x86, 0x33, 0x45, 0xa5, 0xaa, 0x56,
 613         0x45, 0xb5, 0x83, 0x29, 0x40, 0x47, 0x79, 0x04,
 614         0x6e, 0xb9, 0x95, 0xd0, 0x81, 0x77, 0x2d, 0x48,
 615         0x1e, 0xfe, 0xc3, 0xc2, 0x1e, 0xe5, 0xf2, 0xbe,
 616         0xfd, 0x3b, 0x94, 0x9f, 0xc4, 0xc4, 0x26, 0x9d,
 617         0xe4, 0x66, 0x1e, 0x19, 0xee, 0x6c, 0x79, 0x97,
 618         0x11, 0x31, 0x4b, 0x0d, 0x01, 0xcb, 0xde, 0xa8,
 619         0xf6, 0x6d, 0x7c, 0x39, 0x46, 0x4e, 0x7e, 0x3f,
 620         0x94, 0x17, 0xdf, 0xa1, 0x7d, 0xd9, 0x1c, 0x8e,
 621         0xbc, 0x7d, 0x33, 0x7d, 0xe3, 0x12, 0x40, 0xca,
 622         0xab, 0x37, 0x11, 0x46, 0xd4, 0xae, 0xef, 0x44,
 623         0xa2, 0xb3, 0x6a, 0x66, 0x0e, 0x0c, 0x90, 0x7f,
 624         0xdf, 0x5c, 0x66, 0x5f, 0xf2, 0x94, 0x9f, 0xa6,
 625         0x73, 0x4f, 0xeb, 0x0d, 0xad, 0xbf, 0xc0, 0x63,
 626         0x5c, 0xdc, 0x46, 0x51, 0xe8, 0x8e, 0x90, 0x19,
 627         0xa8, 0xa4, 0x3c, 0x91, 0x79, 0xfa, 0x7e, 0x58,
 628         0x85, 0x13, 0x55, 0xc5, 0x19, 0x82, 0x37, 0x1b,
 629         0x0a, 0x02, 0x1f, 0x99, 0x6b, 0x18, 0xf1, 0x28,
 630         0x08, 0xa2, 0x73, 0xb8, 0x0f, 0x2e, 0xcd, 0xbf,
 631         0xf3, 0x86, 0x7f, 0xea, 0xef, 0xd0, 0xbb, 0xa6,
 632         0x21, 0xdf, 0x49, 0x73, 0x51, 0xcc, 0x36, 0xd3,
 633         0x3e, 0xa0, 0xf8, 0x44, 0xdf, 0xd3, 0xa6, 0xbe,
 634         0x8a, 0xd4, 0x57, 0xdd, 0x72, 0x94, 0x61, 0x0f,
 635         0x82, 0xd1, 0x07, 0xb8, 0x7c, 0x18, 0x83, 0xdf,
 636         0x3a, 0xe5, 0x50, 0x6a, 0x82, 0x20, 0xac, 0xa9,
 637         0xa8, 0xff, 0xd9, 0xf3, 0x77, 0x33, 0x5a, 0x9e,
 638         0x7f, 0x6d, 0xfe, 0x5d, 0x33, 0x41, 0x42, 0xe7,
 639         0x6c, 0x19, 0xe0, 0x44, 0x8a, 0x15, 0xf6, 0x70,
 640         0x98, 0xb7, 0x68, 0x4d, 0xfa, 0x97, 0x39, 0xb0,
 641         0x8e, 0xe8, 0x84, 0x8b, 0x75, 0x30, 0xb7, 0x7d,
 642         0x92, 0x69, 0x20, 0x9c, 0x81, 0xfb, 0x4b, 0xf4,
 643         0x01, 0x50, 0xeb, 0xce, 0x0c, 0x1c, 0x6c, 0xb5,
 644         0x4a, 0xd7, 0x27, 0x0c, 0xce, 0xbb, 0xe5, 0x85,
 645         0xf0, 0xb6, 0xee, 0xd5, 0x70, 0xdd, 0x3b, 0xfc,
 646         0xd4, 0x99, 0xf1, 0x33, 0xdd, 0x8b, 0xc4, 0x2f,
 647         0xae, 0xab, 0x74, 0x96, 0x32, 0xc7, 0x4c, 0x56,
 648         0x3c, 0x89, 0x0f, 0x96, 0x0b, 0x42, 0xc0, 0xcb,
 649         0xee, 0x0f, 0x0b, 0x8c, 0xfb, 0x7e, 0x47, 0x7b,
 650         0x64, 0x48, 0xfd, 0xb2, 0x00, 0x80, 0x89, 0xa5,
 651         0x13, 0x55, 0x62, 0xfc, 0x8f, 0xe2, 0x42, 0x03,
 652         0xb7, 0x4e, 0x2a, 0x79, 0xb4, 0x82, 0xea, 0x23,
 653         0x49, 0xda, 0xaf, 0x52, 0x63, 0x1e, 0x60, 0x03,
 654         0x89, 0x06, 0x44, 0x46, 0x08, 0xc3, 0xc4, 0x87,
 655         0x70, 0x2e, 0xda, 0x94, 0xad, 0x6b, 0xe0, 0xe4,
 656         0xd1, 0x8a, 0x06, 0xc2, 0xa8, 0xc0, 0xa7, 0x43,
 657         0x3c, 0x47, 0x52, 0x0e, 0xc3, 0x77, 0x81, 0x11,
 658         0x67, 0x0e, 0xa0, 0x70, 0x04, 0x47, 0x29, 0x40,
 659         0x86, 0x0d, 0x34, 0x56, 0xa7, 0xc9, 0x35, 0x59,
 660         0x68, 0xdc, 0x93, 0x81, 0x70, 0xee, 0x86, 0xd9,
 661         0x80, 0x06, 0x40, 0x4f, 0x1a, 0x0d, 0x40, 0x30,
 662         0x0b, 0xcb, 0x96, 0x47, 0xc1, 0xb7, 0x52, 0xfd,
 663         0x56, 0xe0, 0x72, 0x4b, 0xfb, 0xbd, 0x92, 0x45,
 664         0x61, 0x71, 0xc2, 0x33, 0x11, 0xbf, 0x52, 0x83,
 665         0x79, 0x26, 0xe0, 0x49, 0x6b, 0xb7, 0x05, 0x8b,
 666         0xe8, 0x0e, 0x87, 0x31, 0xd7, 0x9d, 0x8a, 0xf5,
 667         0xc0, 0x5f, 0x2e, 0x58, 0x4a, 0xdb, 0x11, 0xb3,
 668         0x6c, 0x30, 0x2a, 0x46, 0x19, 0xe3, 0x27, 0x84,
 669         0x1f, 0x63, 0x6e, 0xf6, 0x57, 0xc7, 0xc9, 0xd8,
 670         0x5e, 0xba, 0xb3, 0x87, 0xd5, 0x83, 0x26, 0x34,
 671         0x21, 0x9e, 0x65, 0xde, 0x42, 0xd3, 0xbe, 0x7b,
 672         0xbc, 0x91, 0x71, 0x44, 0x4d, 0x99, 0x3b, 0x31,
 673         0xe5, 0x3f, 0x11, 0x4e, 0x7f, 0x13, 0x51, 0x3b,
 674         0xae, 0x79, 0xc9, 0xd3, 0x81, 0x8e, 0x25, 0x40,
 675         0x10, 0xfc, 0x07, 0x1e, 0xf9, 0x7b, 0x9a, 0x4b,
 676         0x6c, 0xe3, 0xb3, 0xad, 0x1a, 0x0a, 0xdd, 0x9e,
 677         0x59, 0x0c, 0xa2, 0xcd, 0xae, 0x48, 0x4a, 0x38,
 678         0x5b, 0x47, 0x41, 0x94, 0x65, 0x6b, 0xbb, 0xeb,
 679         0x5b, 0xe3, 0xaf, 0x07, 0x5b, 0xd4, 0x4a, 0xa2,
 680         0xc9, 0x5d, 0x2f, 0x64, 0x03, 0xd7, 0x3a, 0x2c,
 681         0x6e, 0xce, 0x76, 0x95, 0xb4, 0xb3, 0xc0, 0xf1,
 682         0xe2, 0x45, 0x73, 0x7a, 0x5c, 0xab, 0xc1, 0xfc,
 683         0x02, 0x8d, 0x81, 0x29, 0xb3, 0xac, 0x07, 0xec,
 684         0x40, 0x7d, 0x45, 0xd9, 0x7a, 0x59, 0xee, 0x34,
 685         0xf0, 0xe9, 0xd5, 0x7b, 0x96, 0xb1, 0x3d, 0x95,
 686         0xcc, 0x86, 0xb5, 0xb6, 0x04, 0x2d, 0xb5, 0x92,
 687         0x7e, 0x76, 0xf4, 0x06, 0xa9, 0xa3, 0x12, 0x0f,
 688         0xb1, 0xaf, 0x26, 0xba, 0x7c, 0xfc, 0x7e, 0x1c,
 689         0xbc, 0x2c, 0x49, 0x97, 0x53, 0x60, 0x13, 0x0b,
 690         0xa6, 0x61, 0x83, 0x89, 0x42, 0xd4, 0x17, 0x0c,
 691         0x6c, 0x26, 0x52, 0xc3, 0xb3, 0xd4, 0x67, 0xf5,
 692         0xe3, 0x04, 0xb7, 0xf4, 0xcb, 0x80, 0xb8, 0xcb,
 693         0x77, 0x56, 0x3e, 0xaa, 0x57, 0x54, 0xee, 0xb4,
 694         0x2c, 0x67, 0xcf, 0xf2, 0xdc, 0xbe, 0x55, 0xf9,
 695         0x43, 0x1f, 0x6e, 0x22, 0x97, 0x67, 0x7f, 0xc4,
 696         0xef, 0xb1, 0x26, 0x31, 0x1e, 0x27, 0xdf, 0x41,
 697         0x80, 0x47, 0x6c, 0xe2, 0xfa, 0xa9, 0x8c, 0x2a,
 698         0xf6, 0xf2, 0xab, 0xf0, 0x15, 0xda, 0x6c, 0xc8,
 699         0xfe, 0xb5, 0x23, 0xde, 0xa9, 0x05, 0x3f, 0x06,
 700         0x54, 0x4c, 0xcd, 0xe1, 0xab, 0xfc, 0x0e, 0x62,
 701         0x33, 0x31, 0x73, 0x2c, 0x76, 0xcb, 0xb4, 0x47,
 702         0x1e, 0x20, 0xad, 0xd8, 0xf2, 0x31, 0xdd, 0xc4,
 703         0x8b, 0x0c, 0x77, 0xbe, 0xe1, 0x8b, 0x26, 0x00,
 704         0x02, 0x58, 0xd6, 0x8d, 0xef, 0xad, 0x74, 0x67,
 705         0xab, 0x3f, 0xef, 0xcb, 0x6f, 0xb0, 0xcc, 0x81,
 706         0x44, 0x4c, 0xaf, 0xe9, 0x49, 0x4f, 0xdb, 0xa0,
 707         0x25, 0xa4, 0xf0, 0x89, 0xf1, 0xbe, 0xd8, 0x10,
 708         0xff, 0xb1, 0x3b, 0x4b, 0xfa, 0x98, 0xf5, 0x79,
 709         0x6d, 0x1e, 0x69, 0x4d, 0x57, 0xb1, 0xc8, 0x19,
 710         0x1b, 0xbd, 0x1e, 0x8c, 0x84, 0xb7, 0x7b, 0xe8,
 711         0xd2, 0x2d, 0x09, 0x41, 0x41, 0x37, 0x3d, 0xb1,
 712         0x6f, 0x26, 0x5d, 0x71, 0x16, 0x3d, 0xb7, 0x83,
 713         0x27, 0x2c, 0xa7, 0xb6, 0x50, 0xbd, 0x91, 0x86,
 714         0xab, 0x24, 0xa1, 0x38, 0xfd, 0xea, 0x71, 0x55,
 715         0x7e, 0x9a, 0x07, 0x77, 0x4b, 0xfa, 0x61, 0x66,
 716         0x20, 0x1e, 0x28, 0x95, 0x18, 0x1b, 0xa4, 0xa0,
 717         0xfd, 0xc0, 0x89, 0x72, 0x43, 0xd9, 0x3b, 0x49,
 718         0x5a, 0x3f, 0x9d, 0xbf, 0xdb, 0xb4, 0x46, 0xea,
 719         0x42, 0x01, 0x77, 0x23, 0x68, 0x95, 0xb6, 0x24,
 720         0xb3, 0xa8, 0x6c, 0x28, 0x3b, 0x11, 0x40, 0x7e,
 721         0x18, 0x65, 0x6d, 0xd8, 0x24, 0x42, 0x7d, 0x88,
 722         0xc0, 0x52, 0xd9, 0x05, 0xe4, 0x95, 0x90, 0x87,
 723         0x8c, 0xf4, 0xd0, 0x6b, 0xb9, 0x83, 0x99, 0x34,
 724         0x6d, 0xfe, 0x54, 0x40, 0x94, 0x52, 0x21, 0x4f,
 725         0x14, 0x25, 0xc5, 0xd6, 0x5e, 0x95, 0xdc, 0x0a,
 726         0x2b, 0x89, 0x20, 0x11, 0x84, 0x48, 0xd6, 0x3a,
 727         0xcd, 0x5c, 0x24, 0xad, 0x62, 0xe3, 0xb1, 0x93,
 728         0x25, 0x8d, 0xcd, 0x7e, 0xfc, 0x27, 0xa3, 0x37,
 729         0xfd, 0x84, 0xfc, 0x1b, 0xb2, 0xf1, 0x27, 0x38,
 730         0x5a, 0xb7, 0xfc, 0xf2, 0xfa, 0x95, 0x66, 0xd4,
 731         0xfb, 0xba, 0xa7, 0xd7, 0xa3, 0x72, 0x69, 0x48,
 732         0x48, 0x8c, 0xeb, 0x28, 0x89, 0xfe, 0x33, 0x65,
 733         0x5a, 0x36, 0x01, 0x7e, 0x06, 0x79, 0x0a, 0x09,
 734         0x3b, 0x74, 0x11, 0x9a, 0x6e, 0xbf, 0xd4, 0x9e,
 735         0x58, 0x90, 0x49, 0x4f, 0x4d, 0x08, 0xd4, 0xe5,
 736         0x4a, 0x09, 0x21, 0xef, 0x8b, 0xb8, 0x74, 0x3b,
 737         0x91, 0xdd, 0x36, 0x85, 0x60, 0x2d, 0xfa, 0xd4,
 738         0x45, 0x7b, 0x45, 0x53, 0xf5, 0x47, 0x87, 0x7e,
 739         0xa6, 0x37, 0xc8, 0x78, 0x7a, 0x68, 0x9d, 0x8d,
 740         0x65, 0x2c, 0x0e, 0x91, 0x5c, 0xa2, 0x60, 0xf0,
 741         0x8e, 0x3f, 0xe9, 0x1a, 0xcd, 0xaa, 0xe7, 0xd5,
 742         0x77, 0x18, 0xaf, 0xc9, 0xbc, 0x18, 0xea, 0x48,
 743         0x1b, 0xfb, 0x22, 0x48, 0x70, 0x16, 0x29, 0x9e,
 744         0x5b, 0xc1, 0x2c, 0x66, 0x23, 0xbc, 0xf0, 0x1f,
 745         0xef, 0xaf, 0xe4, 0xd6, 0x04, 0x19, 0x82, 0x7a,
 746         0x0b, 0xba, 0x4b, 0x46, 0xb1, 0x6a, 0x85, 0x5d,
 747         0xb4, 0x73, 0xd6, 0x21, 0xa1, 0x71, 0x60, 0x14,
 748         0xee, 0x0a, 0x77, 0xc4, 0x66, 0x2e, 0xf9, 0x69,
 749         0x30, 0xaf, 0x41, 0x0b, 0xc8, 0x83, 0x3c, 0x53,
 750         0x99, 0x19, 0x27, 0x46, 0xf7, 0x41, 0x6e, 0x56,
 751         0xdc, 0x94, 0x28, 0x67, 0x4e, 0xb7, 0x25, 0x48,
 752         0x8a, 0xc2, 0xe0, 0x60, 0x96, 0xcc, 0x18, 0xf4,
 753         0x84, 0xdd, 0xa7, 0x5e, 0x3e, 0x05, 0x0b, 0x26,
 754         0x26, 0xb2, 0x5c, 0x1f, 0x57, 0x1a, 0x04, 0x7e,
 755         0x6a, 0xe3, 0x2f, 0xb4, 0x35, 0xb6, 0x38, 0x40,
 756         0x40, 0xcd, 0x6f, 0x87, 0x2e, 0xef, 0xa3, 0xd7,
 757         0xa9, 0xc2, 0xe8, 0x0d, 0x27, 0xdf, 0x44, 0x62,
 758         0x99, 0xa0, 0xfc, 0xcf, 0x81, 0x78, 0xcb, 0xfe,
 759         0xe5, 0xa0, 0x03, 0x4e, 0x6c, 0xd7, 0xf4, 0xaf,
 760         0x7a, 0xbb, 0x61, 0x82, 0xfe, 0x71, 0x89, 0xb2,
 761         0x22, 0x7c, 0x8e, 0x83, 0x04, 0xce, 0xf6, 0x5d,
 762         0x84, 0x8f, 0x95, 0x6a, 0x7f, 0xad, 0xfd, 0x32,
 763         0x9c, 0x5e, 0xe4, 0x9c, 0x89, 0x60, 0x54, 0xaa,
 764         0x96, 0x72, 0xd2, 0xd7, 0x36, 0x85, 0xa9, 0x45,
 765         0xd2, 0x2a, 0xa1, 0x81, 0x49, 0x6f, 0x7e, 0x04,
 766         0xfa, 0xe2, 0xfe, 0x90, 0x26, 0x77, 0x5a, 0x33,
 767         0xb8, 0x04, 0x9a, 0x7a, 0xe6, 0x4c, 0x4f, 0xad,
 768         0x72, 0x96, 0x08, 0x28, 0x58, 0x13, 0xf8, 0xc4,
 769         0x1c, 0xf0, 0xc3, 0x45, 0x95, 0x49, 0x20, 0x8c,
 770         0x9f, 0x39, 0x70, 0xe1, 0x77, 0xfe, 0xd5, 0x4b,
 771         0xaf, 0x86, 0xda, 0xef, 0x22, 0x06, 0x83, 0x36,
 772         0x29, 0x12, 0x11, 0x40, 0xbc, 0x3b, 0x86, 0xaa,
 773         0xaa, 0x65, 0x60, 0xc3, 0x80, 0xca, 0xed, 0xa9,
 774         0xf3, 0xb0, 0x79, 0x96, 0xa2, 0x55, 0x27, 0x28,
 775         0x55, 0x73, 0x26, 0xa5, 0x50, 0xea, 0x92, 0x4b,
 776         0x3c, 0x5c, 0x82, 0x33, 0xf0, 0x01, 0x3f, 0x03,
 777         0xc1, 0x08, 0x05, 0xbf, 0x98, 0xf4, 0x9b, 0x6d,
 778         0xa5, 0xa8, 0xb4, 0x82, 0x0c, 0x06, 0xfa, 0xff,
 779         0x2d, 0x08, 0xf3, 0x05, 0x4f, 0x57, 0x2a, 0x39,
 780         0xd4, 0x83, 0x0d, 0x75, 0x51, 0xd8, 0x5b, 0x1b,
 781         0xd3, 0x51, 0x5a, 0x32, 0x2a, 0x9b, 0x32, 0xb2,
 782         0xf2, 0xa4, 0x96, 0x12, 0xf2, 0xae, 0x40, 0x34,
 783         0x67, 0xa8, 0xf5, 0x44, 0xd5, 0x35, 0x53, 0xfe,
 784         0xa3, 0x60, 0x96, 0x63, 0x0f, 0x1f, 0x6e, 0xb0,
 785         0x5a, 0x42, 0xa6, 0xfc, 0x51, 0x0b, 0x60, 0x27,
 786         0xbc, 0x06, 0x71, 0xed, 0x65, 0x5b, 0x23, 0x86,
 787         0x4a, 0x07, 0x3b, 0x22, 0x07, 0x46, 0xe6, 0x90,
 788         0x3e, 0xf3, 0x25, 0x50, 0x1b, 0x4c, 0x7f, 0x03,
 789         0x08, 0xa8, 0x36, 0x6b, 0x87, 0xe5, 0xe3, 0xdb,
 790         0x9a, 0x38, 0x83, 0xff, 0x9f, 0x1a, 0x9f, 0x57,
 791         0xa4, 0x2a, 0xf6, 0x37, 0xbc, 0x1a, 0xff, 0xc9,
 792         0x1e, 0x35, 0x0c, 0xc3, 0x7c, 0xa3, 0xb2, 0xe5,
 793         0xd2, 0xc6, 0xb4, 0x57, 0x47, 0xe4, 0x32, 0x16,
 794         0x6d, 0xa9, 0xae, 0x64, 0xe6, 0x2d, 0x8d, 0xc5,
 795         0x8d, 0x50, 0x8e, 0xe8, 0x1a, 0x22, 0x34, 0x2a,
 796         0xd9, 0xeb, 0x51, 0x90, 0x4a, 0xb1, 0x41, 0x7d,
 797         0x64, 0xf9, 0xb9, 0x0d, 0xf6, 0x23, 0x33, 0xb0,
 798         0x33, 0xf4, 0xf7, 0x3f, 0x27, 0x84, 0xc6, 0x0f,
 799         0x54, 0xa5, 0xc0, 0x2e, 0xec, 0x0b, 0x3a, 0x48,
 800         0x6e, 0x80, 0x35, 0x81, 0x43, 0x9b, 0x90, 0xb1,
 801         0xd0, 0x2b, 0xea, 0x21, 0xdc, 0xda, 0x5b, 0x09,
 802         0xf4, 0xcc, 0x10, 0xb4, 0xc7, 0xfe, 0x79, 0x51,
 803         0xc3, 0xc5, 0xac, 0x88, 0x74, 0x84, 0x0b, 0x4b,
 804         0xca, 0x79, 0x16, 0x29, 0xfb, 0x69, 0x54, 0xdf,
 805         0x41, 0x7e, 0xe9, 0xc7, 0x8e, 0xea, 0xa5, 0xfe,
 806         0xfc, 0x76, 0x0e, 0x90, 0xc4, 0x92, 0x38, 0xad,
 807         0x7b, 0x48, 0xe6, 0x6e, 0xf7, 0x21, 0xfd, 0x4e,
 808         0x93, 0x0a, 0x7b, 0x41, 0x83, 0x68, 0xfb, 0x57,
 809         0x51, 0x76, 0x34, 0xa9, 0x6c, 0x00, 0xaa, 0x4f,
 810         0x66, 0x65, 0x98, 0x4a, 0x4f, 0xa3, 0xa0, 0xef,
 811         0x69, 0x3f, 0xe3, 0x1c, 0x92, 0x8c, 0xfd, 0xd8,
 812         0xe8, 0xde, 0x7c, 0x7f, 0x3e, 0x84, 0x8e, 0x69,
 813         0x3c, 0xf1, 0xf2, 0x05, 0x46, 0xdc, 0x2f, 0x9d,
 814         0x5e, 0x6e, 0x4c, 0xfb, 0xb5, 0x99, 0x2a, 0x59,
 815         0x63, 0xc1, 0x34, 0xbc, 0x57, 0xc0, 0x0d, 0xb9,
 816         0x61, 0x25, 0xf3, 0x33, 0x23, 0x51, 0xb6, 0x0d,
 817         0x07, 0xa6, 0xab, 0x94, 0x4a, 0xb7, 0x2a, 0xea,
 818         0xee, 0xac, 0xa3, 0xc3, 0x04, 0x8b, 0x0e, 0x56,
 819         0xfe, 0x44, 0xa7, 0x39, 0xe2, 0xed, 0xed, 0xb4,
 820         0x22, 0x2b, 0xac, 0x12, 0x32, 0x28, 0x91, 0xd8,
 821         0xa5, 0xab, 0xff, 0x5f, 0xe0, 0x4b, 0xda, 0x78,
 822         0x17, 0xda, 0xf1, 0x01, 0x5b, 0xcd, 0xe2, 0x5f,
 823         0x50, 0x45, 0x73, 0x2b, 0xe4, 0x76, 0x77, 0xf4,
 824         0x64, 0x1d, 0x43, 0xfb, 0x84, 0x7a, 0xea, 0x91,
 825         0xae, 0xf9, 0x9e, 0xb7, 0xb4, 0xb0, 0x91, 0x5f,
 826         0x16, 0x35, 0x9a, 0x11, 0xb8, 0xc7, 0xc1, 0x8c,
 827         0xc6, 0x10, 0x8d, 0x2f, 0x63, 0x4a, 0xa7, 0x57,
 828         0x3a, 0x51, 0xd6, 0x32, 0x2d, 0x64, 0x72, 0xd4,
 829         0x66, 0xdc, 0x10, 0xa6, 0x67, 0xd6, 0x04, 0x23,
 830         0x9d, 0x0a, 0x11, 0x77, 0xdd, 0x37, 0x94, 0x17,
 831         0x3c, 0xbf, 0x8b, 0x65, 0xb0, 0x2e, 0x5e, 0x66,
 832         0x47, 0x64, 0xac, 0xdd, 0xf0, 0x84, 0xfd, 0x39,
 833         0xfa, 0x15, 0x5d, 0xef, 0xae, 0xca, 0xc1, 0x36,
 834         0xa7, 0x5c, 0xbf, 0xc7, 0x08, 0xc2, 0x66, 0x00,
 835         0x74, 0x74, 0x4e, 0x27, 0x3f, 0x55, 0x8a, 0xb7,
 836         0x38, 0x66, 0x83, 0x6d, 0xcf, 0x99, 0x9e, 0x60,
 837         0x8f, 0xdd, 0x2e, 0x62, 0x22, 0x0e, 0xef, 0x0c,
 838         0x98, 0xa7, 0x85, 0x74, 0x3b, 0x9d, 0xec, 0x9e,
 839         0xa9, 0x19, 0x72, 0xa5, 0x7f, 0x2c, 0x39, 0xb7,
 840         0x7d, 0xb7, 0xf1, 0x12, 0x65, 0x27, 0x4b, 0x5a,
 841         0xde, 0x17, 0xfe, 0xad, 0x44, 0xf3, 0x20, 0x4d,
 842         0xfd, 0xe4, 0x1f, 0xb5, 0x81, 0xb0, 0x36, 0x37,
 843         0x08, 0x6f, 0xc3, 0x0c, 0xe9, 0x85, 0x98, 0x82,
 844         0xa9, 0x62, 0x0c, 0xc4, 0x97, 0xc0, 0x50, 0xc8,
 845         0xa7, 0x3c, 0x50, 0x9f, 0x43, 0xb9, 0xcd, 0x5e,
 846         0x4d, 0xfa, 0x1c, 0x4b, 0x0b, 0xa9, 0x98, 0x85,
 847         0x38, 0x92, 0xac, 0x8d, 0xe4, 0xad, 0x9b, 0x98,
 848         0xab, 0xd9, 0x38, 0xac, 0x62, 0x52, 0xa3, 0x22,
 849         0x63, 0x0f, 0xbf, 0x95, 0x48, 0xdf, 0x69, 0xe7,
 850         0x8b, 0x33, 0xd5, 0xb2, 0xbd, 0x05, 0x49, 0x49,
 851         0x9d, 0x57, 0x73, 0x19, 0x33, 0xae, 0xfa, 0x33,
 852         0xf1, 0x19, 0xa8, 0x80, 0xce, 0x04, 0x9f, 0xbc,
 853         0x1d, 0x65, 0x82, 0x1b, 0xe5, 0x3a, 0x51, 0xc8,
 854         0x1c, 0x21, 0xe3, 0x5d, 0xf3, 0x7d, 0x9b, 0x2f,
 855         0x2c, 0x1d, 0x4a, 0x7f, 0x9b, 0x68, 0x35, 0xa3,
 856         0xb2, 0x50, 0xf7, 0x62, 0x79, 0xcd, 0xf4, 0x98,
 857         0x4f, 0xe5, 0x63, 0x7c, 0x3e, 0x45, 0x31, 0x8c,
 858         0x16, 0xa0, 0x12, 0xc8, 0x58, 0xce, 0x39, 0xa6,
 859         0xbc, 0x54, 0xdb, 0xc5, 0xe0, 0xd5, 0xba, 0xbc,
 860         0xb9, 0x04, 0xf4, 0x8d, 0xe8, 0x2f, 0x15, 0x9d,
 861 };
 862
 863 /* 100 test cases */
 864 static struct crc_test {
 865         u32 crc;        /* random starting crc */
 866         u32 start;      /* random 6 bit offset in buf */
 867         u32 length;     /* random 11 bit length of test */
 868         u32 crc_le;     /* expected crc32_le result */
 869         u32 crc_be;     /* expected crc32_be result */
 870         u32 crc32c_le;  /* expected crc32c_le result */
 871 } const test[] __initconst =
 872 {
 873         {0x674bf11d, 0x00000038, 0x00000542, 0x0af6d466, 0xd8b6e4c1, 0xf6e93d6c},
 874         {0x35c672c6, 0x0000003a, 0x000001aa, 0xc6d3dfba, 0x28aaf3ad, 0x0fe92aca},
 875         {0x496da28e, 0x00000039, 0x000005af, 0xd933660f, 0x5d57e81f, 0x52e1ebb8},
 876         {0x09a9b90e, 0x00000027, 0x000001f8, 0xb45fe007, 0xf45fca9a, 0x0798af9a},
 877         {0xdc97e5a9, 0x00000025, 0x000003b6, 0xf81a3562, 0xe0126ba2, 0x18eb3152},
 878         {0x47c58900, 0x0000000a, 0x000000b9, 0x8e58eccf, 0xf3afc793, 0xd00d08c7},
 879         {0x292561e8, 0x0000000c, 0x00000403, 0xa2ba8aaf, 0x0b797aed, 0x8ba966bc},
 880         {0x415037f6, 0x00000003, 0x00000676, 0xa17d52e8, 0x7f0fdf35, 0x11d694a2},
 881         {0x3466e707, 0x00000026, 0x00000042, 0x258319be, 0x75c484a2, 0x6ab3208d},
 882         {0xafd1281b, 0x00000023, 0x000002ee, 0x4428eaf8, 0x06c7ad10, 0xba4603c5},
 883         {0xd3857b18, 0x00000028, 0x000004a2, 0x5c430821, 0xb062b7cb, 0xe6071c6f},
 884         {0x1d825a8f, 0x0000002b, 0x0000050b, 0xd2c45f0c, 0xd68634e0, 0x179ec30a},
 885         {0x5033e3bc, 0x0000000b, 0x00000078, 0xa3ea4113, 0xac6d31fb, 0x0903beb8},
 886         {0x94f1fb5e, 0x0000000f, 0x000003a2, 0xfbfc50b1, 0x3cfe50ed, 0x6a7cb4fa},
 887         {0xc9a0fe14, 0x00000009, 0x00000473, 0x5fb61894, 0x87070591, 0xdb535801},
 888         {0x88a034b1, 0x0000001c, 0x000005ad, 0xc1b16053, 0x46f95c67, 0x92bed597},
 889         {0xf0f72239, 0x00000020, 0x0000026d, 0xa6fa58f3, 0xf8c2c1dd, 0x192a3f1b},
 890         {0xcc20a5e3, 0x0000003b, 0x0000067a, 0x7740185a, 0x308b979a, 0xccbaec1a},
 891         {0xce589c95, 0x0000002b, 0x00000641, 0xd055e987, 0x40aae25b, 0x7eabae4d},
 892         {0x78edc885, 0x00000035, 0x000005be, 0xa39cb14b, 0x035b0d1f, 0x28c72982},
 893         {0x9d40a377, 0x0000003b, 0x00000038, 0x1f47ccd2, 0x197fbc9d, 0xc3cd4d18},
 894         {0x703d0e01, 0x0000003c, 0x000006f1, 0x88735e7c, 0xfed57c5a, 0xbca8f0e7},
 895         {0x776bf505, 0x0000000f, 0x000005b2, 0x5cc4fc01, 0xf32efb97, 0x713f60b3},
 896         {0x4a3e7854, 0x00000027, 0x000004b8, 0x8d923c82, 0x0cbfb4a2, 0xebd08fd5},
 897         {0x209172dd, 0x0000003b, 0x00000356, 0xb89e9c2b, 0xd7868138, 0x64406c59},
 898         {0x3ba4cc5b, 0x0000002f, 0x00000203, 0xe51601a9, 0x5b2a1032, 0x7421890e},
 899         {0xfc62f297, 0x00000000, 0x00000079, 0x71a8e1a2, 0x5d88685f, 0xe9347603},
 900         {0x64280b8b, 0x00000016, 0x000007ab, 0x0fa7a30c, 0xda3a455f, 0x1bef9060},
 901         {0x97dd724b, 0x00000033, 0x000007ad, 0x5788b2f4, 0xd7326d32, 0x34720072},
 902         {0x61394b52, 0x00000035, 0x00000571, 0xc66525f1, 0xcabe7fef, 0x48310f59},
 903         {0x29b4faff, 0x00000024, 0x0000006e, 0xca13751e, 0x993648e0, 0x783a4213},
 904         {0x29bfb1dc, 0x0000000b, 0x00000244, 0x436c43f7, 0x429f7a59, 0x9e8efd41},
 905         {0x86ae934b, 0x00000035, 0x00000104, 0x0760ec93, 0x9cf7d0f4, 0xfc3d34a5},
 906         {0xc4c1024e, 0x0000002e, 0x000006b1, 0x6516a3ec, 0x19321f9c, 0x17a52ae2},
 907         {0x3287a80a, 0x00000026, 0x00000496, 0x0b257eb1, 0x754ebd51, 0x886d935a},
 908         {0xa4db423e, 0x00000023, 0x0000045d, 0x9b3a66dc, 0x873e9f11, 0xeaaeaeb2},
 909         {0x7a1078df, 0x00000015, 0x0000014a, 0x8c2484c5, 0x6a628659, 0x8e900a4b},
 910         {0x6048bd5b, 0x00000006, 0x0000006a, 0x897e3559, 0xac9961af, 0xd74662b1},
 911         {0xd8f9ea20, 0x0000003d, 0x00000277, 0x60eb905b, 0xed2aaf99, 0xd26752ba},
 912         {0xea5ec3b4, 0x0000002a, 0x000004fe, 0x869965dc, 0x6c1f833b, 0x8b1fcd62},
 913         {0x2dfb005d, 0x00000016, 0x00000345, 0x6a3b117e, 0xf05e8521, 0xf54342fe},
 914         {0x5a214ade, 0x00000020, 0x000005b6, 0x467f70be, 0xcb22ccd3, 0x5b95b988},
 915         {0xf0ab9cca, 0x00000032, 0x00000515, 0xed223df3, 0x7f3ef01d, 0x2e1176be},
 916         {0x91b444f9, 0x0000002e, 0x000007f8, 0x84e9a983, 0x5676756f, 0x66120546},
 917         {0x1b5d2ddb, 0x0000002e, 0x0000012c, 0xba638c4c, 0x3f42047b, 0xf256a5cc},
 918         {0xd824d1bb, 0x0000003a, 0x000007b5, 0x6288653b, 0x3a3ebea0, 0x4af1dd69},
 919         {0x0470180c, 0x00000034, 0x000001f0, 0x9d5b80d6, 0x3de08195, 0x56f0a04a},
 920         {0xffaa3a3f, 0x00000036, 0x00000299, 0xf3a82ab8, 0x53e0c13d, 0x74f6b6b2},
 921         {0x6406cfeb, 0x00000023, 0x00000600, 0xa920b8e8, 0xe4e2acf4, 0x085951fd},
 922         {0xb24aaa38, 0x0000003e, 0x000004a1, 0x657cc328, 0x5077b2c3, 0xc65387eb},
 923         {0x58b2ab7c, 0x00000039, 0x000002b4, 0x3a17ee7e, 0x9dcb3643, 0x1ca9257b},
 924         {0x3db85970, 0x00000006, 0x000002b6, 0x95268b59, 0xb9812c10, 0xfd196d76},
 925         {0x857830c5, 0x00000003, 0x00000590, 0x4ef439d5, 0xf042161d, 0x5ef88339},
 926         {0xe1fcd978, 0x0000003e, 0x000007d8, 0xae8d8699, 0xce0a1ef5, 0x2c3714d9},
 927         {0xb982a768, 0x00000016, 0x000006e0, 0x62fad3df, 0x5f8a067b, 0x58576548},
 928         {0x1d581ce8, 0x0000001e, 0x0000058b, 0xf0f5da53, 0x26e39eee, 0xfd7c57de},
 929         {0x2456719b, 0x00000025, 0x00000503, 0x4296ac64, 0xd50e4c14, 0xd5fedd59},
 930         {0xfae6d8f2, 0x00000000, 0x0000055d, 0x057fdf2e, 0x2a31391a, 0x1cc3b17b},
 931         {0xcba828e3, 0x00000039, 0x000002ce, 0xe3f22351, 0x8f00877b, 0x270eed73},
 932         {0x13d25952, 0x0000000a, 0x0000072d, 0x76d4b4cc, 0x5eb67ec3, 0x91ecbb11},
 933         {0x0342be3f, 0x00000015, 0x00000599, 0xec75d9f1, 0x9d4d2826, 0x05ed8d0c},
 934         {0xeaa344e0, 0x00000014, 0x000004d8, 0x72a4c981, 0x2064ea06, 0x0b09ad5b},
 935         {0xbbb52021, 0x0000003b, 0x00000272, 0x04af99fc, 0xaf042d35, 0xf8d511fb},
 936         {0xb66384dc, 0x0000001d, 0x000007fc, 0xd7629116, 0x782bd801, 0x5ad832cc},
 937         {0x616c01b6, 0x00000022, 0x000002c8, 0x5b1dab30, 0x783ce7d2, 0x1214d196},
 938         {0xce2bdaad, 0x00000016, 0x0000062a, 0x932535c8, 0x3f02926d, 0x5747218a},
 939         {0x00fe84d7, 0x00000005, 0x00000205, 0x850e50aa, 0x753d649c, 0xde8f14de},
 940         {0xbebdcb4c, 0x00000006, 0x0000055d, 0xbeaa37a2, 0x2d8c9eba, 0x3563b7b9},
 941         {0xd8b1a02a, 0x00000010, 0x00000387, 0x5017d2fc, 0x503541a5, 0x071475d0},
 942         {0x3b96cad2, 0x00000036, 0x00000347, 0x1d2372ae, 0x926cd90b, 0x54c79d60},
 943         {0xc94c1ed7, 0x00000005, 0x0000038b, 0x9e9fdb22, 0x144a9178, 0x4c53eee6},
 944         {0x1aad454e, 0x00000025, 0x000002b2, 0xc3f6315c, 0x5c7a35b3, 0x10137a3c},
 945         {0xa4fec9a6, 0x00000000, 0x000006d6, 0x90be5080, 0xa4107605, 0xaa9d6c73},
 946         {0x1bbe71e2, 0x0000001f, 0x000002fd, 0x4e504c3b, 0x284ccaf1, 0xb63d23e7},
 947         {0x4201c7e4, 0x00000002, 0x000002b7, 0x7822e3f9, 0x0cc912a9, 0x7f53e9cf},
 948         {0x23fddc96, 0x00000003, 0x00000627, 0x8a385125, 0x07767e78, 0x13c1cd83},
 949         {0xd82ba25c, 0x00000016, 0x0000063e, 0x98e4148a, 0x283330c9, 0x49ff5867},
 950         {0x786f2032, 0x0000002d, 0x0000060f, 0xf201600a, 0xf561bfcd, 0x8467f211},
 951         {0xfebe4e1f, 0x0000002a, 0x000004f2, 0x95e51961, 0xfd80dcab, 0x3f9683b2},
 952         {0x1a6e0a39, 0x00000008, 0x00000672, 0x8af6c2a5, 0x78dd84cb, 0x76a3f874},
 953         {0x56000ab8, 0x0000000e, 0x000000e5, 0x36bacb8f, 0x22ee1f77, 0x863b702f},
 954         {0x4717fe0c, 0x00000000, 0x000006ec, 0x8439f342, 0x5c8e03da, 0xdc6c58ff},
 955         {0xd5d5d68e, 0x0000003c, 0x000003a3, 0x46fff083, 0x177d1b39, 0x0622cc95},
 956         {0xc25dd6c6, 0x00000024, 0x000006c0, 0x5ceb8eb4, 0x892b0d16, 0xe85605cd},
 957         {0xe9b11300, 0x00000023, 0x00000683, 0x07a5d59a, 0x6c6a3208, 0x31da5f06},
 958         {0x95cd285e, 0x00000001, 0x00000047, 0x7b3a4368, 0x0202c07e, 0xa1f2e784},
 959         {0xd9245a25, 0x0000001e, 0x000003a6, 0xd33c1841, 0x1936c0d5, 0xb07cc616},
 960         {0x103279db, 0x00000006, 0x0000039b, 0xca09b8a0, 0x77d62892, 0xbf943b6c},
 961         {0x1cba3172, 0x00000027, 0x000001c8, 0xcb377194, 0xebe682db, 0x2c01af1c},
 962         {0x8f613739, 0x0000000c, 0x000001df, 0xb4b0bc87, 0x7710bd43, 0x0fe5f56d},
 963         {0x1c6aa90d, 0x0000001b, 0x0000053c, 0x70559245, 0xda7894ac, 0xf8943b2d},
 964         {0xaabe5b93, 0x0000003d, 0x00000715, 0xcdbf42fa, 0x0c3b99e7, 0xe4d89272},
 965         {0xf15dd038, 0x00000006, 0x000006db, 0x6e104aea, 0x8d5967f2, 0x7c2f6bbb},
 966         {0x584dd49c, 0x00000020, 0x000007bc, 0x36b6cfd6, 0xad4e23b2, 0xabbf388b},
 967         {0x5d8c9506, 0x00000020, 0x00000470, 0x4c62378e, 0x31d92640, 0x1dca1f4e},
 968         {0xb80d17b0, 0x00000032, 0x00000346, 0x22a5bb88, 0x9a7ec89f, 0x5c170e23},
 969         {0xdaf0592e, 0x00000023, 0x000007b0, 0x3cab3f99, 0x9b1fdd99, 0xc0e9d672},
 970         {0x4793cc85, 0x0000000d, 0x00000706, 0xe82e04f6, 0xed3db6b7, 0xc18bdc86},
 971         {0x82ebf64e, 0x00000009, 0x000007c3, 0x69d590a9, 0x9efa8499, 0xa874fcdd},
 972         {0xb18a0319, 0x00000026, 0x000007db, 0x1cf98dcc, 0x8fa9ad6a, 0x9dc0bb48},
 973 };
 974
 975 #include <linux/time.h>
 976
 977 static int __init crc32c_test(void)
 978 {
 979         int i;
 980         int errors = 0;
 981         int bytes = 0;
 982         u64 nsec;
 983         unsigned long flags;
 984
 985         /* keep static to prevent cache warming code from
 986          * getting eliminated by the compiler */
 987         static u32 crc;
 988
 989         /* pre-warm the cache */
 990         for (i = 0; i < 100; i++) {
 991                 bytes += 2*test[i].length;
 992
 993                 crc ^= __crc32c_le(test[i].crc, test_buf +
 994                     test[i].start, test[i].length);
 995         }
 996
 997         /* reduce OS noise */
 998         local_irq_save(flags);
 999         local_irq_disable();
1000
1001         nsec = ktime_get_ns();
1002         for (i = 0; i < 100; i++) {
1003                 if (test[i].crc32c_le != __crc32c_le(test[i].crc, test_buf +
1004                     test[i].start, test[i].length))
1005                         errors++;
1006         }
1007         nsec = ktime_get_ns() - nsec;
1008
1009         local_irq_restore(flags);
1010         local_irq_enable();
1011
1012         pr_info("crc32c: CRC_LE_BITS = %d\n", CRC_LE_BITS);
1013
1014         if (errors)
1015                 pr_warn("crc32c: %d self tests failed\n", errors);
1016         else {
1017                 pr_info("crc32c: self tests passed, processed %d bytes in %lld nsec\n",
1018                         bytes, nsec);
1019         }
1020
1021         return 0;
1022 }
1023
1024 static int __init crc32c_combine_test(void)
1025 {
1026         int i, j;
1027         int errors = 0, runs = 0;
1028
1029         for (i = 0; i < 10; i++) {
1030                 u32 crc_full;
1031
1032                 crc_full = __crc32c_le(test[i].crc, test_buf + test[i].start,
1033                                        test[i].length);
1034                 for (j = 0; j <= test[i].length; ++j) {
1035                         u32 crc1, crc2;
1036                         u32 len1 = j, len2 = test[i].length - j;
1037
1038                         crc1 = __crc32c_le(test[i].crc, test_buf +
1039                                            test[i].start, len1);
1040                         crc2 = __crc32c_le(0, test_buf + test[i].start +
1041                                            len1, len2);
1042
1043                         if (!(crc_full == __crc32c_le_combine(crc1, crc2, len2) &&
1044                               crc_full == test[i].crc32c_le))
1045                                 errors++;
1046                         runs++;
1047                         cond_resched();
1048                 }
1049         }
1050
1051         if (errors)
1052                 pr_warn("crc32c_combine: %d/%d self tests failed\n", errors, runs);
1053         else
1054                 pr_info("crc32c_combine: %d self tests passed\n", runs);
1055
1056         return 0;
1057 }
1058
1059 static int __init crc32_test(void)
1060 {
1061         int i;
1062         int errors = 0;
1063         int bytes = 0;
1064         u64 nsec;
1065         unsigned long flags;
1066
1067         /* keep static to prevent cache warming code from
1068          * getting eliminated by the compiler */
1069         static u32 crc;
1070
1071         /* pre-warm the cache */
1072         for (i = 0; i < 100; i++) {
1073                 bytes += 2*test[i].length;
1074
1075                 crc ^= crc32_le(test[i].crc, test_buf +
1076                     test[i].start, test[i].length);
1077
1078                 crc ^= crc32_be(test[i].crc, test_buf +
1079                     test[i].start, test[i].length);
1080         }
1081
1082         /* reduce OS noise */
1083         local_irq_save(flags);
1084         local_irq_disable();
1085
1086         nsec = ktime_get_ns();
1087         for (i = 0; i < 100; i++) {
1088                 if (test[i].crc_le != crc32_le(test[i].crc, test_buf +
1089                     test[i].start, test[i].length))
1090                         errors++;
1091
1092                 if (test[i].crc_be != crc32_be(test[i].crc, test_buf +
1093                     test[i].start, test[i].length))
1094                         errors++;
1095         }
1096         nsec = ktime_get_ns() - nsec;
1097
1098         local_irq_restore(flags);
1099         local_irq_enable();
1100
1101         pr_info("crc32: CRC_LE_BITS = %d, CRC_BE BITS = %d\n",
1102                  CRC_LE_BITS, CRC_BE_BITS);
1103
1104         if (errors)
1105                 pr_warn("crc32: %d self tests failed\n", errors);
1106         else {
1107                 pr_info("crc32: self tests passed, processed %d bytes in %lld nsec\n",
1108                         bytes, nsec);
1109         }
1110
1111         return 0;
1112 }
1113
1114 static int __init crc32_combine_test(void)
1115 {
1116         int i, j;
1117         int errors = 0, runs = 0;
1118
1119         for (i = 0; i < 10; i++) {
1120                 u32 crc_full;
1121
1122                 crc_full = crc32_le(test[i].crc, test_buf + test[i].start,
1123                                     test[i].length);
1124                 for (j = 0; j <= test[i].length; ++j) {
1125                         u32 crc1, crc2;
1126                         u32 len1 = j, len2 = test[i].length - j;
1127
1128                         crc1 = crc32_le(test[i].crc, test_buf +
1129                                         test[i].start, len1);
1130                         crc2 = crc32_le(0, test_buf + test[i].start +
1131                                         len1, len2);
1132
1133                         if (!(crc_full == crc32_le_combine(crc1, crc2, len2) &&
1134                               crc_full == test[i].crc_le))
1135                                 errors++;
1136                         runs++;
1137                         cond_resched();
1138                 }
1139         }
1140
1141         if (errors)
1142                 pr_warn("crc32_combine: %d/%d self tests failed\n", errors, runs);
1143         else
1144                 pr_info("crc32_combine: %d self tests passed\n", runs);
1145
1146         return 0;
1147 }
1148
1149 static int __init crc32test_init(void)
1150 {
1151         crc32_test();
1152         crc32c_test();
1153
1154         crc32_combine_test();
1155         crc32c_combine_test();
1156
1157         return 0;
1158 }
1159
1160 static void __exit crc32_exit(void)
1161 {
1162 }
1163
1164 module_init(crc32test_init);
1165 module_exit(crc32_exit);
1166 #endif /* CONFIG_CRC32_SELFTEST */