diff --git a/client/cmdcrc.c b/client/cmdcrc.c
index 22abd5488..a9bcdc878 100644
--- a/client/cmdcrc.c
+++ b/client/cmdcrc.c
@@ -71,14 +71,7 @@ int CmdCrc(const char *Cmd)
// as well as a width array for the width of each model
int GetModels(char *Models[], int *count, uint8_t *width){
/* default values */
- static model_t model = {
- PZERO, /* no CRC polynomial, user must specify */
- PZERO, /* Init = 0 */
- P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */
- PZERO, /* XorOut = 0 */
- PZERO, /* check value unused */
- NULL /* no model name */
- };
+ static model_t model = MZERO;
int ibperhx = 8;//, obperhx = 8;
int rflags = 0, uflags = 0; /* search and UI flags */
@@ -136,7 +129,7 @@ int GetModels(char *Models[], int *count, uint8_t *width){
* searched.
*/
/* scan against preset models */
- if (~uflags & C_FORCE) {
+ if (~uflags & C_NOPCK) {
pass = 0;
Cnt = 0;
do {
@@ -252,14 +245,8 @@ int GetModels(char *Models[], int *count, uint8_t *width){
//result = calculated crc hex string
int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *result){
/* default values */
- static model_t model = {
- PZERO, // no CRC polynomial, user must specify
- PZERO, // Init = 0
- P_BE, // RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h
- PZERO, // XorOut = 0
- PZERO, // check value unused
- NULL // no model name
- };
+ static model_t model = MZERO;
+
int ibperhx = 8, obperhx = 8;
int rflags = 0; // search flags
int c;
@@ -389,10 +376,9 @@ int CmdrevengSearch(const char *Cmd){
int dataLen = param_getstr(Cmd, 0, inHexStr);
if (dataLen < 4) return 0;
- char *Models[80];
+ char *Models[102];
int count = 0;
- uint8_t width[80];
- width[0] = 0;
+ uint8_t width[80] = {0};
uint8_t crcChars = 0;
char result[30];
char revResult[30];
@@ -418,10 +404,10 @@ int CmdrevengSearch(const char *Cmd){
char *outHex = calloc(dataLen-crcChars+1, sizeof(char));
memcpy(outHex, inHexStr, dataLen-crcChars);
- //PrintAndLog("DEBUG: dataLen: %d, crcChars: %d, Model: %s, CRC: %s, width: %d, outHex: %s",dataLen, crcChars, Models[i], inCRC, width[i], outHex);
+ // PrintAndLog("DEBUG: dataLen: %d, crcChars: %d, Model: %s, CRC: %s, width: %d, outHex: %s",dataLen, crcChars, Models[i], inCRC, width[i], outHex);
ans = RunModel(Models[i], outHex, false, 0, result);
if (ans) {
- //test for match
+ // test for match
if (memcmp(result, inCRC, crcChars)==0){
PrintAndLog("\nFound a possible match!\nModel: %s\nValue: %s\n",Models[i], result);
//optional - stop searching if found...
@@ -431,7 +417,7 @@ int CmdrevengSearch(const char *Cmd){
char *swapEndian = SwapEndianStr(result, crcChars, crcChars);
if (memcmp(swapEndian, inCRC, crcChars)==0){
PrintAndLog("\nFound a possible match!\nModel: %s\nValue EndianSwapped: %s\n",Models[i], swapEndian);
- //optional - stop searching if found...
+ // optional - stop searching if found...
found = true;
}
free(swapEndian);
@@ -439,31 +425,32 @@ int CmdrevengSearch(const char *Cmd){
}
}
- //if (!found){
+ // if (!found){
ans = RunModel(Models[i], outHex, true, 0, revResult);
if (ans) {
- //test for match
+ // test for match
if (memcmp(revResult, inCRC, crcChars)==0){
PrintAndLog("\nFound a possible match!\nModel Reversed: %s\nValue: %s\n",Models[i], revResult);
- //optional - stop searching if found...
+ // optional - stop searching if found...
found = true;
} else {
if (crcChars > 2){
char *swapEndian = SwapEndianStr(revResult, crcChars, crcChars);
if (memcmp(swapEndian, inCRC, crcChars)==0){
PrintAndLog("\nFound a possible match!\nModel Reversed: %s\nValue EndianSwapped: %s\n",Models[i], swapEndian);
- //optional - stop searching if found...
+ // optional - stop searching if found...
found = true;
}
free(swapEndian);
}
}
}
- //}
+ // }
free(inCRC);
free(outHex);
free(Models[i]);
}
+
if (!found) PrintAndLog("\nNo matches found\n");
return 1;
}
diff --git a/client/reveng/bmpbit.c b/client/reveng/bmpbit.c
index 5462f850f..fbf97ab21 100644
--- a/client/reveng/bmpbit.c
+++ b/client/reveng/bmpbit.c
@@ -1,9 +1,10 @@
/* bmpbit.c
- * Greg Cook, 27/Jun/2016
+ * Greg Cook, 7/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
diff --git a/client/reveng/cli.c b/client/reveng/cli.c
index 5b91c3dce..3cdb60ddb 100644
--- a/client/reveng/cli.c
+++ b/client/reveng/cli.c
@@ -1,9 +1,10 @@
/* cli.c
- * Greg Cook, 27/Jun/2016
+ * Greg Cook, 19/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -21,7 +22,9 @@
* along with CRC RevEng. If not, see .
*/
-/* 2016-06-27: -P sets width like -k
+/* 2017-02-18: -G ignored if R_HAVEP
+ * 2017-02-05: added -G
+ * 2016-06-27: -P sets width like -k
* 2015-04-03: added -z
* 2013-09-16: do not search with -M
* 2013-06-11: uprog() suppresses first progress report
@@ -73,14 +76,7 @@ int reveng_main(int argc, char *argv[]) {
*/
/* default values */
- model_t model = {
- PZERO, /* no CRC polynomial, user must specify */
- PZERO, /* Init = 0 */
- P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */
- PZERO, /* XorOut = 0 */
- PZERO, /* check value unused */
- NULL /* no model name */
- };
+ model_t model = MZERO;
int ibperhx = 8, obperhx = 8;
int rflags = 0, uflags = 0; /* search and UI flags */
@@ -102,7 +98,7 @@ int reveng_main(int argc, char *argv[]) {
pos=0;
optind=1;
do {
- c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:yz");
+ c=getopt(argc, argv, "?A:BDFGLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:yz");
switch(c) {
case 'A': /* A: bits per output character */
case 'a': /* a: bits per character */
@@ -138,14 +134,17 @@ int reveng_main(int argc, char *argv[]) {
}
mode = c;
break;
- case 'F': /* F force search */
+ case 'F': /* F skip preset model check pass */
#ifndef NOFORCE
- uflags |= C_FORCE;
+ uflags |= C_NOPCK;
#endif
break;
case 'f': /* f arguments are filenames */
uflags |= C_INFILE;
break;
+ case 'G': /* G skip brute force search pass */
+ uflags |= C_NOBFS;
+ break;
case 'h': /* h get help / usage */
case 'u': /* u get help / usage */
case '?': /* ? get help / usage */
@@ -158,8 +157,8 @@ int reveng_main(int argc, char *argv[]) {
pptr = &model.init;
rflags |= R_HAVEI;
goto ipqx;
- case 'P': /* P: reversed polynomial */
case 'k': /* k: polynomial in Koopman notation */
+ case 'P': /* P: reversed polynomial */
pfree(&model.spoly);
model.spoly = strtop(optarg, 0, 4);
pkchop(&model.spoly);
@@ -322,11 +321,10 @@ ipqx:
uerror("no preset models available");
return 0;
}
- for(mode = 0; mode < args; ++mode) {
- mbynum(&model, mode);
- mcanon(&model);
+ do {
+ mbynum(&model, --args);
ufound(&model);
- }
+ } while(args);
break;
case 'd': /* d dump CRC model */
/* maybe we don't want to do this:
@@ -398,7 +396,7 @@ ipqx:
*/
/* scan against preset models */
- if(~uflags & C_FORCE) {
+ if(~uflags & C_NOPCK) {
pass = 0;
do {
psets = mcount();
@@ -428,7 +426,6 @@ ipqx:
pfree(&apoly);
if(qptr == pptr) {
/* the selected model solved all arguments */
- mcanon(&pset);
ufound(&pset);
uflags |= C_RESULT;
}
@@ -449,6 +446,11 @@ ipqx:
return 1;
//exit(EXIT_SUCCESS);
}
+ if(uflags & C_NOBFS && ~rflags & R_HAVEP) {
+ uerror("no models found");
+ return 0;
+ //break;
+ }
if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT)){
uerror("cannot search for crossed-endian models");
return 0;
@@ -481,6 +483,7 @@ ipqx:
break;
default: /* no mode specified */
fprintf(stderr, "%s: no mode switch specified. Use %s -h for help.\n", myname, myname);
+ return 0;
//exit(EXIT_FAILURE);
}
@@ -577,7 +580,7 @@ usage(void) {
"Usage:\t");
fputs(myname, stderr);
fprintf(stderr,
- "\t-cdDesvhu? [-bBfFlLMrStVXyz]\n"
+ "\t-cdDesvhu? [-bBfFGlLMrStVXyz]\n"
"\t\t[-a BITS] [-A OBITS] [-i INIT] [-k KPOLY] [-m MODEL]\n"
"\t\t[-p POLY] [-P RPOLY] [-q QPOLY] [-w WIDTH] [-x XOROUT]\n"
"\t\t[STRING...]\n"
@@ -596,12 +599,13 @@ usage(void) {
"\t-x XOROUT\tfinal register XOR value\n"
"Modifier switches:\n"
"\t-b big-endian CRC\t\t-B big-endian CRC output\n"
- "\t-f read files named in STRINGs\t-F find presets less quickly\n"
- "\t-l little-endian CRC\t\t-L little-endian CRC output\n"
- "\t-M non-augmenting algorithm\t-r right-justified output\n"
- "\t-S print spaces between chars\t-t left-justified output\n"
- "\t-V reverse algorithm only\t-X print uppercase hex\n"
- "\t-y low bytes first in files\t-z raw binary STRINGs\n");
+ "\t-f read files named in STRINGs\t-F skip preset model check pass\n"
+ "\t-G skip brute force search pass\t-l little-endian CRC\n"
+ "\t-L little-endian CRC output\t-M non-augmenting algorithm\n"
+ "\t-r right-justified output\t-S print spaces between characters\n"
+ "\t-t left-justified output\t-V reverse algorithm only\n"
+ "\t-X print uppercase hexadecimal\t-y low bytes first in files\n"
+ "\t-z raw binary STRINGs\n");
fprintf(stderr,
"Mode switches:\n"
"\t-c calculate CRCs\t\t-d dump algorithm parameters\n"
@@ -621,7 +625,7 @@ usage(void) {
"\t Outputs a list of all known/common crc models with their\n"
"\t preset values\n"
"\n"
- "Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook\n"
+ "Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Gregory Cook\n"
"This is free software; see the source for copying conditions. There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
"Version "
diff --git a/client/reveng/config.h b/client/reveng/config.h
index 71471c87a..53f777474 100644
--- a/client/reveng/config.h
+++ b/client/reveng/config.h
@@ -1,9 +1,10 @@
/* config.h
- * Greg Cook, 27/Jun/2016
+ * Greg Cook, 7/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
diff --git a/client/reveng/model.c b/client/reveng/model.c
index de0d16796..d1728b39f 100644
--- a/client/reveng/model.c
+++ b/client/reveng/model.c
@@ -1,9 +1,10 @@
/* model.c
- * Greg Cook, 26/Jul/2016
+ * Greg Cook, 19/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -21,7 +22,9 @@
* along with CRC RevEng. If not, see .
*/
-/* 2016-02-22: split off preset.c
+/* 2017-02-19: revised residue calculation for crossed-endian models
+ * 2017-02-05: added magic field
+ * 2016-02-22: split off preset.c
* 2012-03-03: single-line Williams model string conversion
* 2011-09-03: added mrev(), mnovel()
* 2011-01-17: fixed ANSI C warnings (except preset models)
@@ -54,6 +57,7 @@ mcpy(model_t *dest, const model_t *src) {
pcpy(&dest->init, src->init);
pcpy(&dest->xorout, src->xorout);
pcpy(&dest->check, src->check);
+ pcpy(&dest->magic, src->magic);
dest->flags = src->flags;
/* link to the name as it is static */
dest->name = src->name;
@@ -67,6 +71,7 @@ mfree(model_t *model) {
pfree(&model->init);
pfree(&model->xorout);
pfree(&model->check);
+ pfree(&model->magic);
/* not name as it is static */
/* not model either, it might point to an array! */
}
@@ -95,25 +100,28 @@ mtostr(const model_t *model) {
* mcanon() should be called on the argument before printing.
*/
size_t size;
- char *polystr, *initstr, *xorotstr, *checkstr, strbuf[512], *string = NULL;
+ char *polystr, *initstr, *xorotstr, *checkstr, *magicstr,
+ strbuf[512], *string = NULL;
if(!model) return(NULL);
polystr = ptostr(model->spoly, P_RTJUST, 4);
initstr = ptostr(model->init, P_RTJUST, 4);
xorotstr = ptostr(model->xorout, P_RTJUST, 4);
checkstr = ptostr(model->check, P_RTJUST, 4);
+ magicstr = ptostr(model->magic, P_RTJUST, 4);
sprintf(strbuf, "%lu", plen(model->spoly));
size =
- 70
- + (model->name && *model->name ? 2 + strlen(model->name) : 6)
+ 82
+ strlen(strbuf)
+ (polystr && *polystr ? strlen(polystr) : 6)
+ (initstr && *initstr ? strlen(initstr) : 6)
+ (model->flags & P_REFIN ? 4 : 5)
+ (model->flags & P_REFOUT ? 4 : 5)
+ (xorotstr && *xorotstr ? strlen(xorotstr) : 6)
- + (checkstr && *checkstr ? strlen(checkstr) : 6);
+ + (checkstr && *checkstr ? strlen(checkstr) : 6)
+ + (magicstr && *magicstr ? strlen(magicstr) : 6)
+ + (model->name && *model->name ? 2 + strlen(model->name) : 6);
if((string = malloc(size))) {
sprintf(strbuf, "\"%s\"", model->name);
sprintf(string,
@@ -124,6 +132,7 @@ mtostr(const model_t *model) {
"refout=%s "
"xorout=0x%s "
"check=0x%s "
+ "residue=0x%s "
"name=%s",
plen(model->spoly),
polystr && *polystr ? polystr : "(none)",
@@ -132,12 +141,14 @@ mtostr(const model_t *model) {
(model->flags & P_REFOUT) ? "true" : "false",
xorotstr && *xorotstr ? xorotstr : "(none)",
checkstr && *checkstr ? checkstr : "(none)",
+ magicstr && *magicstr ? magicstr : "(none)",
(model->name && *model->name) ? strbuf : "(none)");
}
free(polystr);
free(initstr);
free(xorotstr);
free(checkstr);
+ free(magicstr);
if(!string)
uerror("cannot allocate memory for model description");
return(string);
@@ -166,23 +177,42 @@ mcanon(model_t *model) {
* might be noticed. Storing the Check value with each preset
* is highly preferred.
*/
- if(!plen(model->check))
+ if(!(plen(model->check) && plen(model->magic)))
mcheck(model);
}
void
mcheck(model_t *model) {
/* calculate a check for the model */
- poly_t checkstr, check;
+ poly_t checkstr, check, xorout, magic;
+
+ /* erase existing check and magic. Models with these
+ * fields recalculated should have no name.
+ */
+ mnovel(model);
/* generate the check string with the correct bit order */
checkstr = strtop("313233343536373839", model->flags, 8);
check = pcrc(checkstr, model->spoly, model->init, pzero, model->flags);
+ pfree(&checkstr);
if(model->flags & P_REFOUT)
prev(&check);
psum(&check, model->xorout, 0UL);
model->check = check;
- pfree(&checkstr);
+
+ /* calculate residue by emulating receipt of error-free message
+ * The residue of a crossed-endian model is calculated assuming
+ * that the characters of the received CRC are specially
+ * reflected before submitting the codeword.
+ */
+ xorout=pclone(model->xorout);
+ if(model->flags & P_REFOUT)
+ prev(&xorout);
+ magic = pcrc(xorout, model->spoly, pzero, pzero, model->flags);
+ pfree(&xorout);
+ if(model->flags & P_REFIN)
+ prev(&magic);
+ model->magic = magic;
}
void
@@ -221,4 +251,5 @@ mnovel(model_t *model) {
/* remove name and check string from modified model */
model->name = NULL;
pfree(&model->check);
+ pfree(&model->magic);
}
diff --git a/client/reveng/poly.c b/client/reveng/poly.c
index 35e38af3f..647213338 100644
--- a/client/reveng/poly.c
+++ b/client/reveng/poly.c
@@ -1,9 +1,10 @@
/* poly.c
- * Greg Cook, 26/Jul/2016
+ * Greg Cook, 7/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -640,6 +641,7 @@ pshift(poly_t *dest, const poly_t src, unsigned long head, unsigned long start,
/* copies bits start to end-1 of src to dest, plus the number of leading and trailing zeroes given by head and tail.
* end may exceed the length of src in which case more zeroes are appended.
* dest may point to src, in which case the poly is edited in place.
+ * src must be CLEAN.
* On exit, dest is CLEAN.
*/
diff --git a/client/reveng/preset.c b/client/reveng/preset.c
index c6864a9c8..565a1ce10 100644
--- a/client/reveng/preset.c
+++ b/client/reveng/preset.c
@@ -1,9 +1,10 @@
/* preset.c
- * Greg Cook, 26/Jul/2016
+ * Greg Cook, 19/Jun/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -21,7 +22,12 @@
* along with CRC RevEng. If not, see .
*/
-/* 2016-07-26: added array order checking code
+/* 2017-06-19: added CRC-8/BLUETOOTH, CRC-17/CAN-FD, CRC-21/CAN-FD
+ * 2017-02-18: added 8 new GSM algorithms
+ * 2017-02-06: munpack() produces canonical models
+ * 2017-02-05: added magic field
+ * 2017-02-01: added CRC-64/GO-ISO, 2 new aliases
+ * 2016-07-26: added array order checking code
* 2016-07-25: added 5 new algorithms
* 2016-07-14: added CRC-16/CMS
* 2016-07-08: added CRC-16/PROFIBUS
@@ -72,6 +78,7 @@ struct mpreset {
const int flags; /* P_REFIN and P_REFOUT indicate reflected input/output */
const bmp_t *const bxorout; /* final register XOR mask. length == poly.length */
const bmp_t *const bcheck; /* optional check value, the CRC of the UTF-8 string "123456789" */
+ const bmp_t *const bmagic; /* optional magic check value, the residue of a valid codeword */
const struct malias *const alias; /* optional canonical name of the model */
};
@@ -91,11 +98,17 @@ struct malias {
/* CONSTANT b40 = (40, 0x0004820009) */
/* CONSTANT b40a = (40, 0xffffffffff) */
/* CONSTANT b40b = (40, 0xd4164fc646) */
-/* CONSTANT b64 = (64, 0x42f0e1eba9ea3693) */
-/* CONSTANT b64a = (64, 0x6c40df5f0b497347) */
-/* CONSTANT b64b = (64, 0xffffffffffffffff) */
-/* CONSTANT b64c = (64, 0x62ec59e3f1a4f00a) */
-/* CONSTANT b64d = (64, 0x995dc9bbdf1939fa) */
+/* CONSTANT b40c = (40, 0xc4ff8071ff) */
+/* CONSTANT b64 = (64, 0x000000000000001b) */
+/* CONSTANT b64a = (64, 0xffffffffffffffff) */
+/* CONSTANT b64b = (64, 0xb90956c775a41001) */
+/* CONSTANT b64c = (64, 0x5300000000000000) */
+/* CONSTANT b64d = (64, 0x42f0e1eba9ea3693) */
+/* CONSTANT b64e = (64, 0x6c40df5f0b497347) */
+/* CONSTANT b64f = (64, 0x62ec59e3f1a4f00a) */
+/* CONSTANT b64g = (64, 0xfcacbebd5931a992) */
+/* CONSTANT b64h = (64, 0x995dc9bbdf1939fa) */
+/* CONSTANT b64i = (64, 0x49958c9abd7d353f) */
/* CONSTANT b82 = (82, 0x0308c0111011401440411) */
/* CONSTANT b82a = (82, 0x09ea83f625023801fd612) */
@@ -113,6 +126,9 @@ static const bmp_t b40a[] = {
static const bmp_t b40b[] = {
BMP_C(0xd4164fc646) << (BMP_BIT - 40),
};
+static const bmp_t b40c[] = {
+ BMP_C(0xc4ff8071ff) << (BMP_BIT - 40),
+};
# else /* BMP_BIT */
static const bmp_t b40[] = {
BMP_C(0x00048200) << (BMP_BIT - 32) | BMP_C(0x04) >> (39 - BMP_BIT),
@@ -126,45 +142,84 @@ static const bmp_t b40b[] = {
BMP_C(0xd4164fc6) << (BMP_BIT - 32) | BMP_C(0x23) >> (39 - BMP_BIT),
BMP_C(0x46) << (BMP_BIT * 2 - 40),
};
+static const bmp_t b40c[] = {
+ BMP_C(0xc4ff8071) << (BMP_BIT - 32) | BMP_C(0x7f) >> (39 - BMP_BIT),
+ BMP_C(0xff) << (BMP_BIT * 2 - 40),
+};
# endif /* BMP_BIT */
# if BMP_BIT >= 64
static const bmp_t b64[] = {
- BMP_C(0x42f0e1eba9ea3693) << (BMP_BIT - 64),
+ BMP_C(0x000000000000001b) << (BMP_BIT - 64),
};
static const bmp_t b64a[] = {
- BMP_C(0x6c40df5f0b497347) << (BMP_BIT - 64),
-};
-static const bmp_t b64b[] = {
BMP_C(0xffffffffffffffff) << (BMP_BIT - 64),
};
+static const bmp_t b64b[] = {
+ BMP_C(0xb90956c775a41001) << (BMP_BIT - 64),
+};
static const bmp_t b64c[] = {
- BMP_C(0x62ec59e3f1a4f00a) << (BMP_BIT - 64),
+ BMP_C(0x5300000000000000) << (BMP_BIT - 64),
};
static const bmp_t b64d[] = {
+ BMP_C(0x42f0e1eba9ea3693) << (BMP_BIT - 64),
+};
+static const bmp_t b64e[] = {
+ BMP_C(0x6c40df5f0b497347) << (BMP_BIT - 64),
+};
+static const bmp_t b64f[] = {
+ BMP_C(0x62ec59e3f1a4f00a) << (BMP_BIT - 64),
+};
+static const bmp_t b64g[] = {
+ BMP_C(0xfcacbebd5931a992) << (BMP_BIT - 64),
+};
+static const bmp_t b64h[] = {
BMP_C(0x995dc9bbdf1939fa) << (BMP_BIT - 64),
};
+static const bmp_t b64i[] = {
+ BMP_C(0x49958c9abd7d353f) << (BMP_BIT - 64),
+};
# else /* BMP_BIT */
static const bmp_t b64[] = {
- BMP_C(0x42f0e1eb) << (BMP_BIT - 32) | BMP_C(0x54f51b49) >> (63 - BMP_BIT),
- BMP_C(0xa9ea3693) << (BMP_BIT * 2 - 64),
+ BMP_C(0x00000000) << (BMP_BIT - 32) | BMP_C(0x0000000d) >> (63 - BMP_BIT),
+ BMP_C(0x0000001b) << (BMP_BIT * 2 - 64),
};
static const bmp_t b64a[] = {
- BMP_C(0x6c40df5f) << (BMP_BIT - 32) | BMP_C(0x05a4b9a3) >> (63 - BMP_BIT),
- BMP_C(0x0b497347) << (BMP_BIT * 2 - 64),
-};
-static const bmp_t b64b[] = {
BMP_C(0xffffffff) << (BMP_BIT - 32) | BMP_C(0x7fffffff) >> (63 - BMP_BIT),
BMP_C(0xffffffff) << (BMP_BIT * 2 - 64),
};
+static const bmp_t b64b[] = {
+ BMP_C(0xb90956c7) << (BMP_BIT - 32) | BMP_C(0x3ad20800) >> (63 - BMP_BIT),
+ BMP_C(0x75a41001) << (BMP_BIT * 2 - 64),
+};
static const bmp_t b64c[] = {
+ BMP_C(0x53000000) << (BMP_BIT - 32) | BMP_C(0x00000000) >> (63 - BMP_BIT),
+ BMP_C(0x00000000) << (BMP_BIT * 2 - 64),
+};
+static const bmp_t b64d[] = {
+ BMP_C(0x42f0e1eb) << (BMP_BIT - 32) | BMP_C(0x54f51b49) >> (63 - BMP_BIT),
+ BMP_C(0xa9ea3693) << (BMP_BIT * 2 - 64),
+};
+static const bmp_t b64e[] = {
+ BMP_C(0x6c40df5f) << (BMP_BIT - 32) | BMP_C(0x05a4b9a3) >> (63 - BMP_BIT),
+ BMP_C(0x0b497347) << (BMP_BIT * 2 - 64),
+};
+static const bmp_t b64f[] = {
BMP_C(0x62ec59e3) << (BMP_BIT - 32) | BMP_C(0x78d27805) >> (63 - BMP_BIT),
BMP_C(0xf1a4f00a) << (BMP_BIT * 2 - 64),
};
-static const bmp_t b64d[] = {
+static const bmp_t b64g[] = {
+ BMP_C(0xfcacbebd) << (BMP_BIT - 32) | BMP_C(0x2c98d4c9) >> (63 - BMP_BIT),
+ BMP_C(0x5931a992) << (BMP_BIT * 2 - 64),
+};
+static const bmp_t b64h[] = {
BMP_C(0x995dc9bb) << (BMP_BIT - 32) | BMP_C(0x6f8c9cfd) >> (63 - BMP_BIT),
BMP_C(0xdf1939fa) << (BMP_BIT * 2 - 64),
};
+static const bmp_t b64i[] = {
+ BMP_C(0x49958c9a) << (BMP_BIT - 32) | BMP_C(0x5ebe9a9f) >> (63 - BMP_BIT),
+ BMP_C(0xbd7d353f) << (BMP_BIT * 2 - 64),
+};
# endif /* BMP_BIT */
# if BMP_BIT >= 82
@@ -201,168 +256,209 @@ static const bmp_t b82a[] = {
/* Array of the polynomial bitmaps used in the model table. */
static const bmp_t b32[] = {
- BMP_C(0x00000000) << (BMP_BIT - 32), /* 0 -- 5, 00 */
- BMP_C(0x000000af) << (BMP_BIT - 32), /* 1 -- 32,000000af */
- BMP_C(0x00010000) << (BMP_BIT - 32), /* 2 -- 16, 0001 */
- BMP_C(0x00020000) << (BMP_BIT - 32), /* 3 -- 15, 0001 */
- BMP_C(0x00065b00) << (BMP_BIT - 32), /* 4 -- 24, 00065b */
- BMP_C(0x007e0000) << (BMP_BIT - 32), /* 5 -- 16, 007e */
- BMP_C(0x007f0000) << (BMP_BIT - 32), /* 6 -- 16, 007f */
- BMP_C(0x03400000) << (BMP_BIT - 32), /* 7 -- 11, 01a */
- BMP_C(0x0376e6e7) << (BMP_BIT - 32), /* 8 -- 32,0376e6e7 */
- BMP_C(0x04c11db7) << (BMP_BIT - 32), /* 9 -- 32,04c11db7 */
- BMP_C(0x05890000) << (BMP_BIT - 32), /* 10 -- 16, 0589 */
- BMP_C(0x07000000) << (BMP_BIT - 32), /* 11 -- 8, 07 */
- BMP_C(0x09823b6e) << (BMP_BIT - 32), /* 12 -- 31,04c11db7 */
- BMP_C(0x0b3c0000) << (BMP_BIT - 32), /* 13 -- 15, 059e */
- BMP_C(0x0c000000) << (BMP_BIT - 32), /* 14 -- 6, 03 */
- BMP_C(0x0c200000) << (BMP_BIT - 32), /* 15 -- 11, 061 */
+ BMP_C(0x000000af) << (BMP_BIT - 32), /* 0 -- 32,000000af */
+ BMP_C(0x00010000) << (BMP_BIT - 32), /* 1 -- 16, 0001 */
+ BMP_C(0x00020000) << (BMP_BIT - 32), /* 2 -- 15, 0001 */
+ BMP_C(0x00065b00) << (BMP_BIT - 32), /* 3 -- 24, 00065b */
+ BMP_C(0x007e0000) << (BMP_BIT - 32), /* 4 -- 16, 007e */
+ BMP_C(0x007f0000) << (BMP_BIT - 32), /* 5 -- 16, 007f */
+ BMP_C(0x03400000) << (BMP_BIT - 32), /* 6 -- 11, 01a */
+ BMP_C(0x0376e6e7) << (BMP_BIT - 32), /* 7 -- 32,0376e6e7 */
+ BMP_C(0x04c11db7) << (BMP_BIT - 32), /* 8 -- 32,04c11db7 */
+ BMP_C(0x05890000) << (BMP_BIT - 32), /* 9 -- 16, 0589 */
+ BMP_C(0x07000000) << (BMP_BIT - 32), /* 10 -- 8, 07 */
+ BMP_C(0x09823b6e) << (BMP_BIT - 32), /* 11 -- 31,04c11db7 */
+ BMP_C(0x0b3c0000) << (BMP_BIT - 32), /* 12 -- 15, 059e */
+ BMP_C(0x0c000000) << (BMP_BIT - 32), /* 13 -- 6, 03 */
+ BMP_C(0x0c200000) << (BMP_BIT - 32), /* 14 -- 11, 061 */
+ BMP_C(0x0c780000) << (BMP_BIT - 32), /* 15 -- 14, 031e */
BMP_C(0x0fb30000) << (BMP_BIT - 32), /* 16 -- 16, 0fb3 */
BMP_C(0x10210000) << (BMP_BIT - 32), /* 17 -- 16, 1021 */
BMP_C(0x12000000) << (BMP_BIT - 32), /* 18 -- 7, 09 */
BMP_C(0x130d2afc) << (BMP_BIT - 32), /* 19 -- 30,04c34abf */
- BMP_C(0x15000000) << (BMP_BIT - 32), /* 20 -- 8, 15 */
- BMP_C(0x1697d06a) << (BMP_BIT - 32), /* 21 -- 32,1697d06a */
- BMP_C(0x18000000) << (BMP_BIT - 32), /* 22 -- 6, 06 */
- BMP_C(0x19d3c8d8) << (BMP_BIT - 32), /* 23 -- 31,0ce9e46c */
- BMP_C(0x1c000000) << (BMP_BIT - 32), /* 24 -- 6, 07 */
- BMP_C(0x1d000000) << (BMP_BIT - 32), /* 25 -- 8, 1d */
- BMP_C(0x1d0f0000) << (BMP_BIT - 32), /* 26 -- 16, 1d0f */
- BMP_C(0x1dcf0000) << (BMP_BIT - 32), /* 27 -- 16, 1dcf */
- BMP_C(0x1edc6f41) << (BMP_BIT - 32), /* 28 -- 32,1edc6f41 */
- BMP_C(0x1f23b800) << (BMP_BIT - 32), /* 29 -- 24, 1f23b8 */
- BMP_C(0x20140000) << (BMP_BIT - 32), /* 30 -- 14, 0805 */
- BMP_C(0x20b40000) << (BMP_BIT - 32), /* 31 -- 14, 082d */
- BMP_C(0x20fe0000) << (BMP_BIT - 32), /* 32 -- 16, 20fe */
- BMP_C(0x21890000) << (BMP_BIT - 32), /* 33 -- 16, 2189 */
- BMP_C(0x21cf0200) << (BMP_BIT - 32), /* 34 -- 24, 21cf02 */
- BMP_C(0x23ef5200) << (BMP_BIT - 32), /* 35 -- 24, 23ef52 */
- BMP_C(0x25000000) << (BMP_BIT - 32), /* 36 -- 8, 25 */
- BMP_C(0x26b10000) << (BMP_BIT - 32), /* 37 -- 16, 26b1 */
- BMP_C(0x27d00000) << (BMP_BIT - 32), /* 38 -- 13, 04fa */
- BMP_C(0x28000000) << (BMP_BIT - 32), /* 39 -- 5, 05 */
- BMP_C(0x29b10000) << (BMP_BIT - 32), /* 40 -- 16, 29b1 */
- BMP_C(0x2f000000) << (BMP_BIT - 32), /* 41 -- 8, 2f */
- BMP_C(0x30000000) << (BMP_BIT - 32), /* 42 -- 4, 3 */
- BMP_C(0x3010bf7f) << (BMP_BIT - 32), /* 43 -- 32,3010bf7f */
- BMP_C(0x31000000) << (BMP_BIT - 32), /* 44 -- 8, 31 */
- BMP_C(0x31c30000) << (BMP_BIT - 32), /* 45 -- 16, 31c3 */
- BMP_C(0x328b6300) << (BMP_BIT - 32), /* 46 -- 24, 328b63 */
- BMP_C(0x34000000) << (BMP_BIT - 32), /* 47 -- 6, 0d */
- BMP_C(0x340bc6d9) << (BMP_BIT - 32), /* 48 -- 32,340bc6d9 */
- BMP_C(0x38000000) << (BMP_BIT - 32), /* 49 -- 5, 07 */
- BMP_C(0x39000000) << (BMP_BIT - 32), /* 50 -- 8, 39 */
- BMP_C(0x3d650000) << (BMP_BIT - 32), /* 51 -- 16, 3d65 */
- BMP_C(0x3e000000) << (BMP_BIT - 32), /* 52 -- 8, 3e */
- BMP_C(0x44c20000) << (BMP_BIT - 32), /* 53 -- 16, 44c2 */
- BMP_C(0x48000000) << (BMP_BIT - 32), /* 54 -- 5, 09 */
- BMP_C(0x4acc0000) << (BMP_BIT - 32), /* 55 -- 15, 2566 */
- BMP_C(0x4b000000) << (BMP_BIT - 32), /* 56 -- 8, 4b */
- BMP_C(0x4b370000) << (BMP_BIT - 32), /* 57 -- 16, 4b37 */
- BMP_C(0x4c060000) << (BMP_BIT - 32), /* 58 -- 16, 4c06 */
- BMP_C(0x55000000) << (BMP_BIT - 32), /* 59 -- 8, 55 */
- BMP_C(0x55555500) << (BMP_BIT - 32), /* 60 -- 24, 555555 */
- BMP_C(0x59350000) << (BMP_BIT - 32), /* 61 -- 16, 5935 */
- BMP_C(0x5d380000) << (BMP_BIT - 32), /* 62 -- 16, 5d38 */
- BMP_C(0x5d6dcb00) << (BMP_BIT - 32), /* 63 -- 24, 5d6dcb */
- BMP_C(0x60000000) << (BMP_BIT - 32), /* 64 -- 3, 3 */
- BMP_C(0x60e00000) << (BMP_BIT - 32), /* 65 -- 11, 307 */
- BMP_C(0x63d00000) << (BMP_BIT - 32), /* 66 -- 16, 63d0 */
- BMP_C(0x64000000) << (BMP_BIT - 32), /* 67 -- 6, 19 */
- BMP_C(0x66400000) << (BMP_BIT - 32), /* 68 -- 10, 199 */
- BMP_C(0x6f630000) << (BMP_BIT - 32), /* 69 -- 16, 6f63 */
- BMP_C(0x6f910000) << (BMP_BIT - 32), /* 70 -- 16, 6f91 */
- BMP_C(0x70000000) << (BMP_BIT - 32), /* 71 -- 4, 7 */
- BMP_C(0x70a00000) << (BMP_BIT - 32), /* 72 -- 11, 385 */
- BMP_C(0x755b0000) << (BMP_BIT - 32), /* 73 -- 16, 755b */
- BMP_C(0x765e7680) << (BMP_BIT - 32), /* 74 -- 32,765e7680 */
- BMP_C(0x7979bd00) << (BMP_BIT - 32), /* 75 -- 24, 7979bd */
- BMP_C(0x7e000000) << (BMP_BIT - 32), /* 76 -- 8, 7e */
- BMP_C(0x80006300) << (BMP_BIT - 32), /* 77 -- 24, 800063 */
- BMP_C(0x80050000) << (BMP_BIT - 32), /* 78 -- 16, 8005 */
- BMP_C(0x800d0000) << (BMP_BIT - 32), /* 79 -- 16, 800d */
- BMP_C(0x80c2e71c) << (BMP_BIT - 32), /* 80 -- 30,2030b9c7 */
- BMP_C(0x80f00000) << (BMP_BIT - 32), /* 81 -- 12, 80f */
- BMP_C(0x814141ab) << (BMP_BIT - 32), /* 82 -- 32,814141ab */
- BMP_C(0x864cfb00) << (BMP_BIT - 32), /* 83 -- 24, 864cfb */
- BMP_C(0x87315576) << (BMP_BIT - 32), /* 84 -- 32,87315576 */
- BMP_C(0x89ec0000) << (BMP_BIT - 32), /* 85 -- 16, 89ec */
- BMP_C(0x8a000000) << (BMP_BIT - 32), /* 86 -- 7, 45 */
- BMP_C(0x8b320000) << (BMP_BIT - 32), /* 87 -- 15, 4599 */
- BMP_C(0x8bb70000) << (BMP_BIT - 32), /* 88 -- 16, 8bb7 */
- BMP_C(0x8cc00000) << (BMP_BIT - 32), /* 89 -- 10, 233 */
- BMP_C(0x906e0000) << (BMP_BIT - 32), /* 90 -- 16, 906e */
- BMP_C(0x97000000) << (BMP_BIT - 32), /* 91 -- 8, 97 */
- BMP_C(0x98000000) << (BMP_BIT - 32), /* 92 -- 6, 26 */
- BMP_C(0x9b000000) << (BMP_BIT - 32), /* 93 -- 8, 9b */
- BMP_C(0x9c000000) << (BMP_BIT - 32), /* 94 -- 6, 27 */
- BMP_C(0x9e000000) << (BMP_BIT - 32), /* 95 -- 7, 4f */
- BMP_C(0x9ecf0000) << (BMP_BIT - 32), /* 96 -- 16, 9ecf */
- BMP_C(0xa0970000) << (BMP_BIT - 32), /* 97 -- 16, a097 */
- BMP_C(0xa1000000) << (BMP_BIT - 32), /* 98 -- 8, a1 */
- BMP_C(0xa6000000) << (BMP_BIT - 32), /* 99 -- 7, 53 */
- BMP_C(0xa8000000) << (BMP_BIT - 32), /* 100 -- 5, 15 */
- BMP_C(0xa8190000) << (BMP_BIT - 32), /* 101 -- 16, a819 */
- BMP_C(0xa833982b) << (BMP_BIT - 32), /* 102 -- 32,a833982b */
- BMP_C(0xabcdef00) << (BMP_BIT - 32), /* 103 -- 24, abcdef */
- BMP_C(0xaee70000) << (BMP_BIT - 32), /* 104 -- 16, aee7 */
- BMP_C(0xb0000000) << (BMP_BIT - 32), /* 105 -- 4, b */
- BMP_C(0xb2aa0000) << (BMP_BIT - 32), /* 106 -- 16, b2aa */
- BMP_C(0xb4600000) << (BMP_BIT - 32), /* 107 -- 11, 5a3 */
- BMP_C(0xb4c80000) << (BMP_BIT - 32), /* 108 -- 16, b4c8 */
- BMP_C(0xb4f3e600) << (BMP_BIT - 32), /* 109 -- 24, b4f3e6 */
- BMP_C(0xb704ce00) << (BMP_BIT - 32), /* 110 -- 24, b704ce */
- BMP_C(0xbb3d0000) << (BMP_BIT - 32), /* 111 -- 16, bb3d */
- BMP_C(0xbc000000) << (BMP_BIT - 32), /* 112 -- 8, bc */
- BMP_C(0xbd0be338) << (BMP_BIT - 32), /* 113 -- 32,bd0be338 */
- BMP_C(0xbdf40000) << (BMP_BIT - 32), /* 114 -- 16, bdf4 */
- BMP_C(0xbf050000) << (BMP_BIT - 32), /* 115 -- 16, bf05 */
- BMP_C(0xc0000000) << (BMP_BIT - 32), /* 116 -- 3, 6 */
- BMP_C(0xc2000000) << (BMP_BIT - 32), /* 117 -- 7, 61 */
- BMP_C(0xc25a5600) << (BMP_BIT - 32), /* 118 -- 24, c25a56 */
- BMP_C(0xc2b70000) << (BMP_BIT - 32), /* 119 -- 16, c2b7 */
- BMP_C(0xc6c60000) << (BMP_BIT - 32), /* 120 -- 16, c6c6 */
- BMP_C(0xc8000000) << (BMP_BIT - 32), /* 121 -- 5, 19 */
- BMP_C(0xc8670000) << (BMP_BIT - 32), /* 122 -- 16, c867 */
- BMP_C(0xcbf43926) << (BMP_BIT - 32), /* 123 -- 32,cbf43926 */
- BMP_C(0xcde70300) << (BMP_BIT - 32), /* 124 -- 24, cde703 */
- BMP_C(0xd0000000) << (BMP_BIT - 32), /* 125 -- 8, d0 */
- BMP_C(0xd02a0000) << (BMP_BIT - 32), /* 126 -- 15, 6815 */
- BMP_C(0xd0db0000) << (BMP_BIT - 32), /* 127 -- 16, d0db */
- BMP_C(0xd4d00000) << (BMP_BIT - 32), /* 128 -- 12, d4d */
- BMP_C(0xd5000000) << (BMP_BIT - 32), /* 129 -- 8, d5 */
- BMP_C(0xd64e0000) << (BMP_BIT - 32), /* 130 -- 16, d64e */
- BMP_C(0xda000000) << (BMP_BIT - 32), /* 131 -- 8, da */
- BMP_C(0xdaf00000) << (BMP_BIT - 32), /* 132 -- 12, daf */
- BMP_C(0xdf000000) << (BMP_BIT - 32), /* 133 -- 8, df */
- BMP_C(0xe0000000) << (BMP_BIT - 32), /* 134 -- 3, 7 */
- BMP_C(0xe3069283) << (BMP_BIT - 32), /* 135 -- 32,e3069283 */
- BMP_C(0xe5cc0000) << (BMP_BIT - 32), /* 136 -- 16, e5cc */
- BMP_C(0xe7a80000) << (BMP_BIT - 32), /* 137 -- 13, 1cf5 */
- BMP_C(0xea000000) << (BMP_BIT - 32), /* 138 -- 7, 75 */
- BMP_C(0xea820000) << (BMP_BIT - 32), /* 139 -- 16, ea82 */
- BMP_C(0xec000000) << (BMP_BIT - 32), /* 140 -- 6, 3b */
- BMP_C(0xf0000000) << (BMP_BIT - 32), /* 141 -- 4, f */
- BMP_C(0xf1300000) << (BMP_BIT - 32), /* 142 -- 12, f13 */
- BMP_C(0xf4000000) << (BMP_BIT - 32), /* 143 -- 8, f4 */
- BMP_C(0xf4acfb13) << (BMP_BIT - 32), /* 144 -- 32,f4acfb13 */
- BMP_C(0xf5b00000) << (BMP_BIT - 32), /* 145 -- 12, f5b */
- BMP_C(0xf6400000) << (BMP_BIT - 32), /* 146 -- 10, 3d9 */
- BMP_C(0xf8000000) << (BMP_BIT - 32), /* 147 -- 5, 1f */
- BMP_C(0xfc000000) << (BMP_BIT - 32), /* 148 -- 6, 3f */
- BMP_C(0xfc891918) << (BMP_BIT - 32), /* 149 -- 32,fc891918 */
- BMP_C(0xfd000000) << (BMP_BIT - 32), /* 150 -- 8, fd */
- BMP_C(0xfe000000) << (BMP_BIT - 32), /* 151 -- 7, 7f */
- BMP_C(0xfedcba00) << (BMP_BIT - 32), /* 152 -- 24, fedcba */
- BMP_C(0xfee80000) << (BMP_BIT - 32), /* 153 -- 16, fee8 */
- BMP_C(0xff000000) << (BMP_BIT - 32), /* 154 -- 8, ff */
- BMP_C(0xffc00000) << (BMP_BIT - 32), /* 155 -- 10, 3ff */
- BMP_C(0xfff00000) << (BMP_BIT - 32), /* 156 -- 12, fff */
- BMP_C(0xffff0000) << (BMP_BIT - 32), /* 157 -- 16, ffff */
- BMP_C(0xffffff00) << (BMP_BIT - 32), /* 158 -- 24, ffffff */
- BMP_C(0xfffffffc) << (BMP_BIT - 32), /* 159 -- 30,3fffffff */
- BMP_C(0xfffffffe) << (BMP_BIT - 32), /* 160 -- 31,7fffffff */
- BMP_C(0xffffffff) << (BMP_BIT - 32), /* 161 -- 32,ffffffff */
+ BMP_C(0x144e6300) << (BMP_BIT - 32), /* 20 -- 24, 144e63 */
+ BMP_C(0x15000000) << (BMP_BIT - 32), /* 21 -- 8, 15 */
+ BMP_C(0x1697d06a) << (BMP_BIT - 32), /* 22 -- 32,1697d06a */
+ BMP_C(0x17800000) << (BMP_BIT - 32), /* 23 -- 12, 178 */
+ BMP_C(0x18000000) << (BMP_BIT - 32), /* 24 -- 6, 06 */
+ BMP_C(0x19d3c8d8) << (BMP_BIT - 32), /* 25 -- 31,0ce9e46c */
+ BMP_C(0x1c000000) << (BMP_BIT - 32), /* 26 -- 6, 07 */
+ BMP_C(0x1d000000) << (BMP_BIT - 32), /* 27 -- 8, 1d */
+ BMP_C(0x1d0f0000) << (BMP_BIT - 32), /* 28 -- 16, 1d0f */
+ BMP_C(0x1dcf0000) << (BMP_BIT - 32), /* 29 -- 16, 1dcf */
+ BMP_C(0x1edc6f41) << (BMP_BIT - 32), /* 30 -- 32,1edc6f41 */
+ BMP_C(0x1f23b800) << (BMP_BIT - 32), /* 31 -- 24, 1f23b8 */
+ BMP_C(0x20000000) << (BMP_BIT - 32), /* 32 -- 4, 2 */
+ BMP_C(0x20140000) << (BMP_BIT - 32), /* 33 -- 14, 0805 */
+ BMP_C(0x20b40000) << (BMP_BIT - 32), /* 34 -- 14, 082d */
+ BMP_C(0x20fe0000) << (BMP_BIT - 32), /* 35 -- 16, 20fe */
+ BMP_C(0x21890000) << (BMP_BIT - 32), /* 36 -- 16, 2189 */
+ BMP_C(0x21cf0200) << (BMP_BIT - 32), /* 37 -- 24, 21cf02 */
+ BMP_C(0x23ef5200) << (BMP_BIT - 32), /* 38 -- 24, 23ef52 */
+ BMP_C(0x25000000) << (BMP_BIT - 32), /* 39 -- 8, 25 */
+ BMP_C(0x26000000) << (BMP_BIT - 32), /* 40 -- 8, 26 */
+ BMP_C(0x26b10000) << (BMP_BIT - 32), /* 41 -- 16, 26b1 */
+ BMP_C(0x27818000) << (BMP_BIT - 32), /* 42 -- 17, 04f03 */
+ BMP_C(0x27d00000) << (BMP_BIT - 32), /* 43 -- 13, 04fa */
+ BMP_C(0x28000000) << (BMP_BIT - 32), /* 44 -- 5, 05 */
+ BMP_C(0x29b10000) << (BMP_BIT - 32), /* 45 -- 16, 29b1 */
+ BMP_C(0x2f000000) << (BMP_BIT - 32), /* 46 -- 8, 2f */
+ BMP_C(0x30000000) << (BMP_BIT - 32), /* 47 -- 4, 3/ 5, 6 */
+ BMP_C(0x3010bf7f) << (BMP_BIT - 32), /* 48 -- 32,3010bf7f */
+ BMP_C(0x31000000) << (BMP_BIT - 32), /* 49 -- 8, 31 */
+ BMP_C(0x31800000) << (BMP_BIT - 32), /* 50 -- 10, 0c6 */
+ BMP_C(0x31c30000) << (BMP_BIT - 32), /* 51 -- 16, 31c3 */
+ BMP_C(0x328b6300) << (BMP_BIT - 32), /* 52 -- 24, 328b63 */
+ BMP_C(0x34000000) << (BMP_BIT - 32), /* 53 -- 6, 0d */
+ BMP_C(0x340bc6d9) << (BMP_BIT - 32), /* 54 -- 32,340bc6d9 */
+ BMP_C(0x37000000) << (BMP_BIT - 32), /* 55 -- 8, 37 */
+ BMP_C(0x38000000) << (BMP_BIT - 32), /* 56 -- 5, 07 */
+ BMP_C(0x39000000) << (BMP_BIT - 32), /* 57 -- 8, 39 */
+ BMP_C(0x3d650000) << (BMP_BIT - 32), /* 58 -- 16, 3d65 */
+ BMP_C(0x3e000000) << (BMP_BIT - 32), /* 59 -- 8, 3e */
+ BMP_C(0x40000000) << (BMP_BIT - 32), /* 60 -- 3, 2 */
+ BMP_C(0x42000000) << (BMP_BIT - 32), /* 61 -- 8, 42 */
+ BMP_C(0x44c20000) << (BMP_BIT - 32), /* 62 -- 16, 44c2 */
+ BMP_C(0x45270551) << (BMP_BIT - 32), /* 63 -- 32,45270551 */
+ BMP_C(0x48000000) << (BMP_BIT - 32), /* 64 -- 5, 09 */
+ BMP_C(0x49000000) << (BMP_BIT - 32), /* 65 -- 8, 49 */
+ BMP_C(0x4a800000) << (BMP_BIT - 32), /* 66 -- 10, 12a */
+ BMP_C(0x4acc0000) << (BMP_BIT - 32), /* 67 -- 15, 2566 */
+ BMP_C(0x4b000000) << (BMP_BIT - 32), /* 68 -- 8, 4b */
+ BMP_C(0x4b370000) << (BMP_BIT - 32), /* 69 -- 16, 4b37 */
+ BMP_C(0x4c000000) << (BMP_BIT - 32), /* 70 -- 6, 13 */
+ BMP_C(0x4c060000) << (BMP_BIT - 32), /* 71 -- 16, 4c06 */
+ BMP_C(0x53000000) << (BMP_BIT - 32), /* 72 -- 8, 53 */
+ BMP_C(0x55000000) << (BMP_BIT - 32), /* 73 -- 8, 55 */
+ BMP_C(0x55555500) << (BMP_BIT - 32), /* 74 -- 24, 555555 */
+ BMP_C(0x59350000) << (BMP_BIT - 32), /* 75 -- 16, 5935 */
+ BMP_C(0x5d380000) << (BMP_BIT - 32), /* 76 -- 16, 5d38 */
+ BMP_C(0x5d400000) << (BMP_BIT - 32), /* 77 -- 10, 175 */
+ BMP_C(0x5d6dcb00) << (BMP_BIT - 32), /* 78 -- 24, 5d6dcb */
+ BMP_C(0x60000000) << (BMP_BIT - 32), /* 79 -- 3, 3 */
+ BMP_C(0x60e00000) << (BMP_BIT - 32), /* 80 -- 11, 307 */
+ BMP_C(0x63d00000) << (BMP_BIT - 32), /* 81 -- 16, 63d0 */
+ BMP_C(0x64000000) << (BMP_BIT - 32), /* 82 -- 6, 19 */
+ BMP_C(0x66400000) << (BMP_BIT - 32), /* 83 -- 10, 199 */
+ BMP_C(0x66c50000) << (BMP_BIT - 32), /* 84 -- 16, 66c5 */
+ BMP_C(0x6f630000) << (BMP_BIT - 32), /* 85 -- 16, 6f63 */
+ BMP_C(0x6f910000) << (BMP_BIT - 32), /* 86 -- 16, 6f91 */
+ BMP_C(0x70000000) << (BMP_BIT - 32), /* 87 -- 4, 7 */
+ BMP_C(0x70a00000) << (BMP_BIT - 32), /* 88 -- 11, 385 */
+ BMP_C(0x755b0000) << (BMP_BIT - 32), /* 89 -- 16, 755b */
+ BMP_C(0x765e7680) << (BMP_BIT - 32), /* 90 -- 32,765e7680 */
+ BMP_C(0x76c20800) << (BMP_BIT - 32), /* 91 -- 32, 0ed841 */
+ BMP_C(0x7979bd00) << (BMP_BIT - 32), /* 92 -- 24, 7979bd */
+ BMP_C(0x7e000000) << (BMP_BIT - 32), /* 93 -- 8, 7e */
+ BMP_C(0x80000000) << (BMP_BIT - 32), /* 94 -- 3, 4 */
+ BMP_C(0x80006300) << (BMP_BIT - 32), /* 95 -- 24, 800063 */
+ BMP_C(0x80050000) << (BMP_BIT - 32), /* 96 -- 16, 8005 */
+ BMP_C(0x800d0000) << (BMP_BIT - 32), /* 97 -- 16, 800d */
+ BMP_C(0x80b40000) << (BMP_BIT - 32), /* 98 -- 14, 202d */
+ BMP_C(0x80c2e71c) << (BMP_BIT - 32), /* 99 -- 30,2030b9c7 */
+ BMP_C(0x80f00000) << (BMP_BIT - 32), /* 100 -- 12, 80f */
+ BMP_C(0x814141ab) << (BMP_BIT - 32), /* 101 -- 32,814141ab */
+ BMP_C(0x8144c800) << (BMP_BIT - 32), /* 102 -- 21, 102899 */
+ BMP_C(0x864cfb00) << (BMP_BIT - 32), /* 103 -- 24, 864cfb */
+ BMP_C(0x87315576) << (BMP_BIT - 32), /* 104 -- 32,87315576 */
+ BMP_C(0x89ec0000) << (BMP_BIT - 32), /* 105 -- 16, 89ec */
+ BMP_C(0x8a000000) << (BMP_BIT - 32), /* 106 -- 7, 45 */
+ BMP_C(0x8b320000) << (BMP_BIT - 32), /* 107 -- 15, 4599 */
+ BMP_C(0x8bb70000) << (BMP_BIT - 32), /* 108 -- 16, 8bb7 */
+ BMP_C(0x8cc00000) << (BMP_BIT - 32), /* 109 -- 10, 233 */
+ BMP_C(0x904cddbf) << (BMP_BIT - 32), /* 110 -- 32,904cddbf */
+ BMP_C(0x906e0000) << (BMP_BIT - 32), /* 111 -- 16, 906e */
+ BMP_C(0x94000000) << (BMP_BIT - 32), /* 112 -- 8, 94 */
+ BMP_C(0x97000000) << (BMP_BIT - 32), /* 113 -- 8, 97 */
+ BMP_C(0x98000000) << (BMP_BIT - 32), /* 114 -- 6, 26 */
+ BMP_C(0x9b000000) << (BMP_BIT - 32), /* 115 -- 8, 9b */
+ BMP_C(0x9c000000) << (BMP_BIT - 32), /* 116 -- 6, 27 */
+ BMP_C(0x9d5e4de2) << (BMP_BIT - 32), /* 117 -- 31,4eaf26f1 */
+ BMP_C(0x9e000000) << (BMP_BIT - 32), /* 118 -- 7, 4f */
+ BMP_C(0x9ecf0000) << (BMP_BIT - 32), /* 119 -- 16, 9ecf */
+ BMP_C(0xa0970000) << (BMP_BIT - 32), /* 120 -- 16, a097 */
+ BMP_C(0xa1000000) << (BMP_BIT - 32), /* 121 -- 8, a1 */
+ BMP_C(0xa3660000) << (BMP_BIT - 32), /* 122 -- 16, a366 */
+ BMP_C(0xa6000000) << (BMP_BIT - 32), /* 123 -- 7, 53 */
+ BMP_C(0xa7000000) << (BMP_BIT - 32), /* 124 -- 8, a7 */
+ BMP_C(0xa8000000) << (BMP_BIT - 32), /* 125 -- 5, 15 */
+ BMP_C(0xa8190000) << (BMP_BIT - 32), /* 126 -- 16, a819 */
+ BMP_C(0xa833982b) << (BMP_BIT - 32), /* 127 -- 32,a833982b */
+ BMP_C(0xabcdef00) << (BMP_BIT - 32), /* 128 -- 24, abcdef */
+ BMP_C(0xac000000) << (BMP_BIT - 32), /* 129 -- 8, ac */
+ BMP_C(0xaee70000) << (BMP_BIT - 32), /* 130 -- 16, aee7 */
+ BMP_C(0xb0000000) << (BMP_BIT - 32), /* 131 -- 4, b */
+ BMP_C(0xb0010000) << (BMP_BIT - 32), /* 132 -- 16, b001 */
+ BMP_C(0xb2aa0000) << (BMP_BIT - 32), /* 133 -- 16, b2aa */
+ BMP_C(0xb3400000) << (BMP_BIT - 32), /* 134 -- 12, b34 */
+ BMP_C(0xb42d8000) << (BMP_BIT - 32), /* 135 -- 17, 1685b */
+ BMP_C(0xb4600000) << (BMP_BIT - 32), /* 136 -- 11, 5a3 */
+ BMP_C(0xb4c80000) << (BMP_BIT - 32), /* 137 -- 16, b4c8 */
+ BMP_C(0xb4f3e600) << (BMP_BIT - 32), /* 138 -- 24, b4f3e6 */
+ BMP_C(0xb704ce00) << (BMP_BIT - 32), /* 139 -- 24, b704ce */
+ BMP_C(0xb798b438) << (BMP_BIT - 32), /* 140 -- 32,b798b438 */
+ BMP_C(0xbb3d0000) << (BMP_BIT - 32), /* 141 -- 16, bb3d */
+ BMP_C(0xbc000000) << (BMP_BIT - 32), /* 142 -- 6,2f/ 8,bc */
+ BMP_C(0xbd0be338) << (BMP_BIT - 32), /* 143 -- 32,bd0be338 */
+ BMP_C(0xbdf40000) << (BMP_BIT - 32), /* 144 -- 16, bdf4 */
+ BMP_C(0xbf050000) << (BMP_BIT - 32), /* 145 -- 16, bf05 */
+ BMP_C(0xc0000000) << (BMP_BIT - 32), /* 146 -- 3, 6 */
+ BMP_C(0xc2000000) << (BMP_BIT - 32), /* 147 -- 7, 61 */
+ BMP_C(0xc25a5600) << (BMP_BIT - 32), /* 148 -- 24, c25a56 */
+ BMP_C(0xc2b70000) << (BMP_BIT - 32), /* 149 -- 16, c2b7 */
+ BMP_C(0xc2b80000) << (BMP_BIT - 32), /* 150 -- 14, 30ae */
+ BMP_C(0xc4000000) << (BMP_BIT - 32), /* 151 -- 8, c4 */
+ BMP_C(0xc6c60000) << (BMP_BIT - 32), /* 152 -- 16, c6c6 */
+ BMP_C(0xc704dd7b) << (BMP_BIT - 32), /* 153 -- 32,c704dd7b */
+ BMP_C(0xc8000000) << (BMP_BIT - 32), /* 154 -- 5, 19 */
+ BMP_C(0xc8670000) << (BMP_BIT - 32), /* 155 -- 16, c867 */
+ BMP_C(0xcbf43926) << (BMP_BIT - 32), /* 156 -- 32,cbf43926 */
+ BMP_C(0xcde70300) << (BMP_BIT - 32), /* 157 -- 24, cde703 */
+ BMP_C(0xce3c0000) << (BMP_BIT - 32), /* 158 -- 16, ce3c */
+ BMP_C(0xd0000000) << (BMP_BIT - 32), /* 159 -- 8, d0 */
+ BMP_C(0xd02a0000) << (BMP_BIT - 32), /* 160 -- 15, 6815 */
+ BMP_C(0xd0db0000) << (BMP_BIT - 32), /* 161 -- 16, d0db */
+ BMP_C(0xd3100000) << (BMP_BIT - 32), /* 162 -- 12, d31 */
+ BMP_C(0xd3be9568) << (BMP_BIT - 32), /* 163 -- 30,34efa55a */
+ BMP_C(0xd4d00000) << (BMP_BIT - 32), /* 164 -- 12, d4d */
+ BMP_C(0xd5000000) << (BMP_BIT - 32), /* 165 -- 8, d5 */
+ BMP_C(0xd64e0000) << (BMP_BIT - 32), /* 166 -- 16, d64e */
+ BMP_C(0xda000000) << (BMP_BIT - 32), /* 167 -- 8, da */
+ BMP_C(0xdaf00000) << (BMP_BIT - 32), /* 168 -- 12, daf */
+ BMP_C(0xdebb20e3) << (BMP_BIT - 32), /* 169 -- 32,debb20e3 */
+ BMP_C(0xdf000000) << (BMP_BIT - 32), /* 170 -- 8, df */
+ BMP_C(0xe0000000) << (BMP_BIT - 32), /* 171 -- 3, 7 */
+ BMP_C(0xe3069283) << (BMP_BIT - 32), /* 172 -- 32,e3069283 */
+ BMP_C(0xe3940000) << (BMP_BIT - 32), /* 173 -- 16, e394 */
+ BMP_C(0xe5cc0000) << (BMP_BIT - 32), /* 174 -- 16, e5cc */
+ BMP_C(0xe7a80000) << (BMP_BIT - 32), /* 175 -- 13, 1cf5 */
+ BMP_C(0xe8000000) << (BMP_BIT - 32), /* 176 -- 6, 3a */
+ BMP_C(0xea000000) << (BMP_BIT - 32), /* 177 -- 7, 75 */
+ BMP_C(0xea820000) << (BMP_BIT - 32), /* 178 -- 16, ea82 */
+ BMP_C(0xec000000) << (BMP_BIT - 32), /* 179 -- 6, 3b */
+ BMP_C(0xf0000000) << (BMP_BIT - 32), /* 180 -- 4, f */
+ BMP_C(0xf0b80000) << (BMP_BIT - 32), /* 181 -- 16, f0b8 */
+ BMP_C(0xf1300000) << (BMP_BIT - 32), /* 182 -- 12, f13 */
+ BMP_C(0xf4000000) << (BMP_BIT - 32), /* 183 -- 8, f4 */
+ BMP_C(0xf4acfb13) << (BMP_BIT - 32), /* 184 -- 32,f4acfb13 */
+ BMP_C(0xf5b00000) << (BMP_BIT - 32), /* 185 -- 12, f5b */
+ BMP_C(0xf6400000) << (BMP_BIT - 32), /* 186 -- 10, 3d9 */
+ BMP_C(0xf8000000) << (BMP_BIT - 32), /* 187 -- 5, 1f */
+ BMP_C(0xfc000000) << (BMP_BIT - 32), /* 188 -- 6, 3f */
+ BMP_C(0xfc891918) << (BMP_BIT - 32), /* 189 -- 32,fc891918 */
+ BMP_C(0xfd000000) << (BMP_BIT - 32), /* 190 -- 8, fd */
+ BMP_C(0xfe000000) << (BMP_BIT - 32), /* 191 -- 7, 7f */
+ BMP_C(0xfedcba00) << (BMP_BIT - 32), /* 192 -- 24, fedcba */
+ BMP_C(0xfee80000) << (BMP_BIT - 32), /* 193 -- 16, fee8 */
+ BMP_C(0xff000000) << (BMP_BIT - 32), /* 194 -- 8, ff */
+ BMP_C(0xffc00000) << (BMP_BIT - 32), /* 195 -- 10, 3ff */
+ BMP_C(0xfff00000) << (BMP_BIT - 32), /* 196 -- 12, fff */
+ BMP_C(0xfffc0000) << (BMP_BIT - 32), /* 197 -- 14, 3fff */
+ BMP_C(0xffff0000) << (BMP_BIT - 32), /* 198 -- 16, ffff */
+ BMP_C(0xffffff00) << (BMP_BIT - 32), /* 199 -- 24, ffffff */
+ BMP_C(0xfffffffc) << (BMP_BIT - 32), /* 200 -- 30,3fffffff */
+ BMP_C(0xfffffffe) << (BMP_BIT - 32), /* 201 -- 31,7fffffff */
+ BMP_C(0xffffffff) << (BMP_BIT - 32), /* 202 -- 32,ffffffff */
};
static const struct malias aliases[];
@@ -371,237 +467,263 @@ static const struct malias aliases[];
* Sorted by left-justified polynomial for bsearch().
*/
static const struct mpreset models[] = {
- {32UL, b32+ 1, 0, P_BE, 0, b32+113, aliases+123}, /* 0 */
- {40UL, b40, 0, P_BE, b40a, b40b, aliases+ 80}, /* 1 */
- {24UL, b32+ 4, b32+ 60, P_LE, 0, b32+118, aliases+ 54}, /* 2 */
- {32UL, b32+ 9, 0, P_BE, b32+161, b32+ 74, aliases+ 74}, /* 3 */
- {32UL, b32+ 9, b32+161, P_BE, 0, b32+ 8, aliases+ 73}, /* 4 */
- {32UL, b32+ 9, b32+161, P_BE, b32+161, b32+149, aliases+ 68}, /* 5 */
- {32UL, b32+ 9, b32+161, P_LE, 0, b32+ 48, aliases+115}, /* 6 */
- {32UL, b32+ 9, b32+161, P_LE, b32+161, b32+123, aliases+ 64}, /* 7 */
- {16UL, b32+ 10, 0, P_BE, 0, b32+ 6, aliases+ 28}, /* 8 */
- {16UL, b32+ 10, 0, P_BE, b32+ 2, b32+ 5, aliases+ 27}, /* 9 */
- { 8UL, b32+ 11, 0, P_BE, 0, b32+143, aliases+ 94}, /* 10 */
- { 8UL, b32+ 11, 0, P_BE, b32+ 59, b32+ 98, aliases+102}, /* 11 */
- { 8UL, b32+ 11, b32+154, P_LE, 0, b32+125, aliases+106}, /* 12 */
- {31UL, b32+ 12, b32+160, P_BE, b32+160, b32+ 23, aliases+ 63}, /* 13 */
- { 6UL, b32+ 14, 0, P_LE, 0, b32+ 22, aliases+ 87}, /* 14 */
- {82UL, b82, 0, P_LE, 0, b82a, aliases+109}, /* 15 */
- {16UL, b32+ 17, 0, P_BE, 0, b32+ 45, aliases+124}, /* 16 */
- {16UL, b32+ 17, 0, P_LE, 0, b32+ 33, aliases+116}, /* 17 */
- {16UL, b32+ 17, b32+ 26, P_BE, 0, b32+136, aliases+ 18}, /* 18 */
- {16UL, b32+ 17, b32+ 85, P_LE, 0, b32+ 37, aliases+ 49}, /* 19 */
- {16UL, b32+ 17, b32+106, P_LE, 0, b32+ 66, aliases+ 45}, /* 20 */
- {16UL, b32+ 17, b32+120, P_LE, 0, b32+115, aliases+110}, /* 21 */
- {16UL, b32+ 17, b32+157, P_BE, 0, b32+ 40, aliases+ 21}, /* 22 */
- {16UL, b32+ 17, b32+157, P_BE, b32+157, b32+130, aliases+ 32}, /* 23 */
- {16UL, b32+ 17, b32+157, P_LE, 0, b32+ 70, aliases+ 41}, /* 24 */
- {16UL, b32+ 17, b32+157, P_LE, b32+157, b32+ 90, aliases+120}, /* 25 */
- { 7UL, b32+ 18, 0, P_BE, 0, b32+138, aliases+ 91}, /* 26 */
- { 6UL, b32+ 24, b32+148, P_BE, 0, b32+140, aliases+ 85}, /* 27 */
- { 8UL, b32+ 25, b32+150, P_BE, 0, b32+ 76, aliases+101}, /* 28 */
- { 8UL, b32+ 25, b32+154, P_BE, b32+154, b32+ 56, aliases+107}, /* 29 */
- { 8UL, b32+ 25, b32+154, P_LE, 0, b32+ 91, aliases+100}, /* 30 */
- {16UL, b32+ 27, b32+157, P_BE, b32+157, b32+101, aliases+ 44}, /* 31 */
- {32UL, b32+ 28, b32+161, P_LE, b32+161, b32+135, aliases+ 75}, /* 32 */
- {14UL, b32+ 30, 0, P_LE, 0, b32+ 31, aliases+ 12}, /* 33 */
- { 5UL, b32+ 39, b32+147, P_LE, b32+147, b32+121, aliases+ 83}, /* 34 */
- { 8UL, b32+ 41, 0, P_BE, 0, b32+ 52, aliases+105}, /* 35 */
- { 8UL, b32+ 41, b32+154, P_BE, b32+154, b32+133, aliases+ 96}, /* 36 */
- { 4UL, b32+ 42, 0, P_LE, 0, b32+ 71, aliases+ 79}, /* 37 */
- { 4UL, b32+ 42, b32+141, P_BE, b32+141, b32+105, aliases+ 78}, /* 38 */
- { 8UL, b32+ 44, 0, P_LE, 0, b32+ 98, aliases+104}, /* 39 */
- {24UL, b32+ 46, b32+158, P_BE, b32+158, b32+109, aliases+ 57}, /* 40 */
- { 8UL, b32+ 50, 0, P_LE, 0, b32+ 20, aliases+ 98}, /* 41 */
- {16UL, b32+ 51, 0, P_BE, b32+157, b32+119, aliases+ 30}, /* 42 */
- {16UL, b32+ 51, 0, P_LE, b32+157, b32+139, aliases+ 29}, /* 43 */
- {64UL, b64, 0, P_BE, 0, b64a, aliases+ 88}, /* 44 */
- {64UL, b64, b64b, P_BE, b64b, b64c, aliases+ 89}, /* 45 */
- {64UL, b64, b64b, P_LE, b64b, b64d, aliases+ 90}, /* 46 */
- { 5UL, b32+ 54, b32+ 54, P_BE, 0, b32+ 0, aliases+ 81}, /* 47 */
- {16UL, b32+ 61, 0, P_BE, 0, b32+ 62, aliases+ 42}, /* 48 */
- {24UL, b32+ 63, b32+103, P_BE, 0, b32+ 29, aliases+ 56}, /* 49 */
- {24UL, b32+ 63, b32+152, P_BE, 0, b32+ 75, aliases+ 55}, /* 50 */
- { 3UL, b32+ 64, b32+134, P_LE, 0, b32+116, aliases+ 61}, /* 51 */
- {11UL, b32+ 65, 0, P_BE, 0, b32+ 15, aliases+ 6}, /* 52 */
- { 6UL, b32+ 67, 0, P_LE, 0, b32+ 92, aliases+ 86}, /* 53 */
- {16UL, b32+ 69, 0, P_BE, 0, b32+114, aliases+ 38}, /* 54 */
- {11UL, b32+ 72, b32+ 7, P_BE, 0, b32+107, aliases+ 5}, /* 55 */
- {16UL, b32+ 73, 0, P_BE, 0, b32+ 32, aliases+ 43}, /* 56 */
- {24UL, b32+ 77, 0, P_BE, 0, b32+ 35, aliases+ 59}, /* 57 */
- {16UL, b32+ 78, 0, P_BE, 0, b32+153, aliases+ 19}, /* 58 */
- {16UL, b32+ 78, 0, P_LE, 0, b32+111, aliases+ 0}, /* 59 */
- {16UL, b32+ 78, 0, P_LE, b32+157, b32+ 53, aliases+ 40}, /* 60 */
- {16UL, b32+ 78, b32+ 79, P_BE, 0, b32+ 96, aliases+ 26}, /* 61 */
- {16UL, b32+ 78, b32+157, P_BE, 0, b32+104, aliases+ 24}, /* 62 */
- {16UL, b32+ 78, b32+157, P_LE, 0, b32+ 57, aliases+117}, /* 63 */
- {16UL, b32+ 78, b32+157, P_LE, b32+157, b32+108, aliases+ 51}, /* 64 */
- {30UL, b32+ 80, b32+159, P_BE, b32+159, b32+ 19, aliases+ 62}, /* 65 */
- {12UL, b32+ 81, 0, P_BE, 0, b32+145, aliases+ 9}, /* 66 */
- {12UL, b32+ 81, 0, P_BELE, 0, b32+132, aliases+ 10}, /* 67 */
- {32UL, b32+ 82, 0, P_BE, 0, b32+ 43, aliases+ 77}, /* 68 */
- {24UL, b32+ 83, 0, P_BE, 0, b32+124, aliases+ 58}, /* 69 */
- {24UL, b32+ 83, b32+110, P_BE, 0, b32+ 34, aliases+ 53}, /* 70 */
- { 7UL, b32+ 86, 0, P_BE, 0, b32+117, aliases+ 93}, /* 71 */
- {15UL, b32+ 87, 0, P_BE, 0, b32+ 13, aliases+ 13}, /* 72 */
- {16UL, b32+ 88, 0, P_BE, 0, b32+127, aliases+ 47}, /* 73 */
- {10UL, b32+ 89, 0, P_BE, 0, b32+ 68, aliases+ 3}, /* 74 */
- { 8UL, b32+ 93, 0, P_BE, 0, b32+138, aliases+103}, /* 75 */
- { 8UL, b32+ 93, 0, P_LE, 0, b32+ 36, aliases+108}, /* 76 */
- { 8UL, b32+ 93, b32+154, P_BE, 0, b32+131, aliases+ 97}, /* 77 */
- { 6UL, b32+ 94, b32+148, P_BE, 0, b32+ 47, aliases+ 84}, /* 78 */
- { 7UL, b32+ 95, b32+151, P_LE, 0, b32+ 99, aliases+ 92}, /* 79 */
- {16UL, b32+ 97, 0, P_BE, 0, b32+ 16, aliases+ 48}, /* 80 */
- { 5UL, b32+100, 0, P_LE, 0, b32+ 49, aliases+ 82}, /* 81 */
- {32UL, b32+102, b32+161, P_LE, b32+161, b32+ 84, aliases+ 76}, /* 82 */
- {16UL, b32+122, b32+157, P_BE, 0, b32+ 58, aliases+ 23}, /* 83 */
- {15UL, b32+126, 0, P_BE, b32+ 3, b32+ 55, aliases+ 14}, /* 84 */
- { 8UL, b32+129, 0, P_BE, 0, b32+112, aliases+ 99}, /* 85 */
- {13UL, b32+137, 0, P_BE, 0, b32+ 38, aliases+ 11}, /* 86 */
- {12UL, b32+142, b32+156, P_BE, 0, b32+128, aliases+ 8}, /* 87 */
- {32UL, b32+144, b32+161, P_LE, b32+161, b32+ 21, aliases+ 67}, /* 88 */
- {10UL, b32+146, b32+155, P_BE, 0, b32+ 89, aliases+ 4}, /* 89 */
- { 0UL, 0, 0, P_BE, 0, 0, NULL }, /* terminating entry */
+ {64UL, b64, b64a, P_LE, b64a, b64b, b64c, aliases+ 99}, /* 0 */
+ {32UL, b32+ 0, 0, P_BE, 0, b32+143, 0, aliases+137}, /* 1 */
+ {40UL, b40, 0, P_BE, b40a, b40b, b40c, aliases+ 87}, /* 2 */
+ {24UL, b32+ 3, b32+ 74, P_LE, 0, b32+148, 0, aliases+ 60}, /* 3 */
+ {32UL, b32+ 8, 0, P_BE, b32+202, b32+ 90, b32+153, aliases+ 81}, /* 4 */
+ {32UL, b32+ 8, b32+202, P_BE, 0, b32+ 7, 0, aliases+ 80}, /* 5 */
+ {32UL, b32+ 8, b32+202, P_BE, b32+202, b32+189, b32+153, aliases+ 75}, /* 6 */
+ {32UL, b32+ 8, b32+202, P_LE, 0, b32+ 54, 0, aliases+129}, /* 7 */
+ {32UL, b32+ 8, b32+202, P_LE, b32+202, b32+156, b32+169, aliases+ 71}, /* 8 */
+ {16UL, b32+ 9, 0, P_BE, 0, b32+ 5, 0, aliases+ 31}, /* 9 */
+ {16UL, b32+ 9, 0, P_BE, b32+ 1, b32+ 4, b32+ 9, aliases+ 30}, /* 10 */
+ { 8UL, b32+ 10, 0, P_BE, 0, b32+183, 0, aliases+105}, /* 11 */
+ { 8UL, b32+ 10, 0, P_BE, b32+ 73, b32+121, b32+129, aliases+116}, /* 12 */
+ { 8UL, b32+ 10, b32+194, P_LE, 0, b32+159, 0, aliases+120}, /* 13 */
+ {31UL, b32+ 11, b32+201, P_BE, b32+201, b32+ 25, b32+117, aliases+ 70}, /* 14 */
+ { 6UL, b32+ 13, 0, P_LE, 0, b32+ 24, 0, aliases+ 95}, /* 15 */
+ {82UL, b82, 0, P_LE, 0, b82a, 0, aliases+123}, /* 16 */
+ {16UL, b32+ 17, 0, P_BE, 0, b32+ 51, 0, aliases+138}, /* 17 */
+ {16UL, b32+ 17, 0, P_BE, b32+198, b32+158, b32+ 28, aliases+ 36}, /* 18 */
+ {16UL, b32+ 17, 0, P_LE, 0, b32+ 36, 0, aliases+130}, /* 19 */
+ {16UL, b32+ 17, b32+ 28, P_BE, 0, b32+174, 0, aliases+ 21}, /* 20 */
+ {16UL, b32+ 17, b32+105, P_LE, 0, b32+ 41, 0, aliases+ 53}, /* 21 */
+ {16UL, b32+ 17, b32+133, P_LE, 0, b32+ 81, 0, aliases+ 49}, /* 22 */
+ {16UL, b32+ 17, b32+152, P_LE, 0, b32+145, 0, aliases+124}, /* 23 */
+ {16UL, b32+ 17, b32+198, P_BE, 0, b32+ 45, 0, aliases+ 24}, /* 24 */
+ {16UL, b32+ 17, b32+198, P_BE, b32+198, b32+166, b32+ 28, aliases+ 35}, /* 25 */
+ {16UL, b32+ 17, b32+198, P_LE, 0, b32+ 86, 0, aliases+ 45}, /* 26 */
+ {16UL, b32+ 17, b32+198, P_LE, b32+198, b32+111, b32+181, aliases+134}, /* 27 */
+ { 7UL, b32+ 18, 0, P_BE, 0, b32+177, 0, aliases+102}, /* 28 */
+ { 6UL, b32+ 26, b32+188, P_BE, 0, b32+179, 0, aliases+ 92}, /* 29 */
+ { 8UL, b32+ 27, 0, P_BE, 0, b32+ 55, 0, aliases+113}, /* 30 */
+ { 8UL, b32+ 27, b32+190, P_BE, 0, b32+ 93, 0, aliases+115}, /* 31 */
+ { 8UL, b32+ 27, b32+194, P_BE, b32+194, b32+ 68, b32+151, aliases+121}, /* 32 */
+ { 8UL, b32+ 27, b32+194, P_LE, 0, b32+113, 0, aliases+112}, /* 33 */
+ {16UL, b32+ 29, b32+198, P_BE, b32+198, b32+126, b32+173, aliases+ 48}, /* 34 */
+ {32UL, b32+ 30, b32+202, P_LE, b32+202, b32+172, b32+140, aliases+ 82}, /* 35 */
+ {14UL, b32+ 33, 0, P_LE, 0, b32+ 34, 0, aliases+ 14}, /* 36 */
+ { 5UL, b32+ 44, b32+187, P_LE, b32+187, b32+154, b32+ 47, aliases+ 90}, /* 37 */
+ { 8UL, b32+ 46, 0, P_BE, 0, b32+ 59, 0, aliases+119}, /* 38 */
+ { 8UL, b32+ 46, b32+194, P_BE, b32+194, b32+170, b32+ 61, aliases+107}, /* 39 */
+ { 4UL, b32+ 47, 0, P_LE, 0, b32+ 87, 0, aliases+ 86}, /* 40 */
+ { 4UL, b32+ 47, b32+180, P_BE, b32+180, b32+131, b32+ 32, aliases+ 85}, /* 41 */
+ { 8UL, b32+ 49, 0, P_LE, 0, b32+121, 0, aliases+118}, /* 42 */
+ {24UL, b32+ 52, b32+199, P_BE, b32+199, b32+138, b32+ 20, aliases+ 63}, /* 43 */
+ { 8UL, b32+ 57, 0, P_LE, 0, b32+ 21, 0, aliases+110}, /* 44 */
+ {16UL, b32+ 58, 0, P_BE, b32+198, b32+149, b32+122, aliases+ 33}, /* 45 */
+ {16UL, b32+ 58, 0, P_LE, b32+198, b32+178, b32+ 84, aliases+ 32}, /* 46 */
+ {64UL, b64d, 0, P_BE, 0, b64e, 0, aliases+ 96}, /* 47 */
+ {64UL, b64d, b64a, P_BE, b64a, b64f, b64g, aliases+100}, /* 48 */
+ {64UL, b64d, b64a, P_LE, b64a, b64h, b64i, aliases+101}, /* 49 */
+ { 5UL, b32+ 64, b32+ 64, P_BE, 0, 0, 0, aliases+ 88}, /* 50 */
+ { 8UL, b32+ 65, 0, P_BE, b32+194, b32+112, b32+ 72, aliases+114}, /* 51 */
+ {16UL, b32+ 75, 0, P_BE, 0, b32+ 76, 0, aliases+ 46}, /* 52 */
+ {10UL, b32+ 77, 0, P_BE, b32+195, b32+ 66, b32+ 50, aliases+ 5}, /* 53 */
+ {24UL, b32+ 78, b32+128, P_BE, 0, b32+ 31, 0, aliases+ 62}, /* 54 */
+ {24UL, b32+ 78, b32+192, P_BE, 0, b32+ 92, 0, aliases+ 61}, /* 55 */
+ { 3UL, b32+ 79, 0, P_BE, b32+171, b32+ 94, b32+ 60, aliases+ 67}, /* 56 */
+ { 3UL, b32+ 79, b32+171, P_LE, 0, b32+146, 0, aliases+ 68}, /* 57 */
+ {11UL, b32+ 80, 0, P_BE, 0, b32+ 14, 0, aliases+ 7}, /* 58 */
+ { 6UL, b32+ 82, 0, P_LE, 0, b32+114, 0, aliases+ 93}, /* 59 */
+ {16UL, b32+ 85, 0, P_BE, 0, b32+144, 0, aliases+ 42}, /* 60 */
+ {11UL, b32+ 88, b32+ 6, P_BE, 0, b32+136, 0, aliases+ 6}, /* 61 */
+ {16UL, b32+ 89, 0, P_BE, 0, b32+ 35, 0, aliases+ 47}, /* 62 */
+ {24UL, b32+ 95, 0, P_BE, 0, b32+ 38, 0, aliases+ 65}, /* 63 */
+ {16UL, b32+ 96, 0, P_BE, 0, b32+193, 0, aliases+ 22}, /* 64 */
+ {16UL, b32+ 96, 0, P_LE, 0, b32+141, 0, aliases+ 0}, /* 65 */
+ {16UL, b32+ 96, 0, P_LE, b32+198, b32+ 62, b32+132, aliases+ 44}, /* 66 */
+ {16UL, b32+ 96, b32+ 97, P_BE, 0, b32+119, 0, aliases+ 29}, /* 67 */
+ {16UL, b32+ 96, b32+198, P_BE, 0, b32+130, 0, aliases+ 27}, /* 68 */
+ {16UL, b32+ 96, b32+198, P_LE, 0, b32+ 69, 0, aliases+131}, /* 69 */
+ {16UL, b32+ 96, b32+198, P_LE, b32+198, b32+137, b32+132, aliases+ 55}, /* 70 */
+ {14UL, b32+ 98, 0, P_BE, b32+197, b32+150, b32+ 15, aliases+ 15}, /* 71 */
+ {30UL, b32+ 99, b32+200, P_BE, b32+200, b32+ 19, b32+163, aliases+ 69}, /* 72 */
+ {12UL, b32+100, 0, P_BE, 0, b32+185, 0, aliases+ 10}, /* 73 */
+ {12UL, b32+100, 0, P_BELE, 0, b32+168, 0, aliases+ 12}, /* 74 */
+ {32UL, b32+101, 0, P_BE, 0, b32+ 48, 0, aliases+ 84}, /* 75 */
+ {21UL, b32+102, 0, P_BE, 0, b32+ 91, 0, aliases+ 58}, /* 76 */
+ {24UL, b32+103, 0, P_BE, 0, b32+157, 0, aliases+ 64}, /* 77 */
+ {24UL, b32+103, b32+139, P_BE, 0, b32+ 37, 0, aliases+ 59}, /* 78 */
+ { 7UL, b32+106, 0, P_BE, 0, b32+147, 0, aliases+104}, /* 79 */
+ {15UL, b32+107, 0, P_BE, 0, b32+ 12, 0, aliases+ 16}, /* 80 */
+ {16UL, b32+108, 0, P_BE, 0, b32+161, 0, aliases+ 51}, /* 81 */
+ {10UL, b32+109, 0, P_BE, 0, b32+ 83, 0, aliases+ 3}, /* 82 */
+ { 8UL, b32+115, 0, P_BE, 0, b32+177, 0, aliases+117}, /* 83 */
+ { 8UL, b32+115, 0, P_LE, 0, b32+ 39, 0, aliases+122}, /* 84 */
+ { 8UL, b32+115, b32+194, P_BE, 0, b32+167, 0, aliases+109}, /* 85 */
+ { 6UL, b32+116, b32+188, P_BE, 0, b32+ 53, 0, aliases+ 91}, /* 86 */
+ { 7UL, b32+118, b32+191, P_LE, 0, b32+123, 0, aliases+103}, /* 87 */
+ {16UL, b32+120, 0, P_BE, 0, b32+ 16, 0, aliases+ 52}, /* 88 */
+ { 8UL, b32+124, 0, P_LE, 0, b32+ 40, 0, aliases+108}, /* 89 */
+ { 5UL, b32+125, 0, P_LE, 0, b32+ 56, 0, aliases+ 89}, /* 90 */
+ {32UL, b32+127, b32+202, P_LE, b32+202, b32+104, b32+ 63, aliases+ 83}, /* 91 */
+ {17UL, b32+135, 0, P_BE, 0, b32+ 42, 0, aliases+ 57}, /* 92 */
+ { 6UL, b32+142, 0, P_BE, b32+188, b32+ 70, b32+176, aliases+ 94}, /* 93 */
+ {16UL, b32+155, b32+198, P_BE, 0, b32+ 71, 0, aliases+ 26}, /* 94 */
+ {15UL, b32+160, 0, P_BE, b32+ 2, b32+ 67, b32+160, aliases+ 17}, /* 95 */
+ {12UL, b32+162, 0, P_BE, b32+196, b32+134, b32+ 23, aliases+ 11}, /* 96 */
+ { 8UL, b32+165, 0, P_BE, 0, b32+142, 0, aliases+111}, /* 97 */
+ {13UL, b32+175, 0, P_BE, 0, b32+ 43, 0, aliases+ 13}, /* 98 */
+ {12UL, b32+182, b32+196, P_BE, 0, b32+164, 0, aliases+ 9}, /* 99 */
+ {32UL, b32+184, b32+202, P_LE, b32+202, b32+ 22, b32+110, aliases+ 74}, /* 100 */
+ {10UL, b32+186, b32+195, P_BE, 0, b32+109, 0, aliases+ 4}, /* 101 */
+ { 0UL, 0, 0, P_BE, 0, 0, 0, NULL }, /* terminating entry */
};
-# define NPRESETS 90
+# define NPRESETS 102
/* List of names with pointers to models, pre-sorted for use with bsearch() */
static const struct malias aliases[] = {
- {"ARC", models+59}, /* 0 */
- {"B-CRC-32", models+ 5}, /* 1 */
- {"CKSUM", models+ 3}, /* 2 */
- {"CRC-10", models+74}, /* 3 */
- {"CRC-10/CDMA2000", models+89}, /* 4 */
- {"CRC-11", models+55}, /* 5 */
- {"CRC-11/UMTS", models+52}, /* 6 */
- {"CRC-12/3GPP", models+67}, /* 7 */
- {"CRC-12/CDMA2000", models+87}, /* 8 */
- {"CRC-12/DECT", models+66}, /* 9 */
- {"CRC-12/UMTS", models+67}, /* 10 */
- {"CRC-13/BBC", models+86}, /* 11 */
- {"CRC-14/DARC", models+33}, /* 12 */
- {"CRC-15", models+72}, /* 13 */
- {"CRC-15/MPT1327", models+84}, /* 14 */
- {"CRC-16", models+59}, /* 15 */
- {"CRC-16/ACORN", models+16}, /* 16 */
- {"CRC-16/ARC", models+59}, /* 17 */
- {"CRC-16/AUG-CCITT", models+18}, /* 18 */
- {"CRC-16/BUYPASS", models+58}, /* 19 */
- {"CRC-16/CCITT", models+17}, /* 20 */
- {"CRC-16/CCITT-FALSE", models+22}, /* 21 */
- {"CRC-16/CCITT-TRUE", models+17}, /* 22 */
- {"CRC-16/CDMA2000", models+83}, /* 23 */
- {"CRC-16/CMS", models+62}, /* 24 */
- {"CRC-16/DARC", models+23}, /* 25 */
- {"CRC-16/DDS-110", models+61}, /* 26 */
- {"CRC-16/DECT-R", models+ 9}, /* 27 */
- {"CRC-16/DECT-X", models+ 8}, /* 28 */
- {"CRC-16/DNP", models+43}, /* 29 */
- {"CRC-16/EN-13757", models+42}, /* 30 */
- {"CRC-16/EPC", models+23}, /* 31 */
- {"CRC-16/GENIBUS", models+23}, /* 32 */
- {"CRC-16/I-CODE", models+23}, /* 33 */
- {"CRC-16/IBM-SDLC", models+25}, /* 34 */
- {"CRC-16/IEC-61158-2", models+31}, /* 35 */
- {"CRC-16/ISO-HDLC", models+25}, /* 36 */
- {"CRC-16/LHA", models+59}, /* 37 */
- {"CRC-16/LJ1200", models+54}, /* 38 */
- {"CRC-16/LTE", models+16}, /* 39 */
- {"CRC-16/MAXIM", models+60}, /* 40 */
- {"CRC-16/MCRF4XX", models+24}, /* 41 */
- {"CRC-16/OPENSAFETY-A", models+48}, /* 42 */
- {"CRC-16/OPENSAFETY-B", models+56}, /* 43 */
- {"CRC-16/PROFIBUS", models+31}, /* 44 */
- {"CRC-16/RIELLO", models+20}, /* 45 */
- {"CRC-16/SPI-FUJITSU", models+18}, /* 46 */
- {"CRC-16/T10-DIF", models+73}, /* 47 */
- {"CRC-16/TELEDISK", models+80}, /* 48 */
- {"CRC-16/TMS37157", models+19}, /* 49 */
- {"CRC-16/UMTS", models+58}, /* 50 */
- {"CRC-16/USB", models+64}, /* 51 */
- {"CRC-16/VERIFONE", models+58}, /* 52 */
- {"CRC-24", models+70}, /* 53 */
- {"CRC-24/BLE", models+ 2}, /* 54 */
- {"CRC-24/FLEXRAY-A", models+50}, /* 55 */
- {"CRC-24/FLEXRAY-B", models+49}, /* 56 */
- {"CRC-24/INTERLAKEN", models+40}, /* 57 */
- {"CRC-24/LTE-A", models+69}, /* 58 */
- {"CRC-24/LTE-B", models+57}, /* 59 */
- {"CRC-24/OPENPGP", models+70}, /* 60 */
- {"CRC-3/ROHC", models+51}, /* 61 */
- {"CRC-30/CDMA", models+65}, /* 62 */
- {"CRC-31/PHILIPS", models+13}, /* 63 */
- {"CRC-32", models+ 7}, /* 64 */
- {"CRC-32/AAL5", models+ 5}, /* 65 */
- {"CRC-32/ADCCP", models+ 7}, /* 66 */
- {"CRC-32/AUTOSAR", models+88}, /* 67 */
- {"CRC-32/BZIP2", models+ 5}, /* 68 */
- {"CRC-32/CASTAGNOLI", models+32}, /* 69 */
- {"CRC-32/DECT-B", models+ 5}, /* 70 */
- {"CRC-32/INTERLAKEN", models+32}, /* 71 */
- {"CRC-32/ISCSI", models+32}, /* 72 */
- {"CRC-32/MPEG-2", models+ 4}, /* 73 */
- {"CRC-32/POSIX", models+ 3}, /* 74 */
- {"CRC-32C", models+32}, /* 75 */
- {"CRC-32D", models+82}, /* 76 */
- {"CRC-32Q", models+68}, /* 77 */
- {"CRC-4/INTERLAKEN", models+38}, /* 78 */
- {"CRC-4/ITU", models+37}, /* 79 */
- {"CRC-40/GSM", models+ 1}, /* 80 */
- {"CRC-5/EPC", models+47}, /* 81 */
- {"CRC-5/ITU", models+81}, /* 82 */
- {"CRC-5/USB", models+34}, /* 83 */
- {"CRC-6/CDMA2000-A", models+78}, /* 84 */
- {"CRC-6/CDMA2000-B", models+27}, /* 85 */
- {"CRC-6/DARC", models+53}, /* 86 */
- {"CRC-6/ITU", models+14}, /* 87 */
- {"CRC-64", models+44}, /* 88 */
- {"CRC-64/WE", models+45}, /* 89 */
- {"CRC-64/XZ", models+46}, /* 90 */
- {"CRC-7", models+26}, /* 91 */
- {"CRC-7/ROHC", models+79}, /* 92 */
- {"CRC-7/UMTS", models+71}, /* 93 */
- {"CRC-8", models+10}, /* 94 */
- {"CRC-8/AES", models+30}, /* 95 */
- {"CRC-8/AUTOSAR", models+36}, /* 96 */
- {"CRC-8/CDMA2000", models+77}, /* 97 */
- {"CRC-8/DARC", models+41}, /* 98 */
- {"CRC-8/DVB-S2", models+85}, /* 99 */
- {"CRC-8/EBU", models+30}, /* 100 */
- {"CRC-8/I-CODE", models+28}, /* 101 */
- {"CRC-8/ITU", models+11}, /* 102 */
- {"CRC-8/LTE", models+75}, /* 103 */
- {"CRC-8/MAXIM", models+39}, /* 104 */
- {"CRC-8/OPENSAFETY", models+35}, /* 105 */
- {"CRC-8/ROHC", models+12}, /* 106 */
- {"CRC-8/SAE-J1850", models+29}, /* 107 */
- {"CRC-8/WCDMA", models+76}, /* 108 */
- {"CRC-82/DARC", models+15}, /* 109 */
- {"CRC-A", models+21}, /* 110 */
- {"CRC-B", models+25}, /* 111 */
- {"CRC-CCITT", models+17}, /* 112 */
- {"CRC-IBM", models+59}, /* 113 */
- {"DOW-CRC", models+39}, /* 114 */
- {"JAMCRC", models+ 6}, /* 115 */
- {"KERMIT", models+17}, /* 116 */
- {"MODBUS", models+63}, /* 117 */
- {"PKZIP", models+ 7}, /* 118 */
- {"R-CRC-16", models+ 9}, /* 119 */
- {"X-25", models+25}, /* 120 */
- {"X-CRC-12", models+66}, /* 121 */
- {"X-CRC-16", models+ 8}, /* 122 */
- {"XFER", models+ 0}, /* 123 */
- {"XMODEM", models+16}, /* 124 */
- {"ZMODEM", models+16}, /* 125 */
+ {"ARC", models+ 65}, /* 0 */
+ {"B-CRC-32", models+ 6}, /* 1 */
+ {"CKSUM", models+ 4}, /* 2 */
+ {"CRC-10", models+ 82}, /* 3 */
+ {"CRC-10/CDMA2000", models+101}, /* 4 */
+ {"CRC-10/GSM", models+ 53}, /* 5 */
+ {"CRC-11", models+ 61}, /* 6 */
+ {"CRC-11/UMTS", models+ 58}, /* 7 */
+ {"CRC-12/3GPP", models+ 74}, /* 8 */
+ {"CRC-12/CDMA2000", models+ 99}, /* 9 */
+ {"CRC-12/DECT", models+ 73}, /* 10 */
+ {"CRC-12/GSM", models+ 96}, /* 11 */
+ {"CRC-12/UMTS", models+ 74}, /* 12 */
+ {"CRC-13/BBC", models+ 98}, /* 13 */
+ {"CRC-14/DARC", models+ 36}, /* 14 */
+ {"CRC-14/GSM", models+ 71}, /* 15 */
+ {"CRC-15", models+ 80}, /* 16 */
+ {"CRC-15/MPT1327", models+ 95}, /* 17 */
+ {"CRC-16", models+ 65}, /* 18 */
+ {"CRC-16/ACORN", models+ 17}, /* 19 */
+ {"CRC-16/ARC", models+ 65}, /* 20 */
+ {"CRC-16/AUG-CCITT", models+ 20}, /* 21 */
+ {"CRC-16/BUYPASS", models+ 64}, /* 22 */
+ {"CRC-16/CCITT", models+ 19}, /* 23 */
+ {"CRC-16/CCITT-FALSE", models+ 24}, /* 24 */
+ {"CRC-16/CCITT-TRUE", models+ 19}, /* 25 */
+ {"CRC-16/CDMA2000", models+ 94}, /* 26 */
+ {"CRC-16/CMS", models+ 68}, /* 27 */
+ {"CRC-16/DARC", models+ 25}, /* 28 */
+ {"CRC-16/DDS-110", models+ 67}, /* 29 */
+ {"CRC-16/DECT-R", models+ 10}, /* 30 */
+ {"CRC-16/DECT-X", models+ 9}, /* 31 */
+ {"CRC-16/DNP", models+ 46}, /* 32 */
+ {"CRC-16/EN-13757", models+ 45}, /* 33 */
+ {"CRC-16/EPC", models+ 25}, /* 34 */
+ {"CRC-16/GENIBUS", models+ 25}, /* 35 */
+ {"CRC-16/GSM", models+ 18}, /* 36 */
+ {"CRC-16/I-CODE", models+ 25}, /* 37 */
+ {"CRC-16/IBM-SDLC", models+ 27}, /* 38 */
+ {"CRC-16/IEC-61158-2", models+ 34}, /* 39 */
+ {"CRC-16/ISO-HDLC", models+ 27}, /* 40 */
+ {"CRC-16/LHA", models+ 65}, /* 41 */
+ {"CRC-16/LJ1200", models+ 60}, /* 42 */
+ {"CRC-16/LTE", models+ 17}, /* 43 */
+ {"CRC-16/MAXIM", models+ 66}, /* 44 */
+ {"CRC-16/MCRF4XX", models+ 26}, /* 45 */
+ {"CRC-16/OPENSAFETY-A", models+ 52}, /* 46 */
+ {"CRC-16/OPENSAFETY-B", models+ 62}, /* 47 */
+ {"CRC-16/PROFIBUS", models+ 34}, /* 48 */
+ {"CRC-16/RIELLO", models+ 22}, /* 49 */
+ {"CRC-16/SPI-FUJITSU", models+ 20}, /* 50 */
+ {"CRC-16/T10-DIF", models+ 81}, /* 51 */
+ {"CRC-16/TELEDISK", models+ 88}, /* 52 */
+ {"CRC-16/TMS37157", models+ 21}, /* 53 */
+ {"CRC-16/UMTS", models+ 64}, /* 54 */
+ {"CRC-16/USB", models+ 70}, /* 55 */
+ {"CRC-16/VERIFONE", models+ 64}, /* 56 */
+ {"CRC-17/CAN-FD", models+ 92}, /* 57 */
+ {"CRC-21/CAN-FD", models+ 76}, /* 58 */
+ {"CRC-24", models+ 78}, /* 59 */
+ {"CRC-24/BLE", models+ 3}, /* 60 */
+ {"CRC-24/FLEXRAY-A", models+ 55}, /* 61 */
+ {"CRC-24/FLEXRAY-B", models+ 54}, /* 62 */
+ {"CRC-24/INTERLAKEN", models+ 43}, /* 63 */
+ {"CRC-24/LTE-A", models+ 77}, /* 64 */
+ {"CRC-24/LTE-B", models+ 63}, /* 65 */
+ {"CRC-24/OPENPGP", models+ 78}, /* 66 */
+ {"CRC-3/GSM", models+ 56}, /* 67 */
+ {"CRC-3/ROHC", models+ 57}, /* 68 */
+ {"CRC-30/CDMA", models+ 72}, /* 69 */
+ {"CRC-31/PHILIPS", models+ 14}, /* 70 */
+ {"CRC-32", models+ 8}, /* 71 */
+ {"CRC-32/AAL5", models+ 6}, /* 72 */
+ {"CRC-32/ADCCP", models+ 8}, /* 73 */
+ {"CRC-32/AUTOSAR", models+100}, /* 74 */
+ {"CRC-32/BZIP2", models+ 6}, /* 75 */
+ {"CRC-32/CASTAGNOLI", models+ 35}, /* 76 */
+ {"CRC-32/DECT-B", models+ 6}, /* 77 */
+ {"CRC-32/INTERLAKEN", models+ 35}, /* 78 */
+ {"CRC-32/ISCSI", models+ 35}, /* 79 */
+ {"CRC-32/MPEG-2", models+ 5}, /* 80 */
+ {"CRC-32/POSIX", models+ 4}, /* 81 */
+ {"CRC-32C", models+ 35}, /* 82 */
+ {"CRC-32D", models+ 91}, /* 83 */
+ {"CRC-32Q", models+ 75}, /* 84 */
+ {"CRC-4/INTERLAKEN", models+ 41}, /* 85 */
+ {"CRC-4/ITU", models+ 40}, /* 86 */
+ {"CRC-40/GSM", models+ 2}, /* 87 */
+ {"CRC-5/EPC", models+ 50}, /* 88 */
+ {"CRC-5/ITU", models+ 90}, /* 89 */
+ {"CRC-5/USB", models+ 37}, /* 90 */
+ {"CRC-6/CDMA2000-A", models+ 86}, /* 91 */
+ {"CRC-6/CDMA2000-B", models+ 29}, /* 92 */
+ {"CRC-6/DARC", models+ 59}, /* 93 */
+ {"CRC-6/GSM", models+ 93}, /* 94 */
+ {"CRC-6/ITU", models+ 15}, /* 95 */
+ {"CRC-64", models+ 47}, /* 96 */
+ {"CRC-64/ECMA-182", models+ 47}, /* 97 */
+ {"CRC-64/GO-ECMA", models+ 49}, /* 98 */
+ {"CRC-64/GO-ISO", models+ 0}, /* 99 */
+ {"CRC-64/WE", models+ 48}, /* 100 */
+ {"CRC-64/XZ", models+ 49}, /* 101 */
+ {"CRC-7", models+ 28}, /* 102 */
+ {"CRC-7/ROHC", models+ 87}, /* 103 */
+ {"CRC-7/UMTS", models+ 79}, /* 104 */
+ {"CRC-8", models+ 11}, /* 105 */
+ {"CRC-8/AES", models+ 33}, /* 106 */
+ {"CRC-8/AUTOSAR", models+ 39}, /* 107 */
+ {"CRC-8/BLUETOOTH", models+ 89}, /* 108 */
+ {"CRC-8/CDMA2000", models+ 85}, /* 109 */
+ {"CRC-8/DARC", models+ 44}, /* 110 */
+ {"CRC-8/DVB-S2", models+ 97}, /* 111 */
+ {"CRC-8/EBU", models+ 33}, /* 112 */
+ {"CRC-8/GSM-A", models+ 30}, /* 113 */
+ {"CRC-8/GSM-B", models+ 51}, /* 114 */
+ {"CRC-8/I-CODE", models+ 31}, /* 115 */
+ {"CRC-8/ITU", models+ 12}, /* 116 */
+ {"CRC-8/LTE", models+ 83}, /* 117 */
+ {"CRC-8/MAXIM", models+ 42}, /* 118 */
+ {"CRC-8/OPENSAFETY", models+ 38}, /* 119 */
+ {"CRC-8/ROHC", models+ 13}, /* 120 */
+ {"CRC-8/SAE-J1850", models+ 32}, /* 121 */
+ {"CRC-8/WCDMA", models+ 84}, /* 122 */
+ {"CRC-82/DARC", models+ 16}, /* 123 */
+ {"CRC-A", models+ 23}, /* 124 */
+ {"CRC-B", models+ 27}, /* 125 */
+ {"CRC-CCITT", models+ 19}, /* 126 */
+ {"CRC-IBM", models+ 65}, /* 127 */
+ {"DOW-CRC", models+ 42}, /* 128 */
+ {"JAMCRC", models+ 7}, /* 129 */
+ {"KERMIT", models+ 19}, /* 130 */
+ {"MODBUS", models+ 69}, /* 131 */
+ {"PKZIP", models+ 8}, /* 132 */
+ {"R-CRC-16", models+ 10}, /* 133 */
+ {"X-25", models+ 27}, /* 134 */
+ {"X-CRC-12", models+ 73}, /* 135 */
+ {"X-CRC-16", models+ 9}, /* 136 */
+ {"XFER", models+ 1}, /* 137 */
+ {"XMODEM", models+ 17}, /* 138 */
+ {"ZMODEM", models+ 17}, /* 139 */
{NULL, NULL }, /* terminating entry */
};
-# define NALIASES 126
+# define NALIASES 140
# endif /* BMP_BIT */
#else /* PRESETS */
static const struct mpreset models[] = {
- { 0UL, 0, 0, P_BE, 0, 0, NULL }, /* terminating entry */
+ { 0UL, 0, 0, P_BE, 0, 0, 0, NULL }, /* terminating entry */
};
# define NPRESETS 0
@@ -615,10 +737,14 @@ static const struct malias aliases[] = {
static void munpack(model_t *, const struct mpreset *);
/* copy a parameter of a preset to a poly */
+
#define PUNPACK(poly, preset, field) {\
unsigned long iter, idx; \
- praloc((poly), ((preset)->field ? (preset)->width : 0UL)); \
- for(iter=0UL, idx=0UL; iter < (poly)->length; iter += BMP_BIT, ++idx) \
+ palloc((poly), (preset)->width); \
+ if((preset)->field) \
+ for(iter=0UL, idx=0UL; \
+ iter < (poly)->length; \
+ iter += BMP_BIT, ++idx) \
(poly)->bitmap[idx] = (preset)->field[idx]; \
}
@@ -627,8 +753,7 @@ static void munpack(model_t *, const struct mpreset *);
/* Definitions */
-int
-mbynam(model_t *dest, const char *key) {
+int mbynam(model_t *dest, const char *key) {
/* Sets parameters in dest according to the model named by key.
*/
size_t left = 0, right = NALIASES, middle = 0;
@@ -639,7 +764,7 @@ mbynam(model_t *dest, const char *key) {
return(-1);
if(!(ukey = malloc((size_t) 1 + strlen(key)))) {
uerror("cannot allocate memory for comparison string");
- return(0);
+ return(0);
}
uptr = ukey;
do
@@ -660,22 +785,19 @@ mbynam(model_t *dest, const char *key) {
return(1);
}
-void
-mbynum(model_t *dest, int num) {
+void mbynum(model_t *dest, int num) {
/* Sets parameters in dest according to the model indexed by num. */
if(num > NPRESETS)
num = NPRESETS;
munpack(dest, num+models);
}
-int
-mcount(void) {
+int mcount(void) {
/* Returns the number of preset models. */
return(NPRESETS);
}
-char *
-mnames(void) {
+char * mnames(void) {
/* Returns a malloc()-ed string of the names of all preset
* models, separated by newlines and terminated by NULL.
* Aliases are not listed.
@@ -708,8 +830,7 @@ mnames(void) {
return(string);
}
-void
-mmatch(model_t *model, int flags) {
+void mmatch(model_t *model, int flags) {
/* searches models[] for a model matching the argument, and links a name if found
* if flags & M_OVERWR, copies the found model onto the argument. */
size_t left = 0, right = NPRESETS, middle = 0;
@@ -753,8 +874,7 @@ mmatch(model_t *model, int flags) {
/* Private functions */
-static void
-munpack(model_t *dest, const struct mpreset *src) {
+static void munpack(model_t *dest, const struct mpreset *src) {
/* Copies the parameters of src to dest.
* dest must be an initialised model.
*/
@@ -763,7 +883,8 @@ munpack(model_t *dest, const struct mpreset *src) {
MUNPACK(init);
MUNPACK(xorout);
MUNPACK(check);
+ MUNPACK(magic);
dest->flags = src->flags;
/* link to the name as it is static */
- dest->name = src->alias->name;
+ dest->name = (src->alias) ? src->alias->name : NULL;
}
diff --git a/client/reveng/reveng.c b/client/reveng/reveng.c
index 8a669e905..7d0eba82b 100644
--- a/client/reveng/reveng.c
+++ b/client/reveng/reveng.c
@@ -1,9 +1,10 @@
/* reveng.c
- * Greg Cook, 27/Jun/2016
+ * Greg Cook, 7/Feb/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -151,6 +152,7 @@ requit:
rptr->flags = 0;
rptr->xorout = pzero;
rptr->check = pzero;
+ rptr->magic = pzero;
rptr->name = NULL;
return(result);
@@ -446,7 +448,7 @@ static void
chkres(int *resc, model_t **result, const poly_t divisor, const poly_t init, int flags, const poly_t xorout, int args, const poly_t *argpolys) {
/* Checks a model against the argument list, and adds to the
* external results table if consistent.
- * Extends the result array and update the external pointer if
+ * Extends the result array and updates the external pointer if
* necessary.
*/
model_t *rptr;
@@ -484,6 +486,8 @@ chkres(int *resc, model_t **result, const poly_t divisor, const poly_t init, int
rptr->init = pclone(init);
rptr->flags = flags;
rptr->xorout = pclone(xorout);
+ rptr->check = pzero;
+ rptr->magic = pzero;
rptr->name = NULL;
/* compute check value for this model */
diff --git a/client/reveng/reveng.h b/client/reveng/reveng.h
index 7c2f0b3b0..40750ca53 100644
--- a/client/reveng/reveng.h
+++ b/client/reveng/reveng.h
@@ -1,9 +1,10 @@
/* reveng.h
- * Greg Cook, 25/Jul/2016
+ * Greg Cook, 19/Jun/2017
*/
/* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
+ * Gregory Cook
*
* This file is part of CRC RevEng.
*
@@ -92,7 +93,7 @@
/* Global definitions */
/* CRC RevEng version string */
-#define VERSION "1.4.4"
+#define VERSION "1.5.2"
/* bmpbit.c */
typedef BMP_T bmp_t;
@@ -162,12 +163,17 @@ extern int pmpar(const poly_t poly, const poly_t mask);
extern int pident(const poly_t a, const poly_t b);
/* model.c */
+
+/* A model_t constant representing an uninitialised model or zero-bit CRC algorithm. */
+#define MZERO {PZERO, PZERO, P_BE, PZERO, PZERO, PZERO, NULL}
+
typedef struct {
poly_t spoly; /* polynomial with highest-order term removed. length determines CRC width */
- poly_t init; /* initial register value. length == poly.length */
+ poly_t init; /* initial register value. length == spoly.length */
int flags; /* P_REFIN and P_REFOUT indicate reflected input/output */
- poly_t xorout; /* final register XOR mask. length == poly.length */
+ poly_t xorout; /* final register XOR mask. length == spoly.length */
poly_t check; /* optional check value, the CRC of the UTF-8 string "123456789" */
+ poly_t magic; /* optional magic check value, the residue of a valid codeword */
const char *name; /* optional canonical name of the model */
} model_t;
@@ -203,8 +209,9 @@ extern model_t *reveng(const model_t *guess, const poly_t qpoly, int rflags, int
/* cli.c */
#define C_INFILE 1
-#define C_FORCE 2
-#define C_RESULT 4
+#define C_NOPCK 2
+#define C_NOBFS 4
+#define C_RESULT 8
#define BUFFER 32768