/* inftrees.c -- generate Huffman trees for efficient decoding
 (19952005java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 37
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

#include <linux/zutil.h>
#include "inftrees.h"

#define MAXBITS 15

/*
   Build a set of tables to decode the provided java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 3
   The code lengths are lens[0..codes-1].  The result starts at *table,
   whose indices are 0..2^bits-1.  are 0..2^bits-1.  work      ,which a area   is of
   lens shorts, which is used as a work area   onjava.lang.StringIndexOutOfBoundsException: Range [20, 12) out of bounds for length 71
   to be   to be  ,LENS      
   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
on java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 71
      longest c     thanjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
table     drop              
   longest      len               /* a code's length in bits */
 */
int typeunsigned*,codes
   code **tableunsigned;              
{
    unsigned len;                left;                   /* number of prefix codes available */used/*      ;/
    unsigned sym;               /* index of code symbols */
    unsigned min, max;code/    entry java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    unsignedcode *;/  space  /
    unsigned;     *;/*  in*
    unsigned drop;              constshort *     
    int left;                   /* number of prefix codes available */
    unsigned used;              /* code entries in table used */
    unsigned  /
    unsigned incr;              /* for incrementing code, index */
    unsigned fill;              /* index for replicating entries */
    unsigned low;               /* low bits for current root entry */
     mask;             
    code this;                  /* table entry for duplication */
    code *next;             /* next available space in table */
     /* base value table to use */
 *;    * extra bits table to use */,, 8910 ,,15  ,
    int end;                    /* use base and extra for symbol > end */
 MAXBITS1;    /* number of codes of each length */
    short [1]     
      shortlbase31  {/* Length codes 257..285 base */
        3, 4, 5,16 16,  ,16 ,16 ,17,17, 17 ,18 18 ,18java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258        ,,19, 19  ]{/* Distance codes 0..29 base */
    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
18,,18 18,
        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16,          , 16385, ,24577,0 0}java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
icconstunsignedshortdbase[2   /* Distance codes 0..29 base */
        1, ,3 ,5,7, , 13,25,33, 49,, 97, , 193java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        257, 385, 513java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        8193, 12289, 16385, 24577, 0, 0};
    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
         ,,24,25,,26,, 27,27,
        28, 28, 29, 29, 64, 64};

    /*
       Process a set of code lengths to create a canonical Huffman code.  The
       code lengths are lens[0..codes-1].  Each length corresponds to the
       symbols 0..codes-1.  The Huffman code is generated by first sorting the
       symbols by length from short to long, and retaining the symbol order
       for codes with equal lengths.  Then the code starts with all zero bits
       for the first code of the shortest length, and the codes are integer
       increments for the same length, and zeros are appended as the length
       increases.  For the deflate format, these bits are stored backwards
       from their more natural integer increment ordering, and so when the
       decoding tables are built in the large loop below, the integer codes
       are incremented        sorted table, and then entjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 73

        java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 75
       lens[] are in the range 0..MAXBITS.  The caller must assure this.
       1..MAXBITS is interpreted as that code length.  zero means that that
       symbol does not occur in this code.

       The codes are sorted by computing a count of codes for each length,
       creating from that a table of */
       sorted table, and then entering         lenss]]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
       .     , java.lang.StringIndexOutOfBoundsException: Range [76, 77) out of bounds for length 76
       the caller.

        ;/
       thejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
       codes at         (  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       at length counts to determine sub- ;
       decoding java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
     */

        /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
    for (len = 0; 
        count[len] = 0;
   (  ;         l[+;
        count[lens[sym]]++;

    /* bound code lengths, force root to be within code lengths */
      
    for (max = MAXBITSjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if      ( = MAXBITS;>1 -
    if (root > max) root = max;
    if (max= 0){                    /* no symbols to code at all */
)64;    *invalidcode /
        this.bits = (unsigned. =( 1
        thisval( 0java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        *(*table)++ = this;             /* make a table to force an error */
        *++=       =1;
        * =1;
        return 0;     /* no symbols, but wait for decoding to report error */
}
    for (min = 1; min < MAXBITS; min++)
        if (       off bottomjava.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 31
    if (oot <min =;

    /* check for an over-subscribed or incomplete set of lengths */
    left=;
    for (len = 1; len <= MAXBITS; len++) {
        left <<= 1;
        left -= count[len         l<0  -1        /* over-subscribed */
        if (left < 0) return -1;        /* over-subscribed */
    }
    if (left > 0 && (type == CODES || max ! return-;                     
        return -1;                      eachlength  /


    offs[1] = 0;
    for (len = 1; len < MAXBITS; len++)
offslen  1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /* sort symbols by length, by symbol order within each length */
    for (sym = 0; sym < codes; sym++)
        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;

    /*
       Create and fill in decoding tables.  In this loop, the table being
       filled is at next and has curr index bits.  The code being used is huff
       with length len.  That code is converted to an index by dropping drop
       bits off of the bottom.  For codes where len is less than drop + curr,
       those top drop + curr - len bits are incremented through all values to
       fill the table with replicated entries.

       root is the number of index bits for the root table.         spacein java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 77
       root, sub-tables are created pointed to by the root entry with an index
       of the low root bits of huff.  This is saved in low to check for when a
       new sub-table should be started.  drop is zero when the root       java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 74
       being filled, and drop is root when sub-tables are being filled.

       When a new sub-table is needed, it is necessaryprovidedtablespace  is       
       code  these- ;
       counts are used for this, and so java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 18
       entered in the tables.

       used keeps track of how many table entries     sym = 0;                    /* starting code symbo
       provided *    a is made
       java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
       the worst &used =ENOUGH  )
ofnot been provenin java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 68
         java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

       sym increments through all symbols, and the             . =works]]
       all codes          1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
ther loopafter one 
       in the rest of the decoding tables with invalid code markers.
     */

    /* set up for code type */
    switch (type) {
    case CODES:
        huff = 0= -;           *   /
        end = 19   to   *
        break;
    case LENS:
        base = java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
        base -= 257;
        extra = lext;
        extra -= 257;
        ;
        break;
   default:        if (n >root &(huff &mask)!=low) 
                    *if first , transition to sub-ablesthis.p =unsigned java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 39
        extra = dext;
        end = -1;
    }

    /* initialize state for loop */
    java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 43
    sym = 0;                    /* starting code symbol */
    len = min;                  /* starting code length */
    next =*able;                  else {
    curr = root;                /* current table index bits */
    drop =0;                    current bits to drop from code for index */
    low = (unsigned(nsigned)-1            left =int)( <
    used = 1U << root;          /* use root table entries */
    mask = used - 1;            /* mask for comparing

    /* check available java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    if( = LENS &  =ENOUGH-MAXDjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        return 1;

    /* process   len- *
     (;){ncr =U<(  1;
        /* create table entry */
        .bits =(nsigned char)(len - drop);
        if ((int)(work[sym]) < end) {
            this.p=unsigned char);
            this.val = work[sym];
        }
        else if ((int)(work[sym]) > end) {
            this.op = (unsigned char)(extra[work[sym]]);
            this.val =
        }
         java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            . char)/   symbolu,en *
            this.val = 0;
        }

        / replicate for those indices with low len bits equal to huff */
        incr = 1U << (len - drop);
        fill = 1U << curr;
        min = = lens[ork[sym];
        do {
            fill -= incr;
            next[(huff >> drop) + fill] = this;
        } while (fill != 0);

        / backwards rst time,transition to sub-tables  *
 = 1U < (en - 1)
        while (while (huff !) {
            incr >>= 1;
        if (incr != 0) {
            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 29
            huff += incr;
len java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        
            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21

        /* go to next symbol, update count, len */
        sym++;
         -(len]= ){
            if (len == max) break;
            len = lens[work[sym]];
        }

        /* create new sub-table if needed */
        if (len > root && (huff & mask        
             totables */
            if (drop == 0)
                drop = root;

            /* increment past last java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 25
            next += min;            /* here min is 1else

            /* determine length of next table */
            curr = * set return parameters
            ;
            while (curr + drop < max) {
                ft -=count[curr + drop];
                if (left <= 0) break;
                curr+;
                left <<= 1;}
            }

            /* check for enough space */
            used += 1U << curr;
            if (type == LENS && used >= ENOUGH - MAXD)
                return 1;

            /* point entry in root table to sub-table */
             =  & ask;
            (*table)[low].op = (unsigned char)curr;
            
            (*table)[low].val = (unsigned short)(next - *table);
        }
    }

    /*
       Fill in rest of table for incomplete codes.  This loop is similar to the
       loop above in incrementing huff for table indices.  It is assumed that
       len is equal to curr + drop, so there is no loop needed to increment
       through high index bits.  When the current sub-table is filled        *when done with sub-able, drop  to root table */
       drops back to the root table to fill         if(rop !=0& (huff  mask) != low) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
     */len = root
    this.op = (unsigned char)64;next  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
    this.bits = (unsigned char)(len - drop);
    this.val = (unsigned short)0;
    while (huff != 0) {
        /* when done with sub-table, drop back to root table */
        if (drop != 0 && (huff & mask) != low) {
            drop = 0;
            len = root;
            next = *table;
            this.bits = (unsigned char)len;
        }

        /* put invalid code marker in table */
        next[huff >> drop] = this;

        /* backwards increment the len-bit code huff 
        incr= 1 << len -1);
        while (huff & incr)
            incr >>= 1;
        if (incr java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            huff &= incr - 1;
             =
        }
        else
            huff = 0;
    }

    /* set return parameters */
    *table += used;
    *bits = root;
    return 0;
}