13    The code lengths are lens[0..codes-1].  The result starts at *table,
17    -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
19    requested root table index bits, and on return it is the actual root
20    table index bits.  It will differ if the request is greater than the
24 			code **table, unsigned *bits, unsigned short *work)  in zlib_inflate_table()  argument
29     unsigned root;              /* number of index bits for root table */  in zlib_inflate_table()
30     unsigned curr;              /* number of index bits for current table */  in zlib_inflate_table()
31     unsigned drop;              /* code bits to drop for sub-table */  in zlib_inflate_table()
33     unsigned used;              /* code entries in table used */  in zlib_inflate_table()
39     code this;                  /* table entry for duplication */  in zlib_inflate_table()
40     code *next;             /* next available space in table */  in zlib_inflate_table()
41     const unsigned short *base;     /* base value table to use */  in zlib_inflate_table()
42     const unsigned short *extra;    /* extra bits table to use */  in zlib_inflate_table()
45     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */  in zlib_inflate_table()
80        creating from that a table of starting indices for each length in the  in zlib_inflate_table()
81        sorted table, and then entering the symbols in order in the sorted  in zlib_inflate_table()
82        table.  The sorted table is work[], with that space being provided by  in zlib_inflate_table()
88        at length counts to determine sub-table sizes when building the  in zlib_inflate_table()
107         *(*table)++ = this;             /* make a table to force an error */  in zlib_inflate_table()
108         *(*table)++ = this;  in zlib_inflate_table()
126     /* generate offsets into symbol table for each length for sorting */  in zlib_inflate_table()
136        Create and fill in decoding tables.  In this loop, the table being  in zlib_inflate_table()
141        fill the table with replicated entries.  in zlib_inflate_table()
143        root is the number of index bits for the root table.  When len exceeds  in zlib_inflate_table()
146        new sub-table should be started.  drop is zero when the root table is  in zlib_inflate_table()
149        When a new sub-table is needed, it is necessary to look ahead in the  in zlib_inflate_table()
150        code lengths to determine what size sub-table is needed.  The length  in zlib_inflate_table()
154        used keeps track of how many table entries have been allocated from the  in zlib_inflate_table()
155        provided *table space.  It is checked when a LENS table is being made  in zlib_inflate_table()
156        against the space in *table, ENOUGH, minus the maximum space needed by  in zlib_inflate_table()
190     next = *table;              /* current table to fill in */  in zlib_inflate_table()
191     curr = root;                /* current table index bits */  in zlib_inflate_table()
193     low = (unsigned)(-1);       /* trigger new sub-table when len > root */  in zlib_inflate_table()
194     used = 1U << root;          /* use root table entries */  in zlib_inflate_table()
197     /* check available table space */  in zlib_inflate_table()
201     /* process all codes and make table entries */  in zlib_inflate_table()
203         /* create table entry */  in zlib_inflate_table()
221         min = fill;                 /* save offset to next table */  in zlib_inflate_table()
245         /* create new sub-table if needed */  in zlib_inflate_table()
251             /* increment past last table */  in zlib_inflate_table()
254             /* determine length of next table */  in zlib_inflate_table()
269             /* point entry in root table to sub-table */  in zlib_inflate_table()
271             (*table)[low].op = (unsigned char)curr;  in zlib_inflate_table()
272             (*table)[low].bits = (unsigned char)root;  in zlib_inflate_table()
273             (*table)[low].val = (unsigned short)(next - *table);  in zlib_inflate_table()
278        Fill in rest of table for incomplete codes.  This loop is similar to the  in zlib_inflate_table()
279        loop above in incrementing huff for table indices.  It is assumed that  in zlib_inflate_table()
281        through high index bits.  When the current sub-table is filled, the loop  in zlib_inflate_table()
282        drops back to the root table to fill in any remaining entries there.  in zlib_inflate_table()
288         /* when done with sub-table, drop back to root table */  in zlib_inflate_table()
292             next = *table;  in zlib_inflate_table()
296         /* put invalid code marker in table */  in zlib_inflate_table()
312     *table += used;  in zlib_inflate_table()