A Collection of 32-bit CRC Tables and Algorithms
Contents
Introduction
This page gives a small list of CRC "polynomials" expressed as n-bit binary constants, for n=16 and n=32, corresponding to some widely-used 16-bit and 32-bit CRC checksums.
Following that is the excellent "makecrc" program adapted from code by Mark G. Mendel. It is a C program that prints out valid C code for performing a CRC checksum calculation with each of the CRC "polynomials" listed in the table.
Table of CRC "polynomials"
A polynomial, of course, is not a binary number. However the CRC algorithm is based on properties of finite field arithmetic, in which addition and multiplication modulo a prime p (or a power of a prime, etc.) has properties that are very useful for error detection. The "polynomials" here are in a single variable, evaluated in modulo-2 arithmetic (i.e. using the finite field GF(2), which means that the "coefficients" are all either 0 or 1, and addition and subtraction are simply a 1-bit XOR. That means that the coefficients of an nth order polynomial consist of only n+1 binary digits, and can be stored efficiently as a binary number in a computer; and polynomial "multiplication" and "division" can be performed with shifts and XORs of n+1-bit binary numbers.
|
A much more complete list (and also some source code, and many links) is on Wikipedia here.
datatypes
typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t;makecrc
This is from the Harvest project, developed by the Internet Research Task Force Research Group on Resource Discovery (IRTF-RD) and hosted for some time at University of Colorado, Boulder.
I got this code from version 1.3.pl3 of Harvest, dated Wed 25th October 1995. It was mirrored at MIT (at the URL web.mit.edu/wwwdev/src/harvest-1.3.pl3/components/gatherer/standard/unbinhex/crc/makecrc.c)
The copyright and terms of use for the main part of Harvest are here. Notice that it says that "components" have their own copyright notices, however there is none for the particular component and subdirectory containing this code. A README in the components/gatherer/standard/unbinhex directory credits Mark G. Mendel with creating a predecessor to this code.
This code outputs the tables and CRC calculation routines in the CCITT32 and zip sections below. It also outputs four types of 16-bit CRC tables and code, which are not included on this webpage.
/* This program will write six C routines for the calculation of * the following CRC's. */ /* The CRC polynomial. * These 4 values define the crc-polynomial. * If you change them, you must change crctab[]'s initial value to what is * printed by initcrctab() [see 'compile with -DMAKETAB' above]. */ /* This tables assumes CCITT is MSB first. Swapped means LSB first. In that * case the polynomial is also swapped */ /* 16 bit crc's */ /* Value used by: CCITT KERMIT ARC BINHEX */ /* the poly: 0x1021 0x8408 0xA001 0x1021 */ /* original: 0x1021 0x1021 0x8005 0x1021 */ /* init value: -1 0 0 0 */ /* swapped: no yes yes no */ /* bits in CRC: 16 16 16 16 */ /* ARC used by LHARC, ZOO, STUFFIT */ /* BINHEX used by XMODEM, PACKIT */ /* 32 bit crc's */ /* Value used by: CCITT32 ZIP */ /* the poly: 0x04c11db7 0xedb88320 */ /* original: 0x04c11db7 0x04c11db7 */ /* init value: -1 -1 */ /* swapped no yes */ /* bits in CRC: 32 32 */ /* ZIP used by COMPACTOR */ #include <stdio.h> extern void exit(); extern char *strcat(); static void initcrctab(); main() { initcrctab("ccitt", 0x1021, 0xffff, 0, 16); initcrctab("kermit", 0x8408, 0, 1, 16); initcrctab("arc", 0xa001, 0, 1, 16); initcrctab("binhex", 0x1021, 0, 0, 16); initcrctab("ccitt32",0x04c11db7,0xffffffff,0,32); initcrctab("zip",0xedb88320,0xffffffff,1,32); exit(0); /*NOTREACHED*/ } static void initcrctab(name, poly, init, swapped, bits) char *name; int poly, init, swapped, bits; { register int b, i; uint16_t v; uint32_t vv; FILE *fd; char buf[20]; buf[0] = 0; (void)strcat(buf, name); (void)strcat(buf, ".c"); if((fd = fopen(buf, "w")) == NULL) { (void)fprintf(stderr, "Cannot open %s for writing\n", buf); exit(1); } (void)fprintf(fd, "uint32_t %s_crcinit = %d;\n", name, init); (void)fprintf(fd, "\n"); if(bits == 16) { (void)fprintf(fd, "static uint16_t crctab[256] = {\n"); } else { (void)fprintf(fd, "static uint32_t crctab[256] = {\n"); } (void)fprintf(fd, " "); if(bits == 16) { for(b = 0; b < 256; ++b) { if(swapped) { for(v = b, i = 8; --i >= 0;) v = v & 1 ? (v>>1)^poly : v>>1; } else { for(v = b<<8, i = 8; --i >= 0;) v = v & 0x8000 ? (v<<1)^poly : v<<1; } (void)fprintf(fd, "0x%.4x,", v & 0xffff); if((b&7) == 7) { (void)fprintf(fd, "\n"); if(b != 255) (void)fprintf(fd, " "); } else { (void)fprintf(fd, " "); } } } else { for(b = 0; b < 256; ++b) { if(swapped) { for(vv = b, i = 8; --i >= 0;) vv = vv & 1 ? (vv>>1)^poly : vv>>1; } else { for(vv = b<<24, i = 8; --i >= 0;) vv = vv & 0x80000000 ? (vv<<1)^poly : vv<<1; } (void)fprintf(fd, "0x%.8x,", vv & 0xffffffff); if((b&3) == 3) { (void)fprintf(fd, "\n"); if(b != 255) (void)fprintf(fd, " "); } else { (void)fprintf(fd, " "); } } } (void)fprintf(fd, "};\n"); (void)fprintf(fd, "\n"); (void)fprintf(fd, "uint32_t %s_updcrc(icrc, icp, icnt)\n", name); (void)fprintf(fd, " uint32_t icrc;\n"); (void)fprintf(fd, " uint8_t *icp;\n"); (void)fprintf(fd, " int icnt;\n"); (void)fprintf(fd, "{\n"); if(bits == 16) { (void)fprintf(fd, "#define M1 0xff\n"); (void)fprintf(fd, "#define M2 0xff00\n"); } else { (void)fprintf(fd, "#define M1 0xffffff\n"); (void)fprintf(fd, "#define M2 0xffffff00\n"); } (void)fprintf(fd, " register uint32_t crc = icrc;\n"); (void)fprintf(fd, " register uint8_t *cp = icp;\n"); (void)fprintf(fd, " register int cnt = icnt;\n"); (void)fprintf(fd, "\n"); (void)fprintf(fd, " while(cnt--) {\n"); if(bits == 16) { if (swapped) { (void)fprintf(fd, "\tcrc=((crc>>8)&M1)^crctab[(crc&0xff)^*cp++];\n"); } else { (void)fprintf(fd, "\tcrc=((crc<<8)&M2)^crctab[((crc>>8)&0xff)^*cp++];\n"); } } else { if(swapped) { (void)fprintf(fd, "\tcrc=((crc>>8)&M1)^crctab[(crc&0xff)^*cp++];\n"); } else { (void)fprintf(fd, "\tcrc=((crc<<8)&M2)^crctab[((crc>>24)&0xff)^*cp++];\n"); } } (void)fprintf(fd, " }\n"); (void)fprintf(fd, "\n"); (void)fprintf(fd, " return(crc);\n"); (void)fprintf(fd, "}\n"); (void)fprintf(fd, "\n"); (void)fclose(fd); }CCITT32
Source : web.mit.edu/wwwdev/src/harvest-1.3.pl3/components/gatherer/standard/unbinhex/crc/ccitt32.c
This table and the CRC calculation function are both output by the above "makecrc" code.
uint32_t ccitt32_crcinit = -1; static uint32_t crctab[256] = { 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4, }; uint32_t ccitt32_updcrc(icrc, icp, icnt) uint32_t icrc; uint8_t *icp; int icnt; { #define M1 0xffffff #define M2 0xffffff00 register uint32_t crc = icrc; register uint8_t *cp = icp; register int cnt = icnt; while(cnt--) { crc=((crc<<8)&M2)^crctab[((crc>>24)&0xff)^*cp++]; } return(crc); }crc32-adler
This is not the Adler-32 checksum (follow that link to find out what it is), but is a CRC-like operation using a reversed form of the more common 0x04c11db7 (i.e. 0xedb88320). Like other CRC operations it starts with all 1's (i.e. 0xFFFFFFFF), but the functions also provide the ability to pass a "crc" as input, which enables the CRC of a long amount of data by calling the routine on pieces of the data. This requires reversing all bits at the beginning and end (i.e. when done it XORs the result with 0xFFFFFFFF) which means that the final answer is different from a normal CRC.
Sources :
sourceware.org/svn/prelink/trunk/src/makecrc.c
sourceware.org/svn/prelink/trunk/src/crc32.c
The table of 256 values "crc32_table" is the same as that seen in code from Gary S. Brown, at web.mit.edu/freebsd/head/sys/libkern/crc32.c
/* Table computed with the following function "adler_init" by Mark Adler, which had the following comment: Generate a table 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 table is simply the CRC of all possible eight bit values. This is all the information needed to generate CRC's on data a byte at a time for all combinations of CRC register values and incoming bytes. */ void adler_init() { uint32_t c; // crc shift register uint32_t e; // polynomial exclusive-or pattern int i; // counter for all possible eight bit values int k; // byte being shifted into crc apparatus // terms of polynomial defining this crc (except x^32): static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; // Make exclusive-or pattern from polynomial (0xedb88320) e = 0; for (i = 0; i < sizeof(p)/sizeof(int); i++) { e |= 1L << (31 - p[i]); } // Compute table of CRC's for (i = 1; i < 256; i++) { c = i; // The idea to initialize the register with the byte instead of // zero was stolen from Haruhiko Okumura's ar002 for (k = 8; k; k--) { c = c & 1 ? (c >> 1) ^ e : c >> 1; } crc32_table[i] = c; } } static const uint32_t crc32_table[256] = { 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d }; uint32_t crc32_a(uint32_t crc, const void *buf, size_t size) { const uint8_t *p; p = buf; crc = crc ^ ~0U; while (size--) crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); return crc ^ ~0U; } uint32_t crc32_b(uint32_t crc, uint8_t *buf, int len) { uint8_t *end; crc = ~crc; for (end = buf + len; buf < end; ++buf) { crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); } return ~crc; }zip
Source : web.mit.edu/wwwdev/src/harvest-1.3.pl3/components/gatherer/standard/unbinhex/crc/zip.c
This table and the CRC calculation function are both output by the above "makecrc" code.
uint32_t zip_crcinit = -1; static uint32_t crctab[256] = { 0x00000000, 0x09073096, 0x120e612c, 0x1b0951ba, 0xff6dc419, 0xf66af48f, 0xed63a535, 0xe46495a3, 0xfedb8832, 0xf7dcb8a4, 0xecd5e91e, 0xe5d2d988, 0x01b64c2b, 0x08b17cbd, 0x13b82d07, 0x1abf1d91, 0xfdb71064, 0xf4b020f2, 0xefb97148, 0xe6be41de, 0x02dad47d, 0x0bdde4eb, 0x10d4b551, 0x19d385c7, 0x036c9856, 0x0a6ba8c0, 0x1162f97a, 0x1865c9ec, 0xfc015c4f, 0xf5066cd9, 0xee0f3d63, 0xe7080df5, 0xfb6e20c8, 0xf269105e, 0xe96041e4, 0xe0677172, 0x0403e4d1, 0x0d04d447, 0x160d85fd, 0x1f0ab56b, 0x05b5a8fa, 0x0cb2986c, 0x17bbc9d6, 0x1ebcf940, 0xfad86ce3, 0xf3df5c75, 0xe8d60dcf, 0xe1d13d59, 0x06d930ac, 0x0fde003a, 0x14d75180, 0x1dd06116, 0xf9b4f4b5, 0xf0b3c423, 0xebba9599, 0xe2bda50f, 0xf802b89e, 0xf1058808, 0xea0cd9b2, 0xe30be924, 0x076f7c87, 0x0e684c11, 0x15611dab, 0x1c662d3d, 0xf6dc4190, 0xffdb7106, 0xe4d220bc, 0xedd5102a, 0x09b18589, 0x00b6b51f, 0x1bbfe4a5, 0x12b8d433, 0x0807c9a2, 0x0100f934, 0x1a09a88e, 0x130e9818, 0xf76a0dbb, 0xfe6d3d2d, 0xe5646c97, 0xec635c01, 0x0b6b51f4, 0x026c6162, 0x196530d8, 0x1062004e, 0xf40695ed, 0xfd01a57b, 0xe608f4c1, 0xef0fc457, 0xf5b0d9c6, 0xfcb7e950, 0xe7beb8ea, 0xeeb9887c, 0x0add1ddf, 0x03da2d49, 0x18d37cf3, 0x11d44c65, 0x0db26158, 0x04b551ce, 0x1fbc0074, 0x16bb30e2, 0xf2dfa541, 0xfbd895d7, 0xe0d1c46d, 0xe9d6f4fb, 0xf369e96a, 0xfa6ed9fc, 0xe1678846, 0xe860b8d0, 0x0c042d73, 0x05031de5, 0x1e0a4c5f, 0x170d7cc9, 0xf005713c, 0xf90241aa, 0xe20b1010, 0xeb0c2086, 0x0f68b525, 0x066f85b3, 0x1d66d409, 0x1461e49f, 0x0edef90e, 0x07d9c998, 0x1cd09822, 0x15d7a8b4, 0xf1b33d17, 0xf8b40d81, 0xe3bd5c3b, 0xeaba6cad, 0xedb88320, 0xe4bfb3b6, 0xffb6e20c, 0xf6b1d29a, 0x12d54739, 0x1bd277af, 0x00db2615, 0x09dc1683, 0x13630b12, 0x1a643b84, 0x016d6a3e, 0x086a5aa8, 0xec0ecf0b, 0xe509ff9d, 0xfe00ae27, 0xf7079eb1, 0x100f9344, 0x1908a3d2, 0x0201f268, 0x0b06c2fe, 0xef62575d, 0xe66567cb, 0xfd6c3671, 0xf46b06e7, 0xeed41b76, 0xe7d32be0, 0xfcda7a5a, 0xf5dd4acc, 0x11b9df6f, 0x18beeff9, 0x03b7be43, 0x0ab08ed5, 0x16d6a3e8, 0x1fd1937e, 0x04d8c2c4, 0x0ddff252, 0xe9bb67f1, 0xe0bc5767, 0xfbb506dd, 0xf2b2364b, 0xe80d2bda, 0xe10a1b4c, 0xfa034af6, 0xf3047a60, 0x1760efc3, 0x1e67df55, 0x056e8eef, 0x0c69be79, 0xeb61b38c, 0xe266831a, 0xf96fd2a0, 0xf068e236, 0x140c7795, 0x1d0b4703, 0x060216b9, 0x0f05262f, 0x15ba3bbe, 0x1cbd0b28, 0x07b45a92, 0x0eb36a04, 0xead7ffa7, 0xe3d0cf31, 0xf8d99e8b, 0xf1deae1d, 0x1b64c2b0, 0x1263f226, 0x096aa39c, 0x006d930a, 0xe40906a9, 0xed0e363f, 0xf6076785, 0xff005713, 0xe5bf4a82, 0xecb87a14, 0xf7b12bae, 0xfeb61b38, 0x1ad28e9b, 0x13d5be0d, 0x08dcefb7, 0x01dbdf21, 0xe6d3d2d4, 0xefd4e242, 0xf4ddb3f8, 0xfdda836e, 0x19be16cd, 0x10b9265b, 0x0bb077e1, 0x02b74777, 0x18085ae6, 0x110f6a70, 0x0a063bca, 0x03010b5c, 0xe7659eff, 0xee62ae69, 0xf56bffd3, 0xfc6ccf45, 0xe00ae278, 0xe90dd2ee, 0xf2048354, 0xfb03b3c2, 0x1f672661, 0x166016f7, 0x0d69474d, 0x046e77db, 0x1ed16a4a, 0x17d65adc, 0x0cdf0b66, 0x05d83bf0, 0xe1bcae53, 0xe8bb9ec5, 0xf3b2cf7f, 0xfab5ffe9, 0x1dbdf21c, 0x14bac28a, 0x0fb39330, 0x06b4a3a6, 0xe2d03605, 0xebd70693, 0xf0de5729, 0xf9d967bf, 0xe3667a2e, 0xea614ab8, 0xf1681b02, 0xf86f2b94, 0x1c0bbe37, 0x150c8ea1, 0x0e05df1b, 0x0702ef8d, }; uint32_t zip_updcrc(icrc, icp, icnt) uint32_t icrc; uint8_t *icp; int icnt; { #define M1 0xffffff #define M2 0xffffff00 register uint32_t crc = icrc; register uint8_t *cp = icp; register int cnt = icnt; while(cnt--) { crc=((crc>>8)&M1)^crctab[(crc&0xff)^*cp++]; } return(crc); }This page was written in the "embarrassingly readable" markup language RHTF, and was last updated on 2022 May 23.
s.27