Coding Style cleanup; update CHANGELOG.

Signed-off-by: Wolfgang Denk <wd@denx.de>

1 files changed, 944 insertions, 944 deletions

diff --git a/lib_generic/zlib.c b/lib_generic/zlib.c
index f415f6b4c37..0e1e0d577a2 100644
--- a/lib_generic/zlib.c
+++ b/lib_generic/zlib.c
@@ -214,21 +214,21 @@ typedef enum {
     (most modes can go to the BAD or MEM mode -- not shown for clarity)
 
     Process header:
-        HEAD -> (gzip) or (zlib)
-        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
-        NAME -> COMMENT -> HCRC -> TYPE
-        (zlib) -> DICTID or TYPE
-        DICTID -> DICT -> TYPE
+	HEAD -> (gzip) or (zlib)
+	(gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+	NAME -> COMMENT -> HCRC -> TYPE
+	(zlib) -> DICTID or TYPE
+	DICTID -> DICT -> TYPE
     Read deflate blocks:
-            TYPE -> STORED or TABLE or LEN or CHECK
-            STORED -> COPY -> TYPE
-            TABLE -> LENLENS -> CODELENS -> LEN
+	    TYPE -> STORED or TABLE or LEN or CHECK
+	    STORED -> COPY -> TYPE
+	    TABLE -> LENLENS -> CODELENS -> LEN
     Read deflate codes:
-                LEN -> LENEXT or LIT or TYPE
-                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
-                LIT -> LEN
+		LEN -> LENEXT or LIT or TYPE
+		LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+		LIT -> LEN
     Process trailer:
-        CHECK -> LENGTH -> DONE
+	CHECK -> LENGTH -> DONE
  */
 
 /* state maintained between inflate() calls.  Approximately 7K bytes. */
@@ -242,26 +242,26 @@ struct inflate_state {
 	unsigned long check; /* protected copy of check value */
 	unsigned long total; /* protected copy of output count */
 	gz_headerp head; /* where to save gzip header information */
-        /* sliding window */
+	/* sliding window */
 	unsigned wbits; /* log base 2 of requested window size */
 	unsigned wsize; /* window size or zero if not using window */
 	unsigned whave; /* valid bytes in the window */
 	unsigned write; /* window write index */
 	unsigned char FAR *window; /* allocated sliding window, if needed */
-        /* bit accumulator */
+	/* bit accumulator */
 	unsigned long hold; /* input bit accumulator */
 	unsigned bits; /* number of bits in "in" */
-        /* for string and stored block copying */
+	/* for string and stored block copying */
 	unsigned length; /* literal or length of data to copy */
 	unsigned offset; /* distance back to copy string from */
-        /* for table and code decoding */
+	/* for table and code decoding */
 	unsigned extra; /* extra bits needed */
-        /* fixed and dynamic code tables */
+	/* fixed and dynamic code tables */
 	code const FAR *lencode; /* starting table for length/literal codes */
 	code const FAR *distcode; /* starting table for distance codes */
 	unsigned lenbits; /* index bits for lencode */
 	unsigned distbits; /* index bits for distcode */
-        /* dynamic table building */
+	/* dynamic table building */
 	unsigned ncode; /* number of code length code lengths */
 	unsigned nlen; /* number of length code lengths */
 	unsigned ndist; /* number of distance code lengths */
@@ -410,17 +410,17 @@ void inflate_fast OF((z_streamp strm, unsigned start));
 
    Entry assumptions:
 
-        state->mode == LEN
-        strm->avail_in >= 6
-        strm->avail_out >= 258
-        start >= strm->avail_out
-        state->bits < 8
+	state->mode == LEN
+	strm->avail_in >= 6
+	strm->avail_out >= 258
+	start >= strm->avail_out
+	state->bits < 8
 
    On return, state->mode is one of:
 
-        LEN -- ran out of enough output space or enough available input
-        TYPE -- reached end of block code, inflate() to interpret next block
-        BAD -- error in block data
+	LEN -- ran out of enough output space or enough available input
+	TYPE -- reached end of block code, inflate() to interpret next block
+	BAD -- error in block data
 
    Notes:
 
@@ -460,7 +460,7 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     unsigned dmask;             /* mask for first level of distance codes */
     code this;                  /* retrieved table entry */
     unsigned op;                /* code bits, operation, extra bits, or */
-                                /*  window position, window bytes to copy */
+				/*  window position, window bytes to copy */
     unsigned len;               /* match length, unused bytes */
     unsigned dist;              /* match distance */
     unsigned char FAR *from;    /* where to copy match from */
@@ -489,170 +489,170 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     /* decode literals and length/distances until end-of-block or not enough
        input data or output space */
     do {
-        if (bits < 15) {
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-        }
-        this = lcode[hold & lmask];
+	if (bits < 15) {
+	    hold += (unsigned long)(PUP(in)) << bits;
+	    bits += 8;
+	    hold += (unsigned long)(PUP(in)) << bits;
+	    bits += 8;
+	}
+	this = lcode[hold & lmask];
       dolen:
-        op = (unsigned)(this.bits);
-        hold >>= op;
-        bits -= op;
-        op = (unsigned)(this.op);
-        if (op == 0) {                          /* literal */
-            Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
-                    "inflate:         literal '%c'\n" :
-                    "inflate:         literal 0x%02x\n", this.val));
-            PUP(out) = (unsigned char)(this.val);
-        }
-        else if (op & 16) {                     /* length base */
-            len = (unsigned)(this.val);
-            op &= 15;                           /* number of extra bits */
-            if (op) {
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                }
-                len += (unsigned)hold & ((1U << op) - 1);
-                hold >>= op;
-                bits -= op;
-            }
-            Tracevv((stderr, "inflate:         length %u\n", len));
-            if (bits < 15) {
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-            }
-            this = dcode[hold & dmask];
-          dodist:
-            op = (unsigned)(this.bits);
-            hold >>= op;
-            bits -= op;
-            op = (unsigned)(this.op);
-            if (op & 16) {                      /* distance base */
-                dist = (unsigned)(this.val);
-                op &= 15;                       /* number of extra bits */
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                    if (bits < op) {
-                        hold += (unsigned long)(PUP(in)) << bits;
-                        bits += 8;
-                    }
-                }
-                dist += (unsigned)hold & ((1U << op) - 1);
+	op = (unsigned)(this.bits);
+	hold >>= op;
+	bits -= op;
+	op = (unsigned)(this.op);
+	if (op == 0) {                          /* literal */
+	    Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+		    "inflate:         literal '%c'\n" :
+		    "inflate:         literal 0x%02x\n", this.val));
+	    PUP(out) = (unsigned char)(this.val);
+	}
+	else if (op & 16) {                     /* length base */
+	    len = (unsigned)(this.val);
+	    op &= 15;                           /* number of extra bits */
+	    if (op) {
+		if (bits < op) {
+		    hold += (unsigned long)(PUP(in)) << bits;
+		    bits += 8;
+		}
+		len += (unsigned)hold & ((1U << op) - 1);
+		hold >>= op;
+		bits -= op;
+	    }
+	    Tracevv((stderr, "inflate:         length %u\n", len));
+	    if (bits < 15) {
+		hold += (unsigned long)(PUP(in)) << bits;
+		bits += 8;
+		hold += (unsigned long)(PUP(in)) << bits;
+		bits += 8;
+	    }
+	    this = dcode[hold & dmask];
+	  dodist:
+	    op = (unsigned)(this.bits);
+	    hold >>= op;
+	    bits -= op;
+	    op = (unsigned)(this.op);
+	    if (op & 16) {                      /* distance base */
+		dist = (unsigned)(this.val);
+		op &= 15;                       /* number of extra bits */
+		if (bits < op) {
+		    hold += (unsigned long)(PUP(in)) << bits;
+		    bits += 8;
+		    if (bits < op) {
+			hold += (unsigned long)(PUP(in)) << bits;
+			bits += 8;
+		    }
+		}
+		dist += (unsigned)hold & ((1U << op) - 1);
 #ifdef INFLATE_STRICT
-                if (dist > dmax) {
-                    strm->msg = (char *)"invalid distance too far back";
-                    state->mode = BAD;
-                    break;
-                }
+		if (dist > dmax) {
+		    strm->msg = (char *)"invalid distance too far back";
+		    state->mode = BAD;
+		    break;
+		}
 #endif
-                hold >>= op;
-                bits -= op;
-                Tracevv((stderr, "inflate:         distance %u\n", dist));
-                op = (unsigned)(out - beg);     /* max distance in output */
-                if (dist > op) {                /* see if copy from window */
-                    op = dist - op;             /* distance back in window */
-                    if (op > whave) {
-                        strm->msg = (char *)"invalid distance too far back";
-                        state->mode = BAD;
-                        break;
-                    }
-                    from = window - OFF;
-                    if (write == 0) {           /* very common case */
-                        from += wsize - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    else if (write < op) {      /* wrap around window */
-                        from += wsize + write - op;
-                        op -= write;
-                        if (op < len) {         /* some from end of window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = window - OFF;
-                            if (write < len) {  /* some from start of window */
-                                op = write;
-                                len -= op;
-                                do {
-                                    PUP(out) = PUP(from);
-                                } while (--op);
-                                from = out - dist;      /* rest from output */
-                            }
-                        }
-                    }
-                    else {                      /* contiguous in window */
-                        from += write - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    while (len > 2) {
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    }
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-                else {
-                    from = out - dist;          /* copy direct from output */
-                    do {                        /* minimum length is three */
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    } while (len > 2);
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-            }
-            else if ((op & 64) == 0) {          /* 2nd level distance code */
-                this = dcode[this.val + (hold & ((1U << op) - 1))];
-                goto dodist;
-            }
-            else {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-        }
-        else if ((op & 64) == 0) {              /* 2nd level length code */
-            this = lcode[this.val + (hold & ((1U << op) - 1))];
-            goto dolen;
-        }
-        else if (op & 32) {                     /* end-of-block */
-            Tracevv((stderr, "inflate:         end of block\n"));
-            state->mode = TYPE;
-            break;
-        }
-        else {
-            strm->msg = (char *)"invalid literal/length code";
-            state->mode = BAD;
-            break;
-        }
+		hold >>= op;
+		bits -= op;
+		Tracevv((stderr, "inflate:         distance %u\n", dist));
+		op = (unsigned)(out - beg);     /* max distance in output */
+		if (dist > op) {                /* see if copy from window */
+		    op = dist - op;             /* distance back in window */
+		    if (op > whave) {
+			strm->msg = (char *)"invalid distance too far back";
+			state->mode = BAD;
+			break;
+		    }
+		    from = window - OFF;
+		    if (write == 0) {           /* very common case */
+			from += wsize - op;
+			if (op < len) {         /* some from window */
+			    len -= op;
+			    do {
+				PUP(out) = PUP(from);
+			    } while (--op);
+			    from = out - dist;  /* rest from output */
+			}
+		    }
+		    else if (write < op) {      /* wrap around window */
+			from += wsize + write - op;
+			op -= write;
+			if (op < len) {         /* some from end of window */
+			    len -= op;
+			    do {
+				PUP(out) = PUP(from);
+			    } while (--op);
+			    from = window - OFF;
+			    if (write < len) {  /* some from start of window */
+				op = write;
+				len -= op;
+				do {
+				    PUP(out) = PUP(from);
+				} while (--op);
+				from = out - dist;      /* rest from output */
+			    }
+			}
+		    }
+		    else {                      /* contiguous in window */
+			from += write - op;
+			if (op < len) {         /* some from window */
+			    len -= op;
+			    do {
+				PUP(out) = PUP(from);
+			    } while (--op);
+			    from = out - dist;  /* rest from output */
+			}
+		    }
+		    while (len > 2) {
+			PUP(out) = PUP(from);
+			PUP(out) = PUP(from);
+			PUP(out) = PUP(from);
+			len -= 3;
+		    }
+		    if (len) {
+			PUP(out) = PUP(from);
+			if (len > 1)
+			    PUP(out) = PUP(from);
+		    }
+		}
+		else {
+		    from = out - dist;          /* copy direct from output */
+		    do {                        /* minimum length is three */
+			PUP(out) = PUP(from);
+			PUP(out) = PUP(from);
+			PUP(out) = PUP(from);
+			len -= 3;
+		    } while (len > 2);
+		    if (len) {
+			PUP(out) = PUP(from);
+			if (len > 1)
+			    PUP(out) = PUP(from);
+		    }
+		}
+	    }
+	    else if ((op & 64) == 0) {          /* 2nd level distance code */
+		this = dcode[this.val + (hold & ((1U << op) - 1))];
+		goto dodist;
+	    }
+	    else {
+		strm->msg = (char *)"invalid distance code";
+		state->mode = BAD;
+		break;
+	    }
+	}
+	else if ((op & 64) == 0) {              /* 2nd level length code */
+	    this = lcode[this.val + (hold & ((1U << op) - 1))];
+	    goto dolen;
+	}
+	else if (op & 32) {                     /* end-of-block */
+	    Tracevv((stderr, "inflate:         end of block\n"));
+	    state->mode = TYPE;
+	    break;
+	}
+	else {
+	    strm->msg = (char *)"invalid literal/length code";
+	    state->mode = BAD;
+	    break;
+	}
     } while (in < last && out < end);
 
     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
@@ -666,7 +666,7 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     strm->next_out = out + OFF;
     strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
     strm->avail_out = (unsigned)(out < end ?
-                                 257 + (end - out) : 257 - (out - end));
+				 257 + (end - out) : 257 - (out - end));
     state->hold = hold;
     state->bits = bits;
     return;
@@ -741,19 +741,19 @@ unsigned short FAR *work;
     unsigned short count[MAXBITS+1];    /* number of codes of each length */
     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
-        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+	16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+	19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
     static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-        8193, 12289, 16385, 24577, 0, 0};
+	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+	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,
-        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
-        28, 28, 29, 29, 64, 64};
+	16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+	23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+	28, 28, 29, 29, 64, 64};
 
     /*
        Process a set of code lengths to create a canonical Huffman code.  The
@@ -788,46 +788,46 @@ unsigned short FAR *work;
 
     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
     for (len = 0; len <= MAXBITS; len++)
-        count[len] = 0;
+	count[len] = 0;
     for (sym = 0; sym < codes; sym++)
-        count[lens[sym]]++;
+	count[lens[sym]]++;
 
     /* bound code lengths, force root to be within code lengths */
     root = *bits;
     for (max = MAXBITS; max >= 1; max--)
-        if (count[max] != 0) break;
+	if (count[max] != 0) break;
     if (root > max) root = max;
     if (max == 0) {                     /* no symbols to code at all */
-        this.op = (unsigned char)64;    /* invalid code marker */
-        this.bits = (unsigned char)1;
-        this.val = (unsigned short)0;
-        *(*table)++ = this;             /* make a table to force an error */
-        *(*table)++ = this;
-        *bits = 1;
-        return 0;     /* no symbols, but wait for decoding to report error */
+	this.op = (unsigned char)64;    /* invalid code marker */
+	this.bits = (unsigned char)1;
+	this.val = (unsigned short)0;
+	*(*table)++ = this;             /* make a table to force an error */
+	*(*table)++ = this;
+	*bits = 1;
+	return 0;     /* no symbols, but wait for decoding to report error */
     }
     for (min = 1; min <= MAXBITS; min++)
-        if (count[min] != 0) break;
+	if (count[min] != 0) break;
     if (root < min) root = min;
 
     /* check for an over-subscribed or incomplete set of lengths */
     left = 1;
     for (len = 1; len <= MAXBITS; len++) {
-        left <<= 1;
-        left -= count[len];
-        if (left < 0) return -1;        /* over-subscribed */
+	left <<= 1;
+	left -= count[len];
+	if (left < 0) return -1;        /* over-subscribed */
     }
     if (left > 0 && (type == CODES || max != 1))
-        return -1;                      /* incomplete set */
+	return -1;                      /* incomplete set */
 
     /* generate offsets into symbol table for each length for sorting */
     offs[1] = 0;
     for (len = 1; len < MAXBITS; len++)
-        offs[len + 1] = offs[len] + count[len];
+	offs[len + 1] = offs[len] + count[len];
 
     /* 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;
+	if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
 
     /*
        Create and fill in decoding tables.  In this loop, the table being
@@ -864,20 +864,20 @@ unsigned short FAR *work;
     /* set up for code type */
     switch (type) {
     case CODES:
-        base = extra = work;    /* dummy value--not used */
-        end = 19;
-        break;
+	base = extra = work;    /* dummy value--not used */
+	end = 19;
+	break;
     case LENS:
-        base = lbase;
-        base -= 257;
-        extra = lext;
-        extra -= 257;
-        end = 256;
-        break;
+	base = lbase;
+	base -= 257;
+	extra = lext;
+	extra -= 257;
+	end = 256;
+	break;
     default:            /* DISTS */
-        base = dbase;
-        extra = dext;
-        end = -1;
+	base = dbase;
+	extra = dext;
+	end = -1;
     }
 
     /* initialize state for loop */
@@ -893,82 +893,82 @@ unsigned short FAR *work;
 
     /* check available table space */
     if (type == LENS && used >= ENOUGH - MAXD)
-        return 1;
+	return 1;
 
     /* process all codes and make table entries */
     for (;;) {
-        /* create table entry */
-        this.bits = (unsigned char)(len - drop);
-        if ((int)(work[sym]) < end) {
-            this.op = (unsigned char)0;
-            this.val = work[sym];
-        }
-        else if ((int)(work[sym]) > end) {
-            this.op = (unsigned char)(extra[work[sym]]);
-            this.val = base[work[sym]];
-        }
-        else {
-            this.op = (unsigned char)(32 + 64);         /* end of block */
-            this.val = 0;
-        }
-
-        /* replicate for those indices with low len bits equal to huff */
-        incr = 1U << (len - drop);
-        fill = 1U << curr;
-        min = fill;                 /* save offset to next table */
-        do {
-            fill -= incr;
-            next[(huff >> drop) + fill] = this;
-        } while (fill != 0);
-
-        /* backwards increment the len-bit code huff */
-        incr = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        }
-        else
-            huff = 0;
-
-        /* go to next symbol, update count, len */
-        sym++;
-        if (--(count[len]) == 0) {
-            if (len == max) break;
-            len = lens[work[sym]];
-        }
-
-        /* create new sub-table if needed */
-        if (len > root && (huff & mask) != low) {
-            /* if first time, transition to sub-tables */
-            if (drop == 0)
-                drop = root;
-
-            /* increment past last table */
-            next += min;            /* here min is 1 << curr */
-
-            /* determine length of next table */
-            curr = len - drop;
-            left = (int)(1 << curr);
-            while (curr + drop < max) {
-                left -= 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 */
-            low = huff & mask;
-            (*table)[low].op = (unsigned char)curr;
-            (*table)[low].bits = (unsigned char)root;
-            (*table)[low].val = (unsigned short)(next - *table);
-        }
+	/* create table entry */
+	this.bits = (unsigned char)(len - drop);
+	if ((int)(work[sym]) < end) {
+	    this.op = (unsigned char)0;
+	    this.val = work[sym];
+	}
+	else if ((int)(work[sym]) > end) {
+	    this.op = (unsigned char)(extra[work[sym]]);
+	    this.val = base[work[sym]];
+	}
+	else {
+	    this.op = (unsigned char)(32 + 64);         /* end of block */
+	    this.val = 0;
+	}
+
+	/* replicate for those indices with low len bits equal to huff */
+	incr = 1U << (len - drop);
+	fill = 1U << curr;
+	min = fill;                 /* save offset to next table */
+	do {
+	    fill -= incr;
+	    next[(huff >> drop) + fill] = this;
+	} while (fill != 0);
+
+	/* backwards increment the len-bit code huff */
+	incr = 1U << (len - 1);
+	while (huff & incr)
+	    incr >>= 1;
+	if (incr != 0) {
+	    huff &= incr - 1;
+	    huff += incr;
+	}
+	else
+	    huff = 0;
+
+	/* go to next symbol, update count, len */
+	sym++;
+	if (--(count[len]) == 0) {
+	    if (len == max) break;
+	    len = lens[work[sym]];
+	}
+
+	/* create new sub-table if needed */
+	if (len > root && (huff & mask) != low) {
+	    /* if first time, transition to sub-tables */
+	    if (drop == 0)
+		drop = root;
+
+	    /* increment past last table */
+	    next += min;            /* here min is 1 << curr */
+
+	    /* determine length of next table */
+	    curr = len - drop;
+	    left = (int)(1 << curr);
+	    while (curr + drop < max) {
+		left -= 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 */
+	    low = huff & mask;
+	    (*table)[low].op = (unsigned char)curr;
+	    (*table)[low].bits = (unsigned char)root;
+	    (*table)[low].val = (unsigned short)(next - *table);
+	}
     }
 
     /*
@@ -982,27 +982,27 @@ unsigned short FAR *work;
     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 = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        }
-        else
-            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 = 1U << (len - 1);
+	while (huff & incr)
+	    incr >>= 1;
+	if (incr != 0) {
+	    huff &= incr - 1;
+	    huff += incr;
+	}
+	else
+	    huff = 0;
     }
 
     /* set return parameters */
@@ -1053,34 +1053,34 @@ int stream_size;
     struct inflate_state FAR *state;
 
     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-        stream_size != (int)(sizeof(z_stream)))
-        return Z_VERSION_ERROR;
+	stream_size != (int)(sizeof(z_stream)))
+	return Z_VERSION_ERROR;
     if (strm == Z_NULL) return Z_STREAM_ERROR;
     strm->msg = Z_NULL;                 /* in case we return an error */
     if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
-        strm->opaque = (voidpf)0;
+	strm->zalloc = zcalloc;
+	strm->opaque = (voidpf)0;
     }
     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
     state = (struct inflate_state FAR *)
-            ZALLOC(strm, 1, sizeof(struct inflate_state));
+	    ZALLOC(strm, 1, sizeof(struct inflate_state));
     if (state == Z_NULL) return Z_MEM_ERROR;
     Tracev((stderr, "inflate: allocated\n"));
     strm->state = (struct internal_state FAR *)state;
     if (windowBits < 0) {
-        state->wrap = 0;
-        windowBits = -windowBits;
+	state->wrap = 0;
+	windowBits = -windowBits;
     }
     else {
-        state->wrap = (windowBits >> 4) + 1;
+	state->wrap = (windowBits >> 4) + 1;
 #ifdef GUNZIP
-        if (windowBits < 48) windowBits &= 15;
+	if (windowBits < 48) windowBits &= 15;
 #endif
     }
     if (windowBits < 8 || windowBits > 15) {
-        ZFREE(strm, state);
-        strm->state = Z_NULL;
-        return Z_STREAM_ERROR;
+	ZFREE(strm, state);
+	strm->state = Z_NULL;
+	return Z_STREAM_ERROR;
     }
     state->wbits = (unsigned)windowBits;
     state->window = Z_NULL;
@@ -1129,41 +1129,41 @@ unsigned out;
 
     /* if it hasn't been done already, allocate space for the window */
     if (state->window == Z_NULL) {
-        state->window = (unsigned char FAR *)
-                        ZALLOC(strm, 1U << state->wbits,
-                               sizeof(unsigned char));
-        if (state->window == Z_NULL) return 1;
+	state->window = (unsigned char FAR *)
+			ZALLOC(strm, 1U << state->wbits,
+			       sizeof(unsigned char));
+	if (state->window == Z_NULL) return 1;
     }
 
     /* if window not in use yet, initialize */
     if (state->wsize == 0) {
-        state->wsize = 1U << state->wbits;
-        state->write = 0;
-        state->whave = 0;
+	state->wsize = 1U << state->wbits;
+	state->write = 0;
+	state->whave = 0;
     }
 
     /* copy state->wsize or less output bytes into the circular window */
     copy = out - strm->avail_out;
     if (copy >= state->wsize) {
-        zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
-        state->write = 0;
-        state->whave = state->wsize;
+	zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+	state->write = 0;
+	state->whave = state->wsize;
     }
     else {
-        dist = state->wsize - state->write;
-        if (dist > copy) dist = copy;
-        zmemcpy(state->window + state->write, strm->next_out - copy, dist);
-        copy -= dist;
-        if (copy) {
-            zmemcpy(state->window, strm->next_out - copy, copy);
-            state->write = copy;
-            state->whave = state->wsize;
-        }
-        else {
-            state->write += dist;
-            if (state->write == state->wsize) state->write = 0;
-            if (state->whave < state->wsize) state->whave += dist;
-        }
+	dist = state->wsize - state->write;
+	if (dist > copy) dist = copy;
+	zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+	copy -= dist;
+	if (copy) {
+	    zmemcpy(state->window, strm->next_out - copy, copy);
+	    state->write = copy;
+	    state->whave = state->wsize;
+	}
+	else {
+	    state->write += dist;
+	    if (state->write == state->wsize) state->write = 0;
+	    if (state->whave < state->wsize) state->whave += dist;
+	}
     }
     return 0;
 }
@@ -1269,11 +1269,11 @@ unsigned out;
     for (;;) switch (state) {
     ...
     case STATEn:
-        if (not enough input data or output space to make progress)
-            return;
-        ... make progress ...
-        state = STATEm;
-        break;
+	if (not enough input data or output space to make progress)
+	    return;
+	... make progress ...
+	state = STATEm;
+	break;
     ...
     }
 
@@ -1284,9 +1284,9 @@ unsigned out;
    the requested bits are not available.  The typical use of the BITS macros
    is:
 
-        NEEDBITS(n);
-        ... do something with BITS(n) ...
-        DROPBITS(n);
+	NEEDBITS(n);
+	... do something with BITS(n) ...
+	DROPBITS(n);
 
    where NEEDBITS(n) either returns from inflate() if there isn't enough
    input left to load n bits into the accumulator, or it continues.  BITS(n)
@@ -1308,12 +1308,12 @@ unsigned out;
    returns:
 
     case STATEw:
-        while (want < need) {
-            NEEDBITS(n);
-            keep[want++] = BITS(n);
-            DROPBITS(n);
-        }
-        state = STATEx;
+	while (want < need) {
+	    NEEDBITS(n);
+	    keep[want++] = BITS(n);
+	    DROPBITS(n);
+	}
+	state = STATEx;
     case STATEx:
 
    As shown above, if the next state is also the next case, then the break
@@ -1363,11 +1363,11 @@ int flush;
     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
 #endif
     static const unsigned short order[19] = /* permutation of code lengths */
-        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+	{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 
     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
-        (strm->next_in == Z_NULL && strm->avail_in != 0))
-        return Z_STREAM_ERROR;
+	(strm->next_in == Z_NULL && strm->avail_in != 0))
+	return Z_STREAM_ERROR;
 
     state = (struct inflate_state FAR *)strm->state;
     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
@@ -1376,544 +1376,544 @@ int flush;
     out = left;
     ret = Z_OK;
     for (;;)
-        switch (state->mode) {
-        case HEAD:
-            if (state->wrap == 0) {
-                state->mode = TYPEDO;
-                break;
-            }
-            NEEDBITS(16);
+	switch (state->mode) {
+	case HEAD:
+	    if (state->wrap == 0) {
+		state->mode = TYPEDO;
+		break;
+	    }
+	    NEEDBITS(16);
 #ifdef GUNZIP
-            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
-                state->check = crc32(0L, Z_NULL, 0);
-                CRC2(state->check, hold);
-                INITBITS();
-                state->mode = FLAGS;
-                break;
-            }
-            state->flags = 0;           /* expect zlib header */
-            if (state->head != Z_NULL)
-                state->head->done = -1;
-            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+	    if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+		state->check = crc32(0L, Z_NULL, 0);
+		CRC2(state->check, hold);
+		INITBITS();
+		state->mode = FLAGS;
+		break;
+	    }
+	    state->flags = 0;           /* expect zlib header */
+	    if (state->head != Z_NULL)
+		state->head->done = -1;
+	    if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 #else
-            if (
+	    if (
 #endif
-                ((BITS(8) << 8) + (hold >> 8)) % 31) {
-                strm->msg = (char *)"incorrect header check";
-                state->mode = BAD;
-                break;
-            }
-            if (BITS(4) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            DROPBITS(4);
-            len = BITS(4) + 8;
-            if (len > state->wbits) {
-                strm->msg = (char *)"invalid window size";
-                state->mode = BAD;
-                break;
-            }
-            state->dmax = 1U << len;
-            Tracev((stderr, "inflate:   zlib header ok\n"));
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = hold & 0x200 ? DICTID : TYPE;
-            INITBITS();
-            break;
+		((BITS(8) << 8) + (hold >> 8)) % 31) {
+		strm->msg = (char *)"incorrect header check";
+		state->mode = BAD;
+		break;
+	    }
+	    if (BITS(4) != Z_DEFLATED) {
+		strm->msg = (char *)"unknown compression method";
+		state->mode = BAD;
+		break;
+	    }
+	    DROPBITS(4);
+	    len = BITS(4) + 8;
+	    if (len > state->wbits) {
+		strm->msg = (char *)"invalid window size";
+		state->mode = BAD;
+		break;
+	    }
+	    state->dmax = 1U << len;
+	    Tracev((stderr, "inflate:   zlib header ok\n"));
+	    strm->adler = state->check = adler32(0L, Z_NULL, 0);
+	    state->mode = hold & 0x200 ? DICTID : TYPE;
+	    INITBITS();
+	    break;
 #ifdef GUNZIP
-        case FLAGS:
-            NEEDBITS(16);
-            state->flags = (int)(hold);
-            if ((state->flags & 0xff) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            if (state->flags & 0xe000) {
-                strm->msg = (char *)"unknown header flags set";
-                state->mode = BAD;
-                break;
-            }
-            if (state->head != Z_NULL)
-                state->head->text = (int)((hold >> 8) & 1);
-            if (state->flags & 0x0200) CRC2(state->check, hold);
-            INITBITS();
-            state->mode = TIME;
-        case TIME:
-            NEEDBITS(32);
-            if (state->head != Z_NULL)
-                state->head->time = hold;
-            if (state->flags & 0x0200) CRC4(state->check, hold);
-            INITBITS();
-            state->mode = OS;
-        case OS:
-            NEEDBITS(16);
-            if (state->head != Z_NULL) {
-                state->head->xflags = (int)(hold & 0xff);
-                state->head->os = (int)(hold >> 8);
-            }
-            if (state->flags & 0x0200) CRC2(state->check, hold);
-            INITBITS();
-            state->mode = EXLEN;
-        case EXLEN:
-            if (state->flags & 0x0400) {
-                NEEDBITS(16);
-                state->length = (unsigned)(hold);
-                if (state->head != Z_NULL)
-                    state->head->extra_len = (unsigned)hold;
-                if (state->flags & 0x0200) CRC2(state->check, hold);
-                INITBITS();
-            }
-            else if (state->head != Z_NULL)
-                state->head->extra = Z_NULL;
-            state->mode = EXTRA;
-        case EXTRA:
-            if (state->flags & 0x0400) {
-                copy = state->length;
-                if (copy > have) copy = have;
-                if (copy) {
-                    if (state->head != Z_NULL &&
-                        state->head->extra != Z_NULL) {
-                        len = state->head->extra_len - state->length;
-                        zmemcpy(state->head->extra + len, next,
-                                len + copy > state->head->extra_max ?
-                                state->head->extra_max - len : copy);
-                    }
-                    if (state->flags & 0x0200)
-                        state->check = crc32(state->check, next, copy);
-                    have -= copy;
-                    next += copy;
-                    state->length -= copy;
-                }
-                if (state->length) goto inf_leave;
-            }
-            state->length = 0;
-            state->mode = NAME;
-        case NAME:
-            if (state->flags & 0x0800) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL &&
-                            state->head->name != Z_NULL &&
-                            state->length < state->head->name_max)
-                        state->head->name[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len) goto inf_leave;
-            }
-            else if (state->head != Z_NULL)
-                state->head->name = Z_NULL;
-            state->length = 0;
-            state->mode = COMMENT;
-        case COMMENT:
-            if (state->flags & 0x1000) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL &&
-                            state->head->comment != Z_NULL &&
-                            state->length < state->head->comm_max)
-                        state->head->comment[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len) goto inf_leave;
-            }
-            else if (state->head != Z_NULL)
-                state->head->comment = Z_NULL;
-            state->mode = HCRC;
-        case HCRC:
-            if (state->flags & 0x0200) {
-                NEEDBITS(16);
-                if (hold != (state->check & 0xffff)) {
-                    strm->msg = (char *)"header crc mismatch";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-            }
-            if (state->head != Z_NULL) {
-                state->head->hcrc = (int)((state->flags >> 9) & 1);
-                state->head->done = 1;
-            }
-            strm->adler = state->check = crc32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-            break;
+	case FLAGS:
+	    NEEDBITS(16);
+	    state->flags = (int)(hold);
+	    if ((state->flags & 0xff) != Z_DEFLATED) {
+		strm->msg = (char *)"unknown compression method";
+		state->mode = BAD;
+		break;
+	    }
+	    if (state->flags & 0xe000) {
+		strm->msg = (char *)"unknown header flags set";
+		state->mode = BAD;
+		break;
+	    }
+	    if (state->head != Z_NULL)
+		state->head->text = (int)((hold >> 8) & 1);
+	    if (state->flags & 0x0200) CRC2(state->check, hold);
+	    INITBITS();
+	    state->mode = TIME;
+	case TIME:
+	    NEEDBITS(32);
+	    if (state->head != Z_NULL)
+		state->head->time = hold;
+	    if (state->flags & 0x0200) CRC4(state->check, hold);
+	    INITBITS();
+	    state->mode = OS;
+	case OS:
+	    NEEDBITS(16);
+	    if (state->head != Z_NULL) {
+		state->head->xflags = (int)(hold & 0xff);
+		state->head->os = (int)(hold >> 8);
+	    }
+	    if (state->flags & 0x0200) CRC2(state->check, hold);
+	    INITBITS();
+	    state->mode = EXLEN;
+	case EXLEN:
+	    if (state->flags & 0x0400) {
+		NEEDBITS(16);
+		state->length = (unsigned)(hold);
+		if (state->head != Z_NULL)
+		    state->head->extra_len = (unsigned)hold;
+		if (state->flags & 0x0200) CRC2(state->check, hold);
+		INITBITS();
+	    }
+	    else if (state->head != Z_NULL)
+		state->head->extra = Z_NULL;
+	    state->mode = EXTRA;
+	case EXTRA:
+	    if (state->flags & 0x0400) {
+		copy = state->length;
+		if (copy > have) copy = have;
+		if (copy) {
+		    if (state->head != Z_NULL &&
+			state->head->extra != Z_NULL) {
+			len = state->head->extra_len - state->length;
+			zmemcpy(state->head->extra + len, next,
+				len + copy > state->head->extra_max ?
+				state->head->extra_max - len : copy);
+		    }
+		    if (state->flags & 0x0200)
+			state->check = crc32(state->check, next, copy);
+		    have -= copy;
+		    next += copy;
+		    state->length -= copy;
+		}
+		if (state->length) goto inf_leave;
+	    }
+	    state->length = 0;
+	    state->mode = NAME;
+	case NAME:
+	    if (state->flags & 0x0800) {
+		if (have == 0) goto inf_leave;
+		copy = 0;
+		do {
+		    len = (unsigned)(next[copy++]);
+		    if (state->head != Z_NULL &&
+			    state->head->name != Z_NULL &&
+			    state->length < state->head->name_max)
+			state->head->name[state->length++] = len;
+		} while (len && copy < have);
+		if (state->flags & 0x0200)
+		    state->check = crc32(state->check, next, copy);
+		have -= copy;
+		next += copy;
+		if (len) goto inf_leave;
+	    }
+	    else if (state->head != Z_NULL)
+		state->head->name = Z_NULL;
+	    state->length = 0;
+	    state->mode = COMMENT;
+	case COMMENT:
+	    if (state->flags & 0x1000) {
+		if (have == 0) goto inf_leave;
+		copy = 0;
+		do {
+		    len = (unsigned)(next[copy++]);
+		    if (state->head != Z_NULL &&
+			    state->head->comment != Z_NULL &&
+			    state->length < state->head->comm_max)
+			state->head->comment[state->length++] = len;
+		} while (len && copy < have);
+		if (state->flags & 0x0200)
+		    state->check = crc32(state->check, next, copy);
+		have -= copy;
+		next += copy;
+		if (len) goto inf_leave;
+	    }
+	    else if (state->head != Z_NULL)
+		state->head->comment = Z_NULL;
+	    state->mode = HCRC;
+	case HCRC:
+	    if (state->flags & 0x0200) {
+		NEEDBITS(16);
+		if (hold != (state->check & 0xffff)) {
+		    strm->msg = (char *)"header crc mismatch";
+		    state->mode = BAD;
+		    break;
+		}
+		INITBITS();
+	    }
+	    if (state->head != Z_NULL) {
+		state->head->hcrc = (int)((state->flags >> 9) & 1);
+		state->head->done = 1;
+	    }
+	    strm->adler = state->check = crc32(0L, Z_NULL, 0);
+	    state->mode = TYPE;
+	    break;
 #endif
-        case DICTID:
-            NEEDBITS(32);
-            strm->adler = state->check = REVERSE(hold);
-            INITBITS();
-            state->mode = DICT;
-        case DICT:
-            if (state->havedict == 0) {
-                RESTORE();
-                return Z_NEED_DICT;
-            }
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-        case TYPE:
-            if (flush == Z_BLOCK) goto inf_leave;
-        case TYPEDO:
-            if (state->last) {
-                BYTEBITS();
-                state->mode = CHECK;
-                break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-            case 0:                             /* stored block */
-                Tracev((stderr, "inflate:     stored block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = STORED;
-                break;
-            case 1:                             /* fixed block */
-                fixedtables(state);
-                Tracev((stderr, "inflate:     fixed codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = LEN;              /* decode codes */
-                break;
-            case 2:                             /* dynamic block */
-                Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = TABLE;
-                break;
-            case 3:
-                strm->msg = (char *)"invalid block type";
-                state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-        case STORED:
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
-                state->mode = BAD;
-                break;
-            }
-            state->length = (unsigned)hold & 0xffff;
-            Tracev((stderr, "inflate:       stored length %u\n",
-                    state->length));
-            INITBITS();
-            state->mode = COPY;
-        case COPY:
-            copy = state->length;
-            if (copy) {
-                if (copy > have) copy = have;
-                if (copy > left) copy = left;
-                if (copy == 0) goto inf_leave;
-                zmemcpy(put, next, copy);
-                have -= copy;
-                next += copy;
-                left -= copy;
-                put += copy;
-                state->length -= copy;
-                break;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-        case TABLE:
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
+	case DICTID:
+	    NEEDBITS(32);
+	    strm->adler = state->check = REVERSE(hold);
+	    INITBITS();
+	    state->mode = DICT;
+	case DICT:
+	    if (state->havedict == 0) {
+		RESTORE();
+		return Z_NEED_DICT;
+	    }
+	    strm->adler = state->check = adler32(0L, Z_NULL, 0);
+	    state->mode = TYPE;
+	case TYPE:
+	    if (flush == Z_BLOCK) goto inf_leave;
+	case TYPEDO:
+	    if (state->last) {
+		BYTEBITS();
+		state->mode = CHECK;
+		break;
+	    }
+	    NEEDBITS(3);
+	    state->last = BITS(1);
+	    DROPBITS(1);
+	    switch (BITS(2)) {
+	    case 0:                             /* stored block */
+		Tracev((stderr, "inflate:     stored block%s\n",
+			state->last ? " (last)" : ""));
+		state->mode = STORED;
+		break;
+	    case 1:                             /* fixed block */
+		fixedtables(state);
+		Tracev((stderr, "inflate:     fixed codes block%s\n",
+			state->last ? " (last)" : ""));
+		state->mode = LEN;              /* decode codes */
+		break;
+	    case 2:                             /* dynamic block */
+		Tracev((stderr, "inflate:     dynamic codes block%s\n",
+			state->last ? " (last)" : ""));
+		state->mode = TABLE;
+		break;
+	    case 3:
+		strm->msg = (char *)"invalid block type";
+		state->mode = BAD;
+	    }
+	    DROPBITS(2);
+	    break;
+	case STORED:
+	    BYTEBITS();                         /* go to byte boundary */
+	    NEEDBITS(32);
+	    if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+		strm->msg = (char *)"invalid stored block lengths";
+		state->mode = BAD;
+		break;
+	    }
+	    state->length = (unsigned)hold & 0xffff;
+	    Tracev((stderr, "inflate:       stored length %u\n",
+		    state->length));
+	    INITBITS();
+	    state->mode = COPY;
+	case COPY:
+	    copy = state->length;
+	    if (copy) {
+		if (copy > have) copy = have;
+		if (copy > left) copy = left;
+		if (copy == 0) goto inf_leave;
+		zmemcpy(put, next, copy);
+		have -= copy;
+		next += copy;
+		left -= copy;
+		put += copy;
+		state->length -= copy;
+		break;
+	    }
+	    Tracev((stderr, "inflate:       stored end\n"));
+	    state->mode = TYPE;
+	    break;
+	case TABLE:
+	    NEEDBITS(14);
+	    state->nlen = BITS(5) + 257;
+	    DROPBITS(5);
+	    state->ndist = BITS(5) + 1;
+	    DROPBITS(5);
+	    state->ncode = BITS(4) + 4;
+	    DROPBITS(4);
 #ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
-                state->mode = BAD;
-                break;
-            }
+	    if (state->nlen > 286 || state->ndist > 30) {
+		strm->msg = (char *)"too many length or distance symbols";
+		state->mode = BAD;
+		break;
+	    }
 #endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-            state->have = 0;
-            state->mode = LENLENS;
-        case LENLENS:
-            while (state->have < state->ncode) {
-                NEEDBITS(3);
-                state->lens[order[state->have++]] = (unsigned short)BITS(3);
-                DROPBITS(3);
-            }
-            while (state->have < 19)
-                state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-            state->have = 0;
-            state->mode = CODELENS;
-        case CODELENS:
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
-                    this = state->lencode[BITS(state->lenbits)];
-                    if ((unsigned)(this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                if (this.val < 16) {
-                    NEEDBITS(this.bits);
-                    DROPBITS(this.bits);
-                    state->lens[state->have++] = this.val;
-                }
-                else {
-                    if (this.val == 16) {
-                        NEEDBITS(this.bits + 2);
-                        DROPBITS(this.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
-                            state->mode = BAD;
-                            break;
-                        }
-                        len = state->lens[state->have - 1];
-                        copy = 3 + BITS(2);
-                        DROPBITS(2);
-                    }
-                    else if (this.val == 17) {
-                        NEEDBITS(this.bits + 3);
-                        DROPBITS(this.bits);
-                        len = 0;
-                        copy = 3 + BITS(3);
-                        DROPBITS(3);
-                    }
-                    else {
-                        NEEDBITS(this.bits + 7);
-                        DROPBITS(this.bits);
-                        len = 0;
-                        copy = 11 + BITS(7);
-                        DROPBITS(7);
-                    }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                    }
-                    while (copy--)
-                        state->lens[state->have++] = (unsigned short)len;
-                }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD) break;
-
-            /* build code tables */
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
-                state->mode = BAD;
-                break;
-            }
-            state->distcode = (code const FAR *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                            &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN;
-        case LEN:
-            if (have >= 6 && left >= 258) {
-                RESTORE();
-                inflate_fast(strm, out);
-                LOAD();
-                break;
-            }
-            for (;;) {
-                this = state->lencode[BITS(state->lenbits)];
-                if ((unsigned)(this.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if (this.op && (this.op & 0xf0) == 0) {
-                last = this;
-                for (;;) {
-                    this = state->lencode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(this.bits);
-            state->length = (unsigned)this.val;
-            if ((int)(this.op) == 0) {
-                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", this.val));
-                state->mode = LIT;
-                break;
-            }
-            if (this.op & 32) {
-                Tracevv((stderr, "inflate:         end of block\n"));
-                state->mode = TYPE;
-                break;
-            }
-            if (this.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
-                state->mode = BAD;
-                break;
-            }
-            state->extra = (unsigned)(this.op) & 15;
-            state->mode = LENEXT;
-        case LENEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->length += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-            state->mode = DIST;
-        case DIST:
-            for (;;) {
-                this = state->distcode[BITS(state->distbits)];
-                if ((unsigned)(this.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if ((this.op & 0xf0) == 0) {
-                last = this;
-                for (;;) {
-                    this = state->distcode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(this.bits);
-            if (this.op & 64) {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-            state->offset = (unsigned)this.val;
-            state->extra = (unsigned)(this.op) & 15;
-            state->mode = DISTEXT;
-        case DISTEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->offset += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
+	    Tracev((stderr, "inflate:       table sizes ok\n"));
+	    state->have = 0;
+	    state->mode = LENLENS;
+	case LENLENS:
+	    while (state->have < state->ncode) {
+		NEEDBITS(3);
+		state->lens[order[state->have++]] = (unsigned short)BITS(3);
+		DROPBITS(3);
+	    }
+	    while (state->have < 19)
+		state->lens[order[state->have++]] = 0;
+	    state->next = state->codes;
+	    state->lencode = (code const FAR *)(state->next);
+	    state->lenbits = 7;
+	    ret = inflate_table(CODES, state->lens, 19, &(state->next),
+				&(state->lenbits), state->work);
+	    if (ret) {
+		strm->msg = (char *)"invalid code lengths set";
+		state->mode = BAD;
+		break;
+	    }
+	    Tracev((stderr, "inflate:       code lengths ok\n"));
+	    state->have = 0;
+	    state->mode = CODELENS;
+	case CODELENS:
+	    while (state->have < state->nlen + state->ndist) {
+		for (;;) {
+		    this = state->lencode[BITS(state->lenbits)];
+		    if ((unsigned)(this.bits) <= bits) break;
+		    PULLBYTE();
+		}
+		if (this.val < 16) {
+		    NEEDBITS(this.bits);
+		    DROPBITS(this.bits);
+		    state->lens[state->have++] = this.val;
+		}
+		else {
+		    if (this.val == 16) {
+			NEEDBITS(this.bits + 2);
+			DROPBITS(this.bits);
+			if (state->have == 0) {
+			    strm->msg = (char *)"invalid bit length repeat";
+			    state->mode = BAD;
+			    break;
+			}
+			len = state->lens[state->have - 1];
+			copy = 3 + BITS(2);
+			DROPBITS(2);
+		    }
+		    else if (this.val == 17) {
+			NEEDBITS(this.bits + 3);
+			DROPBITS(this.bits);
+			len = 0;
+			copy = 3 + BITS(3);
+			DROPBITS(3);
+		    }
+		    else {
+			NEEDBITS(this.bits + 7);
+			DROPBITS(this.bits);
+			len = 0;
+			copy = 11 + BITS(7);
+			DROPBITS(7);
+		    }
+		    if (state->have + copy > state->nlen + state->ndist) {
+			strm->msg = (char *)"invalid bit length repeat";
+			state->mode = BAD;
+			break;
+		    }
+		    while (copy--)
+			state->lens[state->have++] = (unsigned short)len;
+		}
+	    }
+
+	    /* handle error breaks in while */
+	    if (state->mode == BAD) break;
+
+	    /* build code tables */
+	    state->next = state->codes;
+	    state->lencode = (code const FAR *)(state->next);
+	    state->lenbits = 9;
+	    ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+				&(state->lenbits), state->work);
+	    if (ret) {
+		strm->msg = (char *)"invalid literal/lengths set";
+		state->mode = BAD;
+		break;
+	    }
+	    state->distcode = (code const FAR *)(state->next);
+	    state->distbits = 6;
+	    ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+			    &(state->next), &(state->distbits), state->work);
+	    if (ret) {
+		strm->msg = (char *)"invalid distances set";
+		state->mode = BAD;
+		break;
+	    }
+	    Tracev((stderr, "inflate:       codes ok\n"));
+	    state->mode = LEN;
+	case LEN:
+	    if (have >= 6 && left >= 258) {
+		RESTORE();
+		inflate_fast(strm, out);
+		LOAD();
+		break;
+	    }
+	    for (;;) {
+		this = state->lencode[BITS(state->lenbits)];
+		if ((unsigned)(this.bits) <= bits) break;
+		PULLBYTE();
+	    }
+	    if (this.op && (this.op & 0xf0) == 0) {
+		last = this;
+		for (;;) {
+		    this = state->lencode[last.val +
+			    (BITS(last.bits + last.op) >> last.bits)];
+		    if ((unsigned)(last.bits + this.bits) <= bits) break;
+		    PULLBYTE();
+		}
+		DROPBITS(last.bits);
+	    }
+	    DROPBITS(this.bits);
+	    state->length = (unsigned)this.val;
+	    if ((int)(this.op) == 0) {
+		Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+			"inflate:         literal '%c'\n" :
+			"inflate:         literal 0x%02x\n", this.val));
+		state->mode = LIT;
+		break;
+	    }
+	    if (this.op & 32) {
+		Tracevv((stderr, "inflate:         end of block\n"));
+		state->mode = TYPE;
+		break;
+	    }
+	    if (this.op & 64) {
+		strm->msg = (char *)"invalid literal/length code";
+		state->mode = BAD;
+		break;
+	    }
+	    state->extra = (unsigned)(this.op) & 15;
+	    state->mode = LENEXT;
+	case LENEXT:
+	    if (state->extra) {
+		NEEDBITS(state->extra);
+		state->length += BITS(state->extra);
+		DROPBITS(state->extra);
+	    }
+	    Tracevv((stderr, "inflate:         length %u\n", state->length));
+	    state->mode = DIST;
+	case DIST:
+	    for (;;) {
+		this = state->distcode[BITS(state->distbits)];
+		if ((unsigned)(this.bits) <= bits) break;
+		PULLBYTE();
+	    }
+	    if ((this.op & 0xf0) == 0) {
+		last = this;
+		for (;;) {
+		    this = state->distcode[last.val +
+			    (BITS(last.bits + last.op) >> last.bits)];
+		    if ((unsigned)(last.bits + this.bits) <= bits) break;
+		    PULLBYTE();
+		}
+		DROPBITS(last.bits);
+	    }
+	    DROPBITS(this.bits);
+	    if (this.op & 64) {
+		strm->msg = (char *)"invalid distance code";
+		state->mode = BAD;
+		break;
+	    }
+	    state->offset = (unsigned)this.val;
+	    state->extra = (unsigned)(this.op) & 15;
+	    state->mode = DISTEXT;
+	case DISTEXT:
+	    if (state->extra) {
+		NEEDBITS(state->extra);
+		state->offset += BITS(state->extra);
+		DROPBITS(state->extra);
+	    }
 #ifdef INFLATE_STRICT
-            if (state->offset > state->dmax) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
+	    if (state->offset > state->dmax) {
+		strm->msg = (char *)"invalid distance too far back";
+		state->mode = BAD;
+		break;
+	    }
 #endif
-            if (state->offset > state->whave + out - left) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-            state->mode = MATCH;
-        case MATCH:
-            if (left == 0) goto inf_leave;
-            copy = out - left;
-            if (state->offset > copy) {         /* copy from window */
-                copy = state->offset - copy;
-                if (copy > state->write) {
-                    copy -= state->write;
-                    from = state->window + (state->wsize - copy);
-                }
-                else
-                    from = state->window + (state->write - copy);
-                if (copy > state->length) copy = state->length;
-            }
-            else {                              /* copy from output */
-                from = put - state->offset;
-                copy = state->length;
-            }
-            if (copy > left) copy = left;
-            left -= copy;
-            state->length -= copy;
-            do {
-                *put++ = *from++;
-            } while (--copy);
-            if (state->length == 0) state->mode = LEN;
-            break;
-        case LIT:
-            if (left == 0) goto inf_leave;
-            *put++ = (unsigned char)(state->length);
-            left--;
-            state->mode = LEN;
-            break;
-        case CHECK:
-            if (state->wrap) {
-                NEEDBITS(32);
-                out -= left;
-                strm->total_out += out;
-                state->total += out;
-                if (out)
-                    strm->adler = state->check =
-                        UPDATE(state->check, put - out, out);
-                out = left;
-                if ((
+	    if (state->offset > state->whave + out - left) {
+		strm->msg = (char *)"invalid distance too far back";
+		state->mode = BAD;
+		break;
+	    }
+	    Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+	    state->mode = MATCH;
+	case MATCH:
+	    if (left == 0) goto inf_leave;
+	    copy = out - left;
+	    if (state->offset > copy) {         /* copy from window */
+		copy = state->offset - copy;
+		if (copy > state->write) {
+		    copy -= state->write;
+		    from = state->window + (state->wsize - copy);
+		}
+		else
+		    from = state->window + (state->write - copy);
+		if (copy > state->length) copy = state->length;
+	    }
+	    else {                              /* copy from output */
+		from = put - state->offset;
+		copy = state->length;
+	    }
+	    if (copy > left) copy = left;
+	    left -= copy;
+	    state->length -= copy;
+	    do {
+		*put++ = *from++;
+	    } while (--copy);
+	    if (state->length == 0) state->mode = LEN;
+	    break;
+	case LIT:
+	    if (left == 0) goto inf_leave;
+	    *put++ = (unsigned char)(state->length);
+	    left--;
+	    state->mode = LEN;
+	    break;
+	case CHECK:
+	    if (state->wrap) {
+		NEEDBITS(32);
+		out -= left;
+		strm->total_out += out;
+		state->total += out;
+		if (out)
+		    strm->adler = state->check =
+			UPDATE(state->check, put - out, out);
+		out = left;
+		if ((
 #ifdef GUNZIP
-                     state->flags ? hold :
+		     state->flags ? hold :
 #endif
-                     REVERSE(hold)) != state->check) {
-                    strm->msg = (char *)"incorrect data check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   check matches trailer\n"));
-            }
+		     REVERSE(hold)) != state->check) {
+		    strm->msg = (char *)"incorrect data check";
+		    state->mode = BAD;
+		    break;
+		}
+		INITBITS();
+		Tracev((stderr, "inflate:   check matches trailer\n"));
+	    }
 #ifdef GUNZIP
-            state->mode = LENGTH;
-        case LENGTH:
-            if (state->wrap && state->flags) {
-                NEEDBITS(32);
-                if (hold != (state->total & 0xffffffffUL)) {
-                    strm->msg = (char *)"incorrect length check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   length matches trailer\n"));
-            }
+	    state->mode = LENGTH;
+	case LENGTH:
+	    if (state->wrap && state->flags) {
+		NEEDBITS(32);
+		if (hold != (state->total & 0xffffffffUL)) {
+		    strm->msg = (char *)"incorrect length check";
+		    state->mode = BAD;
+		    break;
+		}
+		INITBITS();
+		Tracev((stderr, "inflate:   length matches trailer\n"));
+	    }
 #endif
-            state->mode = DONE;
-        case DONE:
-            ret = Z_STREAM_END;
-            goto inf_leave;
-        case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-        case MEM:
-            return Z_MEM_ERROR;
-        case SYNC:
-        default:
-            return Z_STREAM_ERROR;
-        }
+	    state->mode = DONE;
+	case DONE:
+	    ret = Z_STREAM_END;
+	    goto inf_leave;
+	case BAD:
+	    ret = Z_DATA_ERROR;
+	    goto inf_leave;
+	case MEM:
+	    return Z_MEM_ERROR;
+	case SYNC:
+	default:
+	    return Z_STREAM_ERROR;
+	}
 
     /*
        Return from inflate(), updating the total counts and the check value.
@@ -1924,22 +1924,22 @@ int flush;
   inf_leave:
     RESTORE();
     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
-        if (updatewindow(strm, out)) {
-            state->mode = MEM;
-            return Z_MEM_ERROR;
-        }
+	if (updatewindow(strm, out)) {
+	    state->mode = MEM;
+	    return Z_MEM_ERROR;
+	}
     in -= strm->avail_in;
     out -= strm->avail_out;
     strm->total_in += in;
     strm->total_out += out;
     state->total += out;
     if (state->wrap && out)
-        strm->adler = state->check =
-            UPDATE(state->check, strm->next_out - out, out);
+	strm->adler = state->check =
+	    UPDATE(state->check, strm->next_out - out, out);
     strm->data_type = state->bits + (state->last ? 64 : 0) +
-                      (state->mode == TYPE ? 128 : 0);
+		      (state->mode == TYPE ? 128 : 0);
     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
-        ret = Z_BUF_ERROR;
+	ret = Z_BUF_ERROR;
     return ret;
 }
 
@@ -1948,7 +1948,7 @@ z_streamp strm;
 {
     struct inflate_state FAR *state;
     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
+	return Z_STREAM_ERROR;
     state = (struct inflate_state FAR *)strm->state;
     if (state->window != Z_NULL) ZFREE(strm, state->window);
     ZFREE(strm, strm->state);
@@ -2119,56 +2119,56 @@ uLong ZEXPORT adler32(adler, buf, len)
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (len == 1) {
-        adler += buf[0];
-        if (adler >= BASE)
-            adler -= BASE;
-        sum2 += adler;
-        if (sum2 >= BASE)
-            sum2 -= BASE;
-        return adler | (sum2 << 16);
+	adler += buf[0];
+	if (adler >= BASE)
+	    adler -= BASE;
+	sum2 += adler;
+	if (sum2 >= BASE)
+	    sum2 -= BASE;
+	return adler | (sum2 << 16);
     }
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (buf == Z_NULL)
-        return 1L;
+	return 1L;
 
     /* in case short lengths are provided, keep it somewhat fast */
     if (len < 16) {
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        if (adler >= BASE)
-            adler -= BASE;
-        MOD4(sum2);             /* only added so many BASE's */
-        return adler | (sum2 << 16);
+	while (len--) {
+	    adler += *buf++;
+	    sum2 += adler;
+	}
+	if (adler >= BASE)
+	    adler -= BASE;
+	MOD4(sum2);             /* only added so many BASE's */
+	return adler | (sum2 << 16);
     }
 
     /* do length NMAX blocks -- requires just one modulo operation */
     while (len >= NMAX) {
-        len -= NMAX;
-        n = NMAX / 16;          /* NMAX is divisible by 16 */
-        do {
-            DO16(buf);          /* 16 sums unrolled */
-            buf += 16;
-        } while (--n);
-        MOD(adler);
-        MOD(sum2);
+	len -= NMAX;
+	n = NMAX / 16;          /* NMAX is divisible by 16 */
+	do {
+	    DO16(buf);          /* 16 sums unrolled */
+	    buf += 16;
+	} while (--n);
+	MOD(adler);
+	MOD(sum2);
     }
 
     /* do remaining bytes (less than NMAX, still just one modulo) */
     if (len) {                  /* avoid modulos if none remaining */
-        while (len >= 16) {
-            len -= 16;
-            DO16(buf);
-            buf += 16;
-        }
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        MOD(adler);
-        MOD(sum2);
+	while (len >= 16) {
+	    len -= 16;
+	    DO16(buf);
+	    buf += 16;
+	}
+	while (len--) {
+	    adler += *buf++;
+	    sum2 += adler;
+	}
+	MOD(adler);
+	MOD(sum2);
     }
 
     /* return recombined sums */