new file mode 100644

@@ -0,0 +1,3 @@

+[submodule "src/in_xsf_framework/zlib"]

+	path = src/in_xsf_framework/zlib

+	url = https://github.com/madler/zlib

@@ -2,8 +2,8 @@

 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

   <ImportGroup Label="PropertySheets" />

   <PropertyGroup Label="UserMacros">

-    <zlibRootDir>ZLIBFIXME</zlibRootDir>

-    <WinampSDKDir>WINAMPSDKFIXME</WinampSDKDir>

+    <zlibRootDir>$(MSBuildThisFileDirectory)\zlib</zlibRootDir>

+    <WinampSDKDir>$(MSBuildThisFileDirectory)\winamp</WinampSDKDir>

   </PropertyGroup>

   <PropertyGroup />

   <ItemDefinitionGroup />

new file mode 160000

@@ -0,0 +1 @@

+Subproject commit cacf7f1d4e3d44d871b605da3b647f07d718623f

deleted file mode 100644

@@ -1,186 +0,0 @@

-/* adler32.c -- compute the Adler-32 checksum of a data stream

- * Copyright (C) 1995-2011, 2016 Mark Adler

- * For conditions of distribution and use, see copyright notice in zlib.h

- */

-

-/* @(#) $Id$ */

-

-#include "zutil.h"

-

-local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));

-

-#define BASE 65521U     /* largest prime smaller than 65536 */

-#define NMAX 5552

-/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */

-

-#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}

-#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);

-#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);

-#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);

-#define DO16(buf)   DO8(buf,0); DO8(buf,8);

-

-/* use NO_DIVIDE if your processor does not do division in hardware --

-   try it both ways to see which is faster */

-#ifdef NO_DIVIDE

-/* note that this assumes BASE is 65521, where 65536 % 65521 == 15

-   (thank you to John Reiser for pointing this out) */

-#  define CHOP(a) \

-    do { \

-        unsigned long tmp = a >> 16; \

-        a &= 0xffffUL; \

-        a += (tmp << 4) - tmp; \

-    } while (0)

-#  define MOD28(a) \

-    do { \

-        CHOP(a); \

-        if (a >= BASE) a -= BASE; \

-    } while (0)

-#  define MOD(a) \

-    do { \

-        CHOP(a); \

-        MOD28(a); \

-    } while (0)

-#  define MOD63(a) \

-    do { /* this assumes a is not negative */ \

-        z_off64_t tmp = a >> 32; \

-        a &= 0xffffffffL; \

-        a += (tmp << 8) - (tmp << 5) + tmp; \

-        tmp = a >> 16; \

-        a &= 0xffffL; \

-        a += (tmp << 4) - tmp; \

-        tmp = a >> 16; \

-        a &= 0xffffL; \

-        a += (tmp << 4) - tmp; \

-        if (a >= BASE) a -= BASE; \

-    } while (0)

-#else

-#  define MOD(a) a %= BASE

-#  define MOD28(a) a %= BASE

-#  define MOD63(a) a %= BASE

-#endif

-

-/* ========================================================================= */

-uLong ZEXPORT adler32_z(adler, buf, len)

-    uLong adler;

-    const Bytef *buf;

-    z_size_t len;

-{

-    unsigned long sum2;

-    unsigned n;

-

-    /* split Adler-32 into component sums */

-    sum2 = (adler >> 16) & 0xffff;

-    adler &= 0xffff;

-

-    /* in case user likes doing a byte at a time, keep it fast */

-    if (len == 1) {

-        adler += buf[0];

-        if (adler >= BASE)

-            adler -= BASE;

-        sum2 += adler;

-        if (sum2 >= BASE)

-            sum2 -= BASE;

-        return adler | (sum2 << 16);

-    }

-

-    /* initial Adler-32 value (deferred check for len == 1 speed) */

-    if (buf == Z_NULL)

-        return 1L;

-

-    /* in case short lengths are provided, keep it somewhat fast */

-    if (len < 16) {

-        while (len--) {

-            adler += *buf++;

-            sum2 += adler;

-        }

-        if (adler >= BASE)

-            adler -= BASE;

-        MOD28(sum2);            /* only added so many BASE's */

-        return adler | (sum2 << 16);

-    }

-

-    /* do length NMAX blocks -- requires just one modulo operation */

-    while (len >= NMAX) {

-        len -= NMAX;

-        n = NMAX / 16;          /* NMAX is divisible by 16 */

-        do {

-            DO16(buf);          /* 16 sums unrolled */

-            buf += 16;

-        } while (--n);

-        MOD(adler);

-        MOD(sum2);

-    }

-

-    /* do remaining bytes (less than NMAX, still just one modulo) */

-    if (len) {                  /* avoid modulos if none remaining */

-        while (len >= 16) {

-            len -= 16;

-            DO16(buf);

-            buf += 16;

-        }

-        while (len--) {

-            adler += *buf++;

-            sum2 += adler;

-        }

-        MOD(adler);

-        MOD(sum2);

-    }

-

-    /* return recombined sums */

-    return adler | (sum2 << 16);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT adler32(adler, buf, len)

-    uLong adler;

-    const Bytef *buf;

-    uInt len;

-{

-    return adler32_z(adler, buf, len);

-}

-

-/* ========================================================================= */

-local uLong adler32_combine_(adler1, adler2, len2)

-    uLong adler1;

-    uLong adler2;

-    z_off64_t len2;

-{

-    unsigned long sum1;

-    unsigned long sum2;

-    unsigned rem;

-

-    /* for negative len, return invalid adler32 as a clue for debugging */

-    if (len2 < 0)

-        return 0xffffffffUL;

-

-    /* the derivation of this formula is left as an exercise for the reader */

-    MOD63(len2);                /* assumes len2 >= 0 */

-    rem = (unsigned)len2;

-    sum1 = adler1 & 0xffff;

-    sum2 = rem * sum1;

-    MOD(sum2);

-    sum1 += (adler2 & 0xffff) + BASE - 1;

-    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;

-    if (sum1 >= BASE) sum1 -= BASE;

-    if (sum1 >= BASE) sum1 -= BASE;

-    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);

-    if (sum2 >= BASE) sum2 -= BASE;

-    return sum1 | (sum2 << 16);

-}

-

-/* ========================================================================= */

-uLong ZEXPORT adler32_combine(adler1, adler2, len2)

-    uLong adler1;

-    uLong adler2;

-    z_off_t len2;

-{

-    return adler32_combine_(adler1, adler2, len2);

-}

-

-uLong ZEXPORT adler32_combine64(adler1, adler2, len2)

-    uLong adler1;

-    uLong adler2;

-    z_off64_t len2;

-{

-    return adler32_combine_(adler1, adler2, len2);

-}

deleted file mode 100644

@@ -1,442 +0,0 @@

-/* crc32.c -- compute the CRC-32 of a data stream

- * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler

- * For conditions of distribution and use, see copyright notice in zlib.h

- *

- * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster

- * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing

- * tables for updating the shift register in one step with three exclusive-ors

- * instead of four steps with four exclusive-ors.  This results in about a

- * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.

- */

-

-/* @(#) $Id$ */

-

-/*

-  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore

-  protection on the static variables used to control the first-use generation

-  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should

-  first call get_crc_table() to initialize the tables before allowing more than

-  one thread to use crc32().

-

-  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.

- */

-

-#ifdef MAKECRCH

-#  include <stdio.h>

-#  ifndef DYNAMIC_CRC_TABLE

-#    define DYNAMIC_CRC_TABLE

-#  endif /* !DYNAMIC_CRC_TABLE */

-#endif /* MAKECRCH */

-

-#include "zutil.h"      /* for STDC and FAR definitions */

-

-/* Definitions for doing the crc four data bytes at a time. */

-#if !defined(NOBYFOUR) && defined(Z_U4)

-#  define BYFOUR

-#endif

-#ifdef BYFOUR

-   local unsigned long crc32_little OF((unsigned long,

-                        const unsigned char FAR *, z_size_t));

-   local unsigned long crc32_big OF((unsigned long,

-                        const unsigned char FAR *, z_size_t));

-#  define TBLS 8

-#else

-#  define TBLS 1

-#endif /* BYFOUR */

-

-/* Local functions for crc concatenation */

-local unsigned long gf2_matrix_times OF((unsigned long *mat,

-                                         unsigned long vec));

-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));

-local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));

-

-

-#ifdef DYNAMIC_CRC_TABLE

-

-local volatile int crc_table_empty = 1;

-local z_crc_t FAR crc_table[TBLS][256];

-local void make_crc_table OF((void));

-#ifdef MAKECRCH

-   local void write_table OF((FILE *, const z_crc_t FAR *));

-#endif /* MAKECRCH */

-/*

-  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:

-  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.

-

-  Polynomials over GF(2) are represented in binary, one bit per coefficient,

-  with the lowest powers in the most significant bit.  Then adding polynomials

-  is just exclusive-or, and multiplying a polynomial by x is a right shift by

-  one.  If we call the above polynomial p, and represent a byte as the

-  polynomial q, also with the lowest power in the most significant bit (so the

-  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,

-  where a mod b means the remainder after dividing a by b.

-

-  This calculation is done using the shift-register method of multiplying and

-  taking the remainder.  The register is initialized to zero, and for each

-  incoming bit, x^32 is added mod p to the register if the bit is a one (where

-  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by

-  x (which is shifting right by one and adding x^32 mod p if the bit shifted

-  out is a one).  We start with the highest power (least significant bit) of

-  q and repeat for all eight bits of q.

-

-  The first table is simply the CRC of all possible eight bit values.  This is

-  all the information needed to generate CRCs on data a byte at a time for all

-  combinations of CRC register values and incoming bytes.  The remaining tables

-  allow for word-at-a-time CRC calculation for both big-endian and little-

-  endian machines, where a word is four bytes.

-*/

-local void make_crc_table()

-{

-    z_crc_t c;

-    int n, k;

-    z_crc_t poly;                       /* polynomial exclusive-or pattern */

-    /* terms of polynomial defining this crc (except x^32): */

-    static volatile int first = 1;      /* flag to limit concurrent making */

-    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};

-

-    /* See if another task is already doing this (not thread-safe, but better

-       than nothing -- significantly reduces duration of vulnerability in

-       case the advice about DYNAMIC_CRC_TABLE is ignored) */

-    if (first) {

-        first = 0;

-

-        /* make exclusive-or pattern from polynomial (0xedb88320UL) */

-        poly = 0;

-        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)

-            poly |= (z_crc_t)1 << (31 - p[n]);

-

-        /* generate a crc for every 8-bit value */

-        for (n = 0; n < 256; n++) {

-            c = (z_crc_t)n;

-            for (k = 0; k < 8; k++)

-                c = c & 1 ? poly ^ (c >> 1) : c >> 1;

-            crc_table[0][n] = c;

-        }

-

-#ifdef BYFOUR

-        /* generate crc for each value followed by one, two, and three zeros,

-           and then the byte reversal of those as well as the first table */

-        for (n = 0; n < 256; n++) {

-            c = crc_table[0][n];

-            crc_table[4][n] = ZSWAP32(c);

-            for (k = 1; k < 4; k++) {

-                c = crc_table[0][c & 0xff] ^ (c >> 8);

-                crc_table[k][n] = c;

-                crc_table[k + 4][n] = ZSWAP32(c);

-            }

-        }

-#endif /* BYFOUR */

-

-        crc_table_empty = 0;

-    }

-    else {      /* not first */

-        /* wait for the other guy to finish (not efficient, but rare) */

-        while (crc_table_empty)

-            ;

-    }

-

-#ifdef MAKECRCH

-    /* write out CRC tables to crc32.h */

-    {

-        FILE *out;

-

-        out = fopen("crc32.h", "w");

-        if (out == NULL) return;

-        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");

-        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");

-        fprintf(out, "local const z_crc_t FAR ");

-        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");

-        write_table(out, crc_table[0]);

-#  ifdef BYFOUR

-        fprintf(out, "#ifdef BYFOUR\n");

-        for (k = 1; k < 8; k++) {

-            fprintf(out, "  },\n  {\n");

-            write_table(out, crc_table[k]);

-        }

-        fprintf(out, "#endif\n");

-#  endif /* BYFOUR */

-        fprintf(out, "  }\n};\n");

-        fclose(out);

-    }

-#endif /* MAKECRCH */

-}

-

-#ifdef MAKECRCH

-local void write_table(out, table)

-    FILE *out;

-    const z_crc_t FAR *table;

-{

-    int n;

-

-    for (n = 0; n < 256; n++)

-        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",

-                (unsigned long)(table[n]),

-                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));

-}

-#endif /* MAKECRCH */

-

-#else /* !DYNAMIC_CRC_TABLE */

-/* ========================================================================

- * Tables of CRC-32s of all single-byte values, made by make_crc_table().

- */

-#include "crc32.h"

-#endif /* DYNAMIC_CRC_TABLE */

-

-/* =========================================================================

- * This function can be used by asm versions of crc32()

- */

-const z_crc_t FAR * ZEXPORT get_crc_table()

-{

-#ifdef DYNAMIC_CRC_TABLE

-    if (crc_table_empty)

-        make_crc_table();

-#endif /* DYNAMIC_CRC_TABLE */

-    return (const z_crc_t FAR *)crc_table;

-}

-

-/* ========================================================================= */

-#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)

-#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1

-

-/* ========================================================================= */

-unsigned long ZEXPORT crc32_z(crc, buf, len)

-    unsigned long crc;

-    const unsigned char FAR *buf;

-    z_size_t len;

-{

-    if (buf == Z_NULL) return 0UL;

-

-#ifdef DYNAMIC_CRC_TABLE

-    if (crc_table_empty)

-        make_crc_table();

-#endif /* DYNAMIC_CRC_TABLE */

-

-#ifdef BYFOUR

-    if (sizeof(void *) == sizeof(ptrdiff_t)) {

-        z_crc_t endian;

-

-        endian = 1;

-        if (*((unsigned char *)(&endian)))

-            return crc32_little(crc, buf, len);

-        else

-            return crc32_big(crc, buf, len);

-    }

-#endif /* BYFOUR */

-    crc = crc ^ 0xffffffffUL;

-    while (len >= 8) {

-        DO8;

-        len -= 8;

-    }

-    if (len) do {

-        DO1;

-    } while (--len);

-    return crc ^ 0xffffffffUL;

-}

-

-/* ========================================================================= */

-unsigned long ZEXPORT crc32(crc, buf, len)

-    unsigned long crc;

-    const unsigned char FAR *buf;

-    uInt len;

-{

-    return crc32_z(crc, buf, len);

-}

-

-#ifdef BYFOUR

-

-/*

-   This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit

-   integer pointer type. This violates the strict aliasing rule, where a

-   compiler can assume, for optimization purposes, that two pointers to

-   fundamentally different types won't ever point to the same memory. This can

-   manifest as a problem only if one of the pointers is written to. This code

-   only reads from those pointers. So long as this code remains isolated in

-   this compilation unit, there won't be a problem. For this reason, this code

-   should not be copied and pasted into a compilation unit in which other code

-   writes to the buffer that is passed to these routines.

- */

-

-/* ========================================================================= */

-#define DOLIT4 c ^= *buf4++; \

-        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \

-            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]

-#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4

-

-/* ========================================================================= */

-local unsigned long crc32_little(crc, buf, len)

-    unsigned long crc;

-    const unsigned char FAR *buf;

-    z_size_t len;

-{

-    register z_crc_t c;

-    register const z_crc_t FAR *buf4;

-

-    c = (z_crc_t)crc;

-    c = ~c;

-    while (len && ((ptrdiff_t)buf & 3)) {

-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);

-        len--;

-    }

-

-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;

-    while (len >= 32) {

-        DOLIT32;

-        len -= 32;

-    }

-    while (len >= 4) {

-        DOLIT4;

-        len -= 4;

-    }

-    buf = (const unsigned char FAR *)buf4;

-

-    if (len) do {

-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);

-    } while (--len);

-    c = ~c;

-    return (unsigned long)c;

-}

-

-/* ========================================================================= */

-#define DOBIG4 c ^= *buf4++; \

-        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \

-            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]

-#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4

-

-/* ========================================================================= */

-local unsigned long crc32_big(crc, buf, len)

-    unsigned long crc;

-    const unsigned char FAR *buf;

-    z_size_t len;

-{

-    register z_crc_t c;

-    register const z_crc_t FAR *buf4;

-

-    c = ZSWAP32((z_crc_t)crc);

-    c = ~c;

-    while (len && ((ptrdiff_t)buf & 3)) {

-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);

-        len--;

-    }

-

-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;

-    while (len >= 32) {

-        DOBIG32;

-        len -= 32;

-    }

-    while (len >= 4) {

-        DOBIG4;

-        len -= 4;

-    }

-    buf = (const unsigned char FAR *)buf4;

-

-    if (len) do {

-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);

-    } while (--len);

-    c = ~c;

-    return (unsigned long)(ZSWAP32(c));

-}

-

-#endif /* BYFOUR */

-

-#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */

-

-/* ========================================================================= */

-local unsigned long gf2_matrix_times(mat, vec)

-    unsigned long *mat;

-    unsigned long vec;

-{

-    unsigned long sum;

-

-    sum = 0;

-    while (vec) {

-        if (vec & 1)

-            sum ^= *mat;

-        vec >>= 1;

-        mat++;

-    }

-    return sum;

-}

-

-/* ========================================================================= */

-local void gf2_matrix_square(square, mat)

-    unsigned long *square;

-    unsigned long *mat;

-{

-    int n;

-

-    for (n = 0; n < GF2_DIM; n++)

-        square[n] = gf2_matrix_times(mat, mat[n]);

-}

-

-/* ========================================================================= */

-local uLong crc32_combine_(crc1, crc2, len2)

-    uLong crc1;

-    uLong crc2;

-    z_off64_t len2;

-{

-    int n;

-    unsigned long row;

-    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */

-    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */

-

-    /* degenerate case (also disallow negative lengths) */

-    if (len2 <= 0)

-        return crc1;

-

-    /* put operator for one zero bit in odd */

-    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */

-    row = 1;

-    for (n = 1; n < GF2_DIM; n++) {

-        odd[n] = row;

-        row <<= 1;

-    }

-

-    /* put operator for two zero bits in even */

-    gf2_matrix_square(even, odd);

-

-    /* put operator for four zero bits in odd */

-    gf2_matrix_square(odd, even);

-

-    /* apply len2 zeros to crc1 (first square will put the operator for one

-       zero byte, eight zero bits, in even) */

-    do {

-        /* apply zeros operator for this bit of len2 */

-        gf2_matrix_square(even, odd);

-        if (len2 & 1)

-            crc1 = gf2_matrix_times(even, crc1);

-        len2 >>= 1;

-

-        /* if no more bits set, then done */

-        if (len2 == 0)

-            break;

-

-        /* another iteration of the loop with odd and even swapped */

-        gf2_matrix_square(odd, even);

-        if (len2 & 1)

-            crc1 = gf2_matrix_times(odd, crc1);

-        len2 >>= 1;

-

-        /* if no more bits set, then done */

-    } while (len2 != 0);

-

-    /* return combined crc */

-    crc1 ^= crc2;

-    return crc1;

-}

-

-/* ========================================================================= */

-uLong ZEXPORT crc32_combine(crc1, crc2, len2)

-    uLong crc1;

-    uLong crc2;

-    z_off_t len2;

-{

-    return crc32_combine_(crc1, crc2, len2);

-}

-

-uLong ZEXPORT crc32_combine64(crc1, crc2, len2)

-    uLong crc1;

-    uLong crc2;

-    z_off64_t len2;

-{

-    return crc32_combine_(crc1, crc2, len2);

-}

deleted file mode 100644

@@ -1,441 +0,0 @@

-/* crc32.h -- tables for rapid CRC calculation

- * Generated automatically by crc32.c

- */

-

-local const z_crc_t FAR crc_table[TBLS][256] =

-{

-  {

-    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,

-    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,

-    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,

-    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,

-    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,

-    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,

-    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,

-    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,

-    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,

-    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,

-    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,

-    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,

-    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,

-    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,

-    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,

-    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,

-    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,

-    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,

-    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,

-    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,

-    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,

-    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,

-    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,

-    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,

-    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,

-    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,

-    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,

-    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,

-    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,

-    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,

-    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,

-    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,

-    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,

-    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,

-    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,

-    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,

-    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,

-    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,

-    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,

-    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,

-    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,

-    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,

-    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,

-    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,

-    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,

-    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,

-    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,

-    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,

-    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,

-    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,

-    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,

-    0x2d02ef8dUL

-#ifdef BYFOUR

-  },

-  {

-    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,

-    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,

-    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,

-    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,

-    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,

-    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,

-    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,

-    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,

-    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,

-    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,

-    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,

-    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,

-    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,

-    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,

-    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,

-    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,

-    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,

-    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,

-    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,

-    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,

-    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,

-    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,

-    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,

-    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,

-    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,

-    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,

-    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,

-    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,

-    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,

-    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,

-    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,

-    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,

-    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,

-    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,

-    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,

-    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,

-    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,

-    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,

-    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,

-    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,

-    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,

-    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,

-    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,

-    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,

-    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,

-    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,

-    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,

-    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,

-    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,

-    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,

-    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,

-    0x9324fd72UL

-  },

-  {

-    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,

-    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,

-    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,

-    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,

-    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,

-    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,

-    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,

-    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,

-    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,

-    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,

-    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,

-    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,

-    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,

-    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,

-    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,

-    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,

-    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,

-    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,

-    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,

-    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,

-    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,

-    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,

-    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,

-    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,

-    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,

-    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,

-    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,

-    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,

-    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,

-    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,

-    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,

-    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,

-    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,

-    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,

-    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,

-    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,

-    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,

-    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,

-    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,

-    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,

-    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,

-    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,

-    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,

-    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,

-    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,

-    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,

-    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,

-    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,

-    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,

-    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,

-    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,

-    0xbe9834edUL

-  },

-  {

-    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,

-    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,

-    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,

-    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,

-    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,

-    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,

-    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,

-    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,

-    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,

-    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,

-    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,

-    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,

-    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,

-    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,

-    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,

-    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,

-    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,

-    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,

-    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,

-    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,

-    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,

-    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,

-    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,

-    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,

-    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,

-    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,

-    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,

-    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,

-    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,

-    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,

-    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,

-    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,

-    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,

-    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,

-    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,

-    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,

-    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,

-    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,

-    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,

-    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,

-    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,

-    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,

-    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,

-    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,

-    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,