usr/gzip/util.c

/* util.c -- utility functions for gzip support
 * Copyright (C) 1992-1993 Jean-loup Gailly
 * This is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License, see the file COPYING.
 */

#ifdef RCSID
static char rcsid[] = "$Id: util.c,v 1.1 2002/08/18 00:59:21 hpa Exp $";
#endif

#include <ctype.h>
#include <errno.h>
#include <sys/types.h>

#include "tailor.h"

#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>

#include "gzip.h"

extern ulg crc_32_tab[];   /* crc table, defined below */

/* ===========================================================================
 * Copy input to output unchanged: zcat == cat with --force.
 * IN assertion: insize bytes have already been read in inbuf.
 */
int copy(in, out)
    int in, out;   /* input and output file descriptors */
{
    errno = 0;
    while (insize != 0 && (int)insize != EOF) {
	write_buf(out, (char*)inbuf, insize);
	bytes_out += insize;
	insize = read(in, (char*)inbuf, INBUFSIZ);
    }
    if ((int)insize == EOF && errno != 0) {
	read_error();
    }
    bytes_in = bytes_out;
    return OK;
}

/* ===========================================================================
 * Run a set of bytes through the crc shift register.  If s is a NULL
 * pointer, then initialize the crc shift register contents instead.
 * Return the current crc in either case.
 */
ulg updcrc(s, n)
    uch *s;                 /* pointer to bytes to pump through */
    unsigned n;             /* number of bytes in s[] */
{
    register ulg c;         /* temporary variable */

    static ulg crc = (ulg)0xffffffffL; /* shift register contents */

    if (s == NULL) {
	c = 0xffffffffL;
    } else {
	c = crc;
        if (n) do {
            c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);
        } while (--n);
    }
    crc = c;
    return c ^ 0xffffffffL;       /* (instead of ~c for 64-bit machines) */
}

/* ===========================================================================
 * Clear input and output buffers
 */
void clear_bufs()
{
    outcnt = 0;
    insize = inptr = 0;
    bytes_in = bytes_out = 0L;
}

/* ===========================================================================
 * Fill the input buffer. This is called only when the buffer is empty.
 */
int fill_inbuf(eof_ok)
    int eof_ok;          /* set if EOF acceptable as a result */
{
    int len;

    /* Read as much as possible */
    insize = 0;
    errno = 0;
    do {
	len = read(ifd, (char*)inbuf+insize, INBUFSIZ-insize);
        if (len == 0 || len == EOF) break;
	insize += len;
    } while (insize < INBUFSIZ);

    if (insize == 0) {
	if (eof_ok) return EOF;
	read_error();
    }
    bytes_in += (ulg)insize;
    inptr = 1;
    return inbuf[0];
}

/* ===========================================================================
 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
 * (used for the compressed data only)
 */
void flush_outbuf()
{
    if (outcnt == 0) return;

    write_buf(ofd, (char *)outbuf, outcnt);
    bytes_out += (ulg)outcnt;
    outcnt = 0;
}

/* ===========================================================================
 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 * (Used for the decompressed data only.)
 */
void flush_window()
{
    if (outcnt == 0) return;
    updcrc(window, outcnt);

    if (!test) {
	write_buf(ofd, (char *)window, outcnt);
    }
    bytes_out += (ulg)outcnt;
    outcnt = 0;
}

/* ===========================================================================
 * Does the same as write(), but also handles partial pipe writes and checks
 * for error return.
 */
void write_buf(fd, buf, cnt)
    int       fd;
    voidp     buf;
    unsigned  cnt;
{
    unsigned  n;

    while ((n = write(fd, buf, cnt)) != cnt) {
	if (n == (unsigned)(-1)) {
	    write_error();
	}
	cnt -= n;
	buf = (voidp)((char*)buf+n);
    }
}

/* ========================================================================
 * Put string s in lower case, return s.
 */
char *strlwr(s)
    char *s;
{
    char *t;
    for (t = s; *t; t++) *t = tolow(*t);
    return s;
}

/* ========================================================================
 * Return the base name of a file (remove any directory prefix and
 * any version suffix). For systems with file names that are not
 * case sensitive, force the base name to lower case.
 */
char *basename(fname)
    char *fname;
{
    char *p;

    if ((p = strrchr(fname, PATH_SEP))  != NULL) fname = p+1;
    if (casemap('A') == 'a') strlwr(fname);
    return fname;
}

/* ========================================================================
 * Add an environment variable (if any) before argv, and update argc.
 * Return the expanded environment variable to be freed later, or NULL
 * if no options were added to argv.
 */
#define SEPARATOR	" \t"	/* separators in env variable */

char *add_envopt(argcp, argvp, env)
    int *argcp;          /* pointer to argc */
    char ***argvp;       /* pointer to argv */
    char *env;           /* name of environment variable */
{
    char *p;             /* running pointer through env variable */
    char **oargv;        /* runs through old argv array */
    char **nargv;        /* runs through new argv array */
    int	 oargc = *argcp; /* old argc */
    int  nargc = 0;      /* number of arguments in env variable */

    env = (char*)getenv(env);
    if (env == NULL) return NULL;

    p = (char*)xmalloc(strlen(env)+1);
    env = strcpy(p, env);                    /* keep env variable intact */

    for (p = env; *p; nargc++ ) {            /* move through env */
	p += strspn(p, SEPARATOR);	     /* skip leading separators */
	if (*p == '\0') break;

	p += strcspn(p, SEPARATOR);	     /* find end of word */
	if (*p) *p++ = '\0';		     /* mark it */
    }
    if (nargc == 0) {
	free(env);
	return NULL;
    }
    *argcp += nargc;
    /* Allocate the new argv array, with an extra element just in case
     * the original arg list did not end with a NULL.
     */
    nargv = (char**)calloc(*argcp+1, sizeof(char *));
    if (nargv == NULL) error("out of memory");
    oargv  = *argvp;
    *argvp = nargv;

    /* Copy the program name first */
    if (oargc-- < 0) error("argc<=0");
    *(nargv++) = *(oargv++);

    /* Then copy the environment args */
    for (p = env; nargc > 0; nargc--) {
	p += strspn(p, SEPARATOR);	     /* skip separators */
	*(nargv++) = p;			     /* store start */
	while (*p++) ;			     /* skip over word */
    }

    /* Finally copy the old args and add a NULL (usual convention) */
    while (oargc--) *(nargv++) = *(oargv++);
    *nargv = NULL;
    return env;
}

/* ========================================================================
 * Error handlers.
 */
void error(m)
    char *m;
{
    fprintf(stderr, "\n%s: %s: %s\n", progname, ifname, m);
    abort_gzip();
}

void warn(a, b)
    char *a, *b;            /* message strings juxtaposed in output */
{
    WARN((stderr, "%s: %s: warning: %s%s\n", progname, ifname, a, b));
}

void read_error()
{
    fprintf(stderr, "\n%s: ", progname);
    if (errno != 0) {
	perror(ifname);
    } else {
	fprintf(stderr, "%s: unexpected end of file\n", ifname);
    }
    abort_gzip();
}

void write_error()
{
    fprintf(stderr, "\n%s: ", progname);
    perror(ofname);
    abort_gzip();
}

/* ========================================================================
 * Display compression ratio on the given stream on 6 characters.
 */
void display_ratio(num, den, file)
    long num;
    long den;
    FILE *file;
{
    long ratio;  /* 1000 times the compression ratio */
    char sign;

    if (den == 0) {
	ratio = 0; /* no compression */
    } else if (den < 2147483L) { /* (2**31 -1)/1000 */
	ratio = 1000L*num/den;
    } else {
	ratio = num/(den/1000L);
    }
    if (ratio < 0) {
	sign = '-';
	ratio = -ratio;
    } else {
	sign = ' ';
    }
    fprintf(file, "%c%2ld.%1ld%%", sign, ratio / 10L, ratio % 10L);
}


/* ========================================================================
 * Semi-safe malloc -- never returns NULL.
 */
voidp xmalloc (size)
    unsigned size;
{
    voidp cp = (voidp)malloc (size);

    if (cp == NULL) error("out of memory");
    return cp;
}

/* ========================================================================
 * Table of CRC-32's of all single-byte values (made by makecrc.c)
 */
ulg crc_32_tab[] = {
  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  0x2d02ef8dL
};
1	/* util.c -- utility functions for gzip support
2	* Copyright (C) 1992-1993 Jean-loup Gailly
3	* This is free software; you can redistribute it and/or modify it under the
4	* terms of the GNU General Public License, see the file COPYING.
5	*/
6
7	#ifdef RCSID
8	static char rcsid[] = "$Id: util.c,v 1.1 2002/08/18 00:59:21 hpa Exp $";
9	#endif
10
11	#include <ctype.h>
12	#include <errno.h>
13	#include <sys/types.h>
14
15	#include "tailor.h"
16
17	#include <unistd.h>
18	#include <fcntl.h>
19	#include <stdlib.h>
20
21	#include "gzip.h"
22
23	extern ulg crc_32_tab[]; /* crc table, defined below */
24
25	/* ===========================================================================
26	* Copy input to output unchanged: zcat == cat with --force.
27	* IN assertion: insize bytes have already been read in inbuf.
28	*/
29	int copy(in, out)
30	int in, out; /* input and output file descriptors */
31	{
32	errno = 0;
33	while (insize != 0 && (int)insize != EOF) {
34	write_buf(out, (char*)inbuf, insize);
35	bytes_out += insize;
36	insize = read(in, (char*)inbuf, INBUFSIZ);
37	}
38	if ((int)insize == EOF && errno != 0) {
39	read_error();
40	}
41	bytes_in = bytes_out;
42	return OK;
43	}
44
45	/* ===========================================================================
46	* Run a set of bytes through the crc shift register. If s is a NULL
47	* pointer, then initialize the crc shift register contents instead.
48	* Return the current crc in either case.
49	*/
50	ulg updcrc(s, n)
51	uch s; / pointer to bytes to pump through */
52	unsigned n; /* number of bytes in s[] */
53	{
54	register ulg c; /* temporary variable */
55
56	static ulg crc = (ulg)0xffffffffL; /* shift register contents */
57
58	if (s == NULL) {
59	c = 0xffffffffL;
60	} else {
61	c = crc;
62	if (n) do {
63	c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);
64	} while (--n);
65	}
66	crc = c;
67	return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */
68	}
69
70	/* ===========================================================================
71	* Clear input and output buffers
72	*/
73	void clear_bufs()
74	{
75	outcnt = 0;
76	insize = inptr = 0;
77	bytes_in = bytes_out = 0L;
78	}
79
80	/* ===========================================================================
81	* Fill the input buffer. This is called only when the buffer is empty.
82	*/
83	int fill_inbuf(eof_ok)
84	int eof_ok; /* set if EOF acceptable as a result */
85	{
86	int len;
87
88	/* Read as much as possible */
89	insize = 0;
90	errno = 0;
91	do {
92	len = read(ifd, (char*)inbuf+insize, INBUFSIZ-insize);
93	if (len == 0 \|\| len == EOF) break;
94	insize += len;
95	} while (insize < INBUFSIZ);
96
97	if (insize == 0) {
98	if (eof_ok) return EOF;
99	read_error();
100	}
101	bytes_in += (ulg)insize;
102	inptr = 1;
103	return inbuf[0];
104	}
105
106	/* ===========================================================================
107	* Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
108	* (used for the compressed data only)
109	*/
110	void flush_outbuf()
111	{
112	if (outcnt == 0) return;
113
114	write_buf(ofd, (char *)outbuf, outcnt);
115	bytes_out += (ulg)outcnt;
116	outcnt = 0;
117	}
118
119	/* ===========================================================================
120	* Write the output window window[0..outcnt-1] and update crc and bytes_out.
121	* (Used for the decompressed data only.)
122	*/
123	void flush_window()
124	{
125	if (outcnt == 0) return;
126	updcrc(window, outcnt);
127
128	if (!test) {
129	write_buf(ofd, (char *)window, outcnt);
130	}
131	bytes_out += (ulg)outcnt;
132	outcnt = 0;
133	}
134
135	/* ===========================================================================
136	* Does the same as write(), but also handles partial pipe writes and checks
137	* for error return.
138	*/
139	void write_buf(fd, buf, cnt)
140	int fd;
141	voidp buf;
142	unsigned cnt;
143	{
144	unsigned n;
145
146	while ((n = write(fd, buf, cnt)) != cnt) {
147	if (n == (unsigned)(-1)) {
148	write_error();
149	}
150	cnt -= n;
151	buf = (voidp)((char*)buf+n);
152	}
153	}
154
155	/* ========================================================================
156	* Put string s in lower case, return s.
157	*/
158	char *strlwr(s)
159	char *s;
160	{
161	char *t;
162	for (t = s; t; t++) t = tolow(*t);
163	return s;
164	}
165
166	/* ========================================================================
167	* Return the base name of a file (remove any directory prefix and
168	* any version suffix). For systems with file names that are not
169	* case sensitive, force the base name to lower case.
170	*/
171	char *basename(fname)
172	char *fname;
173	{
174	char *p;
175
176	if ((p = strrchr(fname, PATH_SEP)) != NULL) fname = p+1;
177	if (casemap('A') == 'a') strlwr(fname);
178	return fname;
179	}
180
181	/* ========================================================================
182	* Add an environment variable (if any) before argv, and update argc.
183	* Return the expanded environment variable to be freed later, or NULL
184	* if no options were added to argv.
185	*/
186	#define SEPARATOR " \t" /* separators in env variable */
187
188	char *add_envopt(argcp, argvp, env)
189	int argcp; / pointer to argc */
190	char **argvp; / pointer to argv */
191	char env; / name of environment variable */
192	{
193	char p; / running pointer through env variable */
194	char *oargv; / runs through old argv array */
195	char *nargv; / runs through new argv array */
196	int oargc = argcp; / old argc */
197	int nargc = 0; /* number of arguments in env variable */
198
199	env = (char*)getenv(env);
200	if (env == NULL) return NULL;
201
202	p = (char*)xmalloc(strlen(env)+1);
203	env = strcpy(p, env); /* keep env variable intact */
204
205	for (p = env; p; nargc++ ) { / move through env */
206	p += strspn(p, SEPARATOR); /* skip leading separators */
207	if (*p == '\0') break;
208
209	p += strcspn(p, SEPARATOR); /* find end of word */
210	if (p) p++ = '\0'; /* mark it */
211	}
212	if (nargc == 0) {
213	free(env);
214	return NULL;
215	}
216	*argcp += nargc;
217	/* Allocate the new argv array, with an extra element just in case
218	* the original arg list did not end with a NULL.
219	*/
220	nargv = (char*)calloc(argcp+1, sizeof(char *));
221	if (nargv == NULL) error("out of memory");
222	oargv = *argvp;
223	*argvp = nargv;
224
225	/* Copy the program name first */
226	if (oargc-- < 0) error("argc<=0");
227	(nargv++) = (oargv++);
228
229	/* Then copy the environment args */
230	for (p = env; nargc > 0; nargc--) {
231	p += strspn(p, SEPARATOR); /* skip separators */
232	(nargv++) = p; / store start */
233	while (p++) ; / skip over word */
234	}
235
236	/* Finally copy the old args and add a NULL (usual convention) */
237	while (oargc--) (nargv++) = (oargv++);
238	*nargv = NULL;
239	return env;
240	}
241
242	/* ========================================================================
243	* Error handlers.
244	*/
245	void error(m)
246	char *m;
247	{
248	fprintf(stderr, "\n%s: %s: %s\n", progname, ifname, m);
249	abort_gzip();
250	}
251
252	void warn(a, b)
253	char a, b; /* message strings juxtaposed in output */
254	{
255	WARN((stderr, "%s: %s: warning: %s%s\n", progname, ifname, a, b));
256	}
257
258	void read_error()
259	{
260	fprintf(stderr, "\n%s: ", progname);
261	if (errno != 0) {
262	perror(ifname);
263	} else {
264	fprintf(stderr, "%s: unexpected end of file\n", ifname);
265	}
266	abort_gzip();
267	}
268
269	void write_error()
270	{
271	fprintf(stderr, "\n%s: ", progname);
272	perror(ofname);
273	abort_gzip();
274	}
275
276	/* ========================================================================
277	* Display compression ratio on the given stream on 6 characters.
278	*/
279	void display_ratio(num, den, file)
280	long num;
281	long den;
282	FILE *file;
283	{
284	long ratio; /* 1000 times the compression ratio */
285	char sign;
286
287	if (den == 0) {
288	ratio = 0; /* no compression */
289	} else if (den < 2147483L) { /* (2*31 -1)/1000 /
290	ratio = 1000L*num/den;
291	} else {
292	ratio = num/(den/1000L);
293	}
294	if (ratio < 0) {
295	sign = '-';
296	ratio = -ratio;
297	} else {
298	sign = ' ';
299	}
300	fprintf(file, "%c%2ld.%1ld%%", sign, ratio / 10L, ratio % 10L);
301	}
302
303
304	/* ========================================================================
305	* Semi-safe malloc -- never returns NULL.
306	*/
307	voidp xmalloc (size)
308	unsigned size;
309	{
310	voidp cp = (voidp)malloc (size);
311
312	if (cp == NULL) error("out of memory");
313	return cp;
314	}
315
316	/* ========================================================================
317	* Table of CRC-32's of all single-byte values (made by makecrc.c)
318	*/
319	ulg crc_32_tab[] = {
320	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
321	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
322	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
323	0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
324	0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
325	0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
326	0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
327	0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
328	0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
329	0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
330	0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
331	0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
332	0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
333	0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
334	0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
335	0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
336	0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
337	0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
338	0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
339	0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
340	0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
341	0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
342	0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
343	0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
344	0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
345	0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
346	0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
347	0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
348	0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
349	0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
350	0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
351	0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
352	0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
353	0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
354	0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
355	0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
356	0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
357	0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
358	0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
359	0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
360	0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
361	0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
362	0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
363	0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
364	0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
365	0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
366	0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
367	0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
368	0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
369	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
370	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
371	0x2d02ef8dL
372	};