diff --git a/ChangeLog b/ChangeLog
index e97948e..57f9986 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,14 @@
 		ChangeLog file for zlib
 
+Changes in 0.92 (3 May 95)
+- don't assume that char is signed (problem on SGI)
+- Clear bit buffer when starting a stored block
+- no memcpy on Pyramid
+- suppressed inftest.c
+- optimized fill_window, put longest_match inline for gcc
+- optimized inflate on stored blocks.
+- untabify all sources to simplify patches
+
 Changes in 0.91 (2 May 95)
 - Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
 - Document the memory requirements in zconf.h
diff --git a/Makefile b/Makefile
index 9a48249..2d0cdc7 100644
--- a/Makefile
+++ b/Makefile
@@ -4,6 +4,7 @@
 
 CC=cc
 CFLAGS=-O
+#use -O3 for gcc to take advantage of inlining
 #CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
 #CFLAGS=-g -DDEBUG
 LDFLAGS=-L. -lgz
@@ -15,9 +16,9 @@
 OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
        zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o
 
-TEST_OBJS = example.o minigzip.o inftest.o
+TEST_OBJS = example.o minigzip.o
 
-all: example minigzip inftest
+all: example minigzip
 
 test: all
 	./example
@@ -41,11 +42,8 @@
 minigzip: minigzip.o libgz.a
 	$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
 
-inftest: inftest.o libgz.a
-	$(CC) $(CFLAGS) -o $@ inftest.o $(LDFLAGS)
-
 clean:
-	rm -f *.o example minigzip inftest libgz.a foo.gz
+	rm -f *.o example minigzip libgz.a foo.gz
 
 zip:
 	zip -ul9 zlib README ChangeLog Makefile Makefile.??? Makefile.?? *.[ch]
@@ -66,7 +64,6 @@
 infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h
 inffast.o: zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h
 inflate.o: zutil.h zlib.h zconf.h infblock.h
-inftest.o: zutil.h zlib.h zconf.h
 inftrees.o: zutil.h zlib.h zconf.h inftrees.h
 infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h
 minigzip.o: zlib.h zconf.h
diff --git a/README b/README
index caeccb9..bc4a663 100644
--- a/README
+++ b/README
@@ -1,4 +1,4 @@
-zlib 0.91 is a beta version of a general purpose compression library.
+zlib 0.92 is a beta version of a general purpose compression library.
 
 The data format used by the zlib library is described in the
 files zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
@@ -14,12 +14,15 @@
 To install in a different directory, use for example: make install prefix=$HOME
 This will install in $HOME/lib instead of /usr/local/lib.
 
-The changes made in version 0.91 are documented in the file ChangeLog.
+The changes made in version 0.92 are documented in the file ChangeLog.
 The main changes since 0.9 are:
+- don't assume that char is signed (problem on SGI)
 - Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
 - Document the memory requirements in zconf.h
 - added "make install"
-- added support for DJGPP
+- added support for DJGPP and Pyramid
+- fix an inflate bug for stored blocks.
+- various speedups
 
 On MSDOS, this version works in both large and small model. However
 small model compression works only for small values of MAX_MEM_LEVEL
diff --git a/adler32.c b/adler32.c
index 0b2b820..0ad9bec 100644
--- a/adler32.c
+++ b/adler32.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: adler32.c,v 1.5 1995/04/14 14:49:51 jloup Exp $ */
+/* $Id: adler32.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */
 
 #include "zutil.h"
 
@@ -30,17 +30,17 @@
     if (buf == Z_NULL) return 1L;
 
     while (len > 0) {
-	k = len < NMAX ? len : NMAX;
-	len -= k;
-	while (k >= 16) {
-	    DO16(buf);
-	    k -= 16;
-	}
-	if (k != 0) do {
-	    DO1(buf);
-	} while (--k);
-	s1 %= BASE;
-	s2 %= BASE;
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+            k -= 16;
+        }
+        if (k != 0) do {
+            DO1(buf);
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
     }
     return (s2 << 16) | s1;
 }
diff --git a/compress.c b/compress.c
index 762a9df..98ced3e 100644
--- a/compress.c
+++ b/compress.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: compress.c,v 1.5 1995/04/29 17:18:43 jloup Exp $ */
+/* $Id: compress.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */
 
 #include "zlib.h"
 
@@ -45,8 +45,8 @@
 
     err = deflate(&stream, Z_FINISH);
     if (err != Z_STREAM_END) {
-	deflateEnd(&stream);
-	return err == Z_OK ? Z_BUF_ERROR : err;
+        deflateEnd(&stream);
+        return err == Z_OK ? Z_BUF_ERROR : err;
     }
     *destLen = stream.total_out;
 
diff --git a/deflate.c b/deflate.c
index b65ba25..6c0cd0a 100644
--- a/deflate.c
+++ b/deflate.c
@@ -47,7 +47,7 @@
  *
  */
 
-/* $Id: deflate.c,v 1.7 1995/05/02 13:28:18 jloup Exp $ */
+/* $Id: deflate.c,v 1.8 1995/05/03 17:27:08 jloup Exp $ */
 
 #include "deflate.h"
 
@@ -127,7 +127,7 @@
 
 #ifdef DEBUG
 local  void check_match __P((deflate_state *s, IPos start, IPos match,
-			     int length));
+                             int length));
 #endif
 
 
@@ -190,12 +190,12 @@
     if (level == Z_DEFAULT_COMPRESSION) level = 6;
 
     if (windowBits < 0) { /* undocumented feature: suppress zlib header */
-	noheader = 1;
-	windowBits = -windowBits;
+        noheader = 1;
+        windowBits = -windowBits;
     }
     if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != DEFLATED ||
-	windowBits < 8 || windowBits > 15 || level < 1 || level > 9) {
-	return Z_STREAM_ERROR;
+        windowBits < 8 || windowBits > 15 || level < 1 || level > 9) {
+        return Z_STREAM_ERROR;
     }
     s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
     if (s == Z_NULL) return Z_MEM_ERROR;
@@ -221,10 +221,10 @@
     s->pending_buf = (uch*) ZALLOC(strm, s->lit_bufsize, 2*sizeof(ush));
 
     if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
-	s->pending_buf == Z_NULL) {
-	strm->msg = z_errmsg[1-Z_MEM_ERROR];
-	deflateEnd (strm);
-	return Z_MEM_ERROR;
+        s->pending_buf == Z_NULL) {
+        strm->msg = z_errmsg[1-Z_MEM_ERROR];
+        deflateEnd (strm);
+        return Z_MEM_ERROR;
     }
     s->d_buf = (ush*) &(s->pending_buf[s->lit_bufsize]);
     s->l_buf = (uch*) &(s->pending_buf[3*s->lit_bufsize]);
@@ -247,7 +247,7 @@
     deflate_state *s;
     
     if (strm == Z_NULL || strm->state == Z_NULL ||
-	strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
+        strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
 
     strm->total_in = strm->total_out = 0;
     strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
@@ -297,7 +297,7 @@
     strm->avail_out  -= len;
     strm->state->pending -= len;
     if (strm->state->pending == 0) {
-	strm->state->pending_out = strm->state->pending_buf;
+        strm->state->pending_out = strm->state->pending_buf;
     }
 }
 
@@ -309,7 +309,7 @@
     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     
     if (strm->next_out == Z_NULL || strm->next_in == Z_NULL) {
-	ERR_RETURN(strm, Z_STREAM_ERROR);
+        ERR_RETURN(strm, Z_STREAM_ERROR);
     }
     if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
 
@@ -318,49 +318,49 @@
     /* Write the zlib header */
     if (strm->state->status == INIT_STATE) {
 
-	uInt header = (DEFLATED + ((strm->state->w_bits-8)<<4)) << 8;
+        uInt header = (DEFLATED + ((strm->state->w_bits-8)<<4)) << 8;
         uInt level_flags = (strm->state->level-1) >> 1;
 
-	if (level_flags > 3) level_flags = 3;
-	header |= (level_flags << 6);
-	header += 31 - (header % 31);
+        if (level_flags > 3) level_flags = 3;
+        header |= (level_flags << 6);
+        header += 31 - (header % 31);
 
-	strm->state->status = BUSY_STATE;
-	putShortMSB(strm->state, header);
+        strm->state->status = BUSY_STATE;
+        putShortMSB(strm->state, header);
     }
 
     /* Flush as much pending output as possible */
     if (strm->state->pending != 0) {
-	flush_pending(strm);
-	if (strm->avail_out == 0) return Z_OK;
+        flush_pending(strm);
+        if (strm->avail_out == 0) return Z_OK;
     }
 
     /* User must not provide more input after the first FINISH: */
     if (strm->state->status == FINISH_STATE && strm->avail_in != 0) {
-	ERR_RETURN(strm, Z_BUF_ERROR);
+        ERR_RETURN(strm, Z_BUF_ERROR);
     }
 
     /* Start a new block or continue the current one.
      */
     if (strm->avail_in != 0 ||
-	(flush == Z_FINISH && strm->state->status != FINISH_STATE)) {
-	int quit;
-	
-	if (flush == Z_FINISH) {
-	    strm->state->status = FINISH_STATE;
-	}
+        (flush == Z_FINISH && strm->state->status != FINISH_STATE)) {
+        int quit;
+        
+        if (flush == Z_FINISH) {
+            strm->state->status = FINISH_STATE;
+        }
         if (strm->state->level <= 3) {
-	    quit = deflate_fast(strm->state, flush);
-	} else {
-	    quit = deflate_slow(strm->state, flush);
-	}
-	if (flush == Z_FULL_FLUSH) {
-	    ct_stored_block(strm->state, (char*)0, 0L, 0); /* special marker */
-	    flush_pending(strm);
-	    CLEAR_HASH(strm->state);             /* forget history */
-	    if (strm->avail_out == 0) return Z_OK;
-	}
-	if (quit) return Z_OK;
+            quit = deflate_fast(strm->state, flush);
+        } else {
+            quit = deflate_slow(strm->state, flush);
+        }
+        if (flush == Z_FULL_FLUSH) {
+            ct_stored_block(strm->state, (char*)0, 0L, 0); /* special marker */
+            flush_pending(strm);
+            CLEAR_HASH(strm->state);             /* forget history */
+            if (strm->avail_out == 0) return Z_OK;
+        }
+        if (quit) return Z_OK;
     }
     Assert(strm->avail_out > 0, "bug2");
 
@@ -401,13 +401,13 @@
     z_stream *source;
 {
     if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
-	return Z_STREAM_ERROR;
+        return Z_STREAM_ERROR;
     }
     *dest = *source;
     return Z_STREAM_ERROR; /* to be implemented */
 #if 0
     dest->state = (struct internal_state *)
-	(*dest->zalloc)(1, sizeof(deflate_state));
+        (*dest->zalloc)(1, sizeof(deflate_state));
     if (dest->state == Z_NULL) return Z_MEM_ERROR;
 
     *(dest->state) = *(source->state);
@@ -432,7 +432,7 @@
     strm->avail_in  -= len;
 
     if (!strm->state->noheader) {
-	strm->state->adler = adler32(strm->state->adler, strm->next_in, len);
+        strm->state->adler = adler32(strm->state->adler, strm->next_in, len);
     }
     zmemcpy(buf, strm->next_in, len);
     strm->next_in  += len;
@@ -488,7 +488,7 @@
 /* For 80x86 and 680x0, an optimized version will be provided in match.asm or
  * match.S. The code will be functionally equivalent.
  */
-local int longest_match(s, cur_match)
+local INLINE int longest_match(s, cur_match)
     deflate_state *s;
     IPos cur_match;                             /* current match */
 {
@@ -498,10 +498,12 @@
     register int len;                           /* length of current match */
     int best_len = s->prev_length;              /* best match length so far */
     IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-	s->strstart - (IPos)MAX_DIST(s) : NIL;
+        s->strstart - (IPos)MAX_DIST(s) : NIL;
     /* Stop when cur_match becomes <= limit. To simplify the code,
      * we prevent matches with the string of window index 0.
      */
+    Pos *prev = s->prev;
+    uInt wmask = s->w_mask;
 
 #ifdef UNALIGNED_OK
     /* Compare two bytes at a time. Note: this is not always beneficial.
@@ -609,7 +611,7 @@
             scan_end   = scan[best_len];
 #endif
         }
-    } while ((cur_match = s->prev[cur_match & s->w_mask]) > limit
+    } while ((cur_match = prev[cur_match & wmask]) > limit
              && --chain_length != 0);
 
     return best_len;
@@ -634,8 +636,8 @@
         z_error("invalid match");
     }
     if (verbose > 1) {
-	fprintf(stderr,"\\[%d,%d]", start-match, length);
-	do { putc(s->window[start++], stderr); } while (--length != 0);
+        fprintf(stderr,"\\[%d,%d]", start-match, length);
+        do { putc(s->window[start++], stderr); } while (--length != 0);
     }
 }
 #else
@@ -656,14 +658,16 @@
     deflate_state *s;
 {
     register unsigned n, m;
+    register Pos *p;
     unsigned more;    /* Amount of free space at the end of the window. */
+    uInt wsize = s->w_size;
 
     do {
-	more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
 
-	/* Deal with !@#$% 64K limit: */
-	if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
-	    more = s->w_size;
+        /* Deal with !@#$% 64K limit: */
+        if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+            more = wsize;
         } else if (more == (unsigned)(-1)) {
             /* Very unlikely, but possible on 16 bit machine if strstart == 0
              * and lookahead == 1 (input done one byte at time)
@@ -673,30 +677,39 @@
         /* If the window is almost full and there is insufficient lookahead,
          * move the upper half to the lower one to make room in the upper half.
          */
-        } else if (s->strstart >= s->w_size+MAX_DIST(s)) {
+        } else if (s->strstart >= wsize+MAX_DIST(s)) {
 
             /* By the IN assertion, the window is not empty so we can't confuse
              * more == 0 with more == 64K on a 16 bit machine.
              */
-            memcpy((char*)s->window, (char*)s->window+s->w_size,
-		   (unsigned)s->w_size);
-            s->match_start -= s->w_size;
-            s->strstart    -= s->w_size; /* we now have strstart >= MAX_DIST */
+            zmemcpy((char*)s->window, (char*)s->window+wsize,
+                   (unsigned)wsize);
+            s->match_start -= wsize;
+            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
 
-            s->block_start -= (long) s->w_size;
+            s->block_start -= (long) wsize;
 
-            for (n = 0; n < s->hash_size; n++) {
-                m = s->head[n];
-                s->head[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL);
-            }
-            for (n = 0; n < s->w_size; n++) {
-                m = s->prev[n];
-                s->prev[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL);
+            /* Slide the hash table (could be avoided with 32 bit values
+               at the expense of memory usage):
+             */
+            n = s->hash_size;
+            p = &s->head[n-1];
+            do {
+                m = *p;
+                *p-- = (Pos)(m >= wsize ? m-wsize : NIL);
+            } while (--n);
+
+            n = wsize;
+            p = &s->prev[n-1];
+            do {
+                m = *p;
+                *p-- = (Pos)(m >= wsize ? m-wsize : NIL);
                 /* If n is not on any hash chain, prev[n] is garbage but
                  * its value will never be used.
                  */
-            }
-            more += s->w_size;
+            } while (--n);
+
+            more += wsize;
         }
         if (s->strm->avail_in == 0) return;
 
@@ -714,8 +727,8 @@
         Assert(more >= 2, "more < 2");
 
         n = read_buf(s->strm, (char*)s->window + s->strstart + s->lookahead,
-		     more);
-	s->lookahead += n;
+                     more);
+        s->lookahead += n;
 
     } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
 }
@@ -726,7 +739,7 @@
  */
 #define FLUSH_BLOCK_ONLY(s, eof) { \
    ct_flush_block(s, (s->block_start >= 0L ? \
-	       (char*)&s->window[(unsigned)s->block_start] : \
+               (char*)&s->window[(unsigned)s->block_start] : \
                (char*)Z_NULL), (long)s->strstart - s->block_start, (eof)); \
    s->block_start = s->strstart; \
    flush_pending(s->strm); \
@@ -761,11 +774,11 @@
          * string following the next match.
          */
         if (s->lookahead < MIN_LOOKAHEAD) {
-	    fill_window(s);
-	    if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
 
-	    if (s->lookahead == 0) break; /* flush the current block */
-	}
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
 
         /* Insert the string window[strstart .. strstart+2] in the
          * dictionary, and set hash_head to the head of the hash chain:
@@ -780,9 +793,9 @@
              * of window index 0 (in particular we have to avoid a match
              * of the string with itself at the start of the input file).
              */
-	    if (s->strategy != Z_HUFFMAN_ONLY) {
-		s->match_length = longest_match (s, hash_head);
-	    }
+            if (s->strategy != Z_HUFFMAN_ONLY) {
+                s->match_length = longest_match (s, hash_head);
+            }
             /* longest_match() sets match_start */
 
             if (s->match_length > s->lookahead) s->match_length = s->lookahead;
@@ -791,7 +804,7 @@
             check_match(s, s->strstart, s->match_start, s->match_length);
 
             bflush = ct_tally(s, s->strstart - s->match_start,
-		 	      s->match_length - MIN_MATCH);
+                              s->match_length - MIN_MATCH);
 
             s->lookahead -= s->match_length;
 
@@ -852,11 +865,11 @@
          * string following the next match.
          */
         if (s->lookahead < MIN_LOOKAHEAD) {
-	    fill_window(s);
-	    if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
 
-	    if (s->lookahead == 0) break; /* flush the current block */
-	}
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
 
         /* Insert the string window[strstart .. strstart+2] in the
          * dictionary, and set hash_head to the head of the hash chain:
@@ -874,15 +887,15 @@
              * of window index 0 (in particular we have to avoid a match
              * of the string with itself at the start of the input file).
              */
-	    if (s->strategy != Z_HUFFMAN_ONLY) {
-		s->match_length = longest_match (s, hash_head);
-	    }
+            if (s->strategy != Z_HUFFMAN_ONLY) {
+                s->match_length = longest_match (s, hash_head);
+            }
             /* longest_match() sets match_start */
             if (s->match_length > s->lookahead) s->match_length = s->lookahead;
 
             if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
-	         (s->match_length == MIN_MATCH &&
-		  s->strstart - s->match_start > TOO_FAR))) {
+                 (s->match_length == MIN_MATCH &&
+                  s->strstart - s->match_start > TOO_FAR))) {
 
                 /* If prev_match is also MIN_MATCH, match_start is garbage
                  * but we will ignore the current match anyway.
@@ -898,7 +911,7 @@
             check_match(s, s->strstart-1, s->prev_match, s->prev_length);
 
             bflush = ct_tally(s, s->strstart -1 - s->prev_match,
-			      s->prev_length - MIN_MATCH);
+                              s->prev_length - MIN_MATCH);
 
             /* Insert in hash table all strings up to the end of the match.
              * strstart-1 and strstart are already inserted.
@@ -927,11 +940,11 @@
              */
             Tracevv((stderr,"%c", s->window[s->strstart-1]));
             if (ct_tally (s, 0, s->window[s->strstart-1])) {
-	        FLUSH_BLOCK_ONLY(s, 0);
+                FLUSH_BLOCK_ONLY(s, 0);
             }
             s->strstart++;
             s->lookahead--;
-	    if (s->strm->avail_out == 0) return 1;
+            if (s->strm->avail_out == 0) return 1;
         } else {
             /* There is no previous match to compare with, wait for
              * the next step to decide.
@@ -942,8 +955,8 @@
         }
     }
     if (s->match_available) {
-	ct_tally (s, 0, s->window[s->strstart-1]);
-	s->match_available = 0;
+        ct_tally (s, 0, s->window[s->strstart-1]);
+        s->match_available = 0;
     }
     FLUSH_BLOCK(s, flush == Z_FINISH);
     return 0;
diff --git a/deflate.h b/deflate.h
index 1f8068e..c292fc7 100644
--- a/deflate.h
+++ b/deflate.h
@@ -8,7 +8,7 @@
    subject to change. Applications should only use zlib.h.
  */
 
-/* $Id: deflate.h,v 1.4 1995/05/01 15:08:45 jloup Exp $ */
+/* $Id: deflate.h,v 1.5 1995/05/03 17:27:09 jloup Exp $ */
 
 #include "zutil.h"
 
@@ -90,7 +90,7 @@
     Byte  data_type;     /* UNKNOWN, BINARY or ASCII */
     Byte  method;        /* STORED (for zip only) or DEFLATED */
 
-    		/* used by deflate.c: */
+                /* used by deflate.c: */
 
     uInt  w_size;        /* LZ77 window size (32K by default) */
     uInt  w_bits;        /* log2(w_size)  (8..16) */
@@ -173,7 +173,7 @@
 
      int nice_match; /* Stop searching when current match exceeds this */
 
-    		/* used by trees.c: */
+                /* used by trees.c: */
 
     ct_data dyn_ltree[HEAP_SIZE];   /* literal and length tree */
     ct_data dyn_dtree[2*D_CODES+1]; /* distance tree */
@@ -264,9 +264,9 @@
  * distances are limited to MAX_DIST instead of WSIZE.
  */
 
-	/* in trees.c */
+        /* in trees.c */
 void ct_init       __P((deflate_state *s));
 int  ct_tally      __P((deflate_state *s, int dist, int lc));
 ulg ct_flush_block __P((deflate_state *s, char *buf, ulg stored_len, int eof));
 void ct_stored_block __P((deflate_state *s, char *buf, ulg stored_len,
-			  int eof));
+                          int eof));
diff --git a/example.c b/example.c
index 5c34733..a2213e0 100644
--- a/example.c
+++ b/example.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: example.c,v 1.8 1995/05/02 15:52:32 jloup Exp $ */
+/* $Id: example.c,v 1.9 1995/05/03 17:27:09 jloup Exp $ */
 
 #include <stdio.h>
 #include "zlib.h"
@@ -27,7 +27,7 @@
 #define CHECK_ERR(err, msg) { \
     if (err != Z_OK) { \
         fprintf(stderr, "%s error: %d\n", msg, err); \
-	exit(1); \
+        exit(1); \
     } \
 }
 
@@ -60,9 +60,9 @@
     CHECK_ERR(err, "uncompress");
 
     if (strcmp((char*)uncompr, hello)) {
-	fprintf(stderr, "bad uncompress\n");
+        fprintf(stderr, "bad uncompress\n");
     } else {
-	printf("uncompress(): %s\n", uncompr);
+        printf("uncompress(): %s\n", uncompr);
     }
 }
 
@@ -81,31 +81,31 @@
 
     file = gzopen(out, "wb");
     if (file == NULL) {
-	fprintf(stderr, "gzopen error\n");
-	exit(1);
+        fprintf(stderr, "gzopen error\n");
+        exit(1);
     }
 
     if (gzwrite(file, hello, len) != len) {
-	fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err));
+        fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err));
     }
     gzclose(file);
 
     file = gzopen(in, "rb");
     if (file == NULL) {
-	fprintf(stderr, "gzopen error\n");
+        fprintf(stderr, "gzopen error\n");
     }
     strcpy((char*)uncompr, "garbage");
 
     uncomprLen = gzread(file, uncompr, uncomprLen);
     if (uncomprLen != len) {
-	fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
+        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
     }
     gzclose(file);
 
     if (strcmp((char*)uncompr, hello)) {
-	fprintf(stderr, "bad gzread\n");
+        fprintf(stderr, "bad gzread\n");
     } else {
-	printf("gzread(): %s\n", uncompr);
+        printf("gzread(): %s\n", uncompr);
     }
 }
 
@@ -129,16 +129,16 @@
     c_stream.next_out = compr;
 
     while (c_stream.total_in != (uLong)len) {
-	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
-	err = deflate(&c_stream, Z_NO_FLUSH);
-	CHECK_ERR(err, "deflate");
+        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
+        err = deflate(&c_stream, Z_NO_FLUSH);
+        CHECK_ERR(err, "deflate");
     }
     /* Finish the stream, still forcing small buffers: */
     for (;;) {
-	c_stream.avail_out = 1;
-	err = deflate(&c_stream, Z_FINISH);
-	if (err == Z_STREAM_END) break;
-	CHECK_ERR(err, "deflate");
+        c_stream.avail_out = 1;
+        err = deflate(&c_stream, Z_FINISH);
+        if (err == Z_STREAM_END) break;
+        CHECK_ERR(err, "deflate");
     }
 
     err = deflateEnd(&c_stream);
@@ -167,19 +167,19 @@
     d_stream.next_out = uncompr;
 
     for (;;) {
-	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
-	err = inflate(&d_stream, Z_NO_FLUSH);
-	if (err == Z_STREAM_END) break;
-	CHECK_ERR(err, "inflate");
+        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END) break;
+        CHECK_ERR(err, "inflate");
     }
 
     err = inflateEnd(&d_stream);
     CHECK_ERR(err, "inflateEnd");
 
     if (strcmp((char*)uncompr, hello)) {
-	fprintf(stderr, "bad inflate\n");
+        fprintf(stderr, "bad inflate\n");
     } else {
-	printf("inflate(): %s\n", uncompr);
+        printf("inflate(): %s\n", uncompr);
     }
 }
 
@@ -211,7 +211,7 @@
 
     err = deflate(&c_stream, Z_FINISH);
     if (err != Z_STREAM_END) {
-	CHECK_ERR(err, "deflate");
+        CHECK_ERR(err, "deflate");
     }
     err = deflateEnd(&c_stream);
     CHECK_ERR(err, "deflateEnd");
@@ -250,7 +250,7 @@
     err = inflate(&d_stream, Z_FINISH);
     if (err != Z_DATA_ERROR) {
         fprintf(stderr, "inflate should report DATA_ERROR\n");
-	/* Because of incorrect adler32 */
+        /* Because of incorrect adler32 */
     }
     err = inflateEnd(&d_stream);
     CHECK_ERR(err, "inflateEnd");
@@ -269,16 +269,16 @@
     local Byte compr[BUFLEN];
 
     if (zlib_version[0] != ZLIB_VERSION[0]) {
-	fprintf(stderr, "incompatible zlib version\n");
-	exit(1);
+        fprintf(stderr, "incompatible zlib version\n");
+        exit(1);
 
     } else if (strcmp(zlib_version, ZLIB_VERSION) != 0) {
-	fprintf(stderr, "warning: different zlib version\n");
+        fprintf(stderr, "warning: different zlib version\n");
     }
     test_compress();
 
     test_gzio((argc > 1 ? argv[1] : "foo.gz"),
-	      (argc > 2 ? argv[2] : "foo.gz"));
+              (argc > 2 ? argv[2] : "foo.gz"));
 
     test_deflate(compr);
     test_inflate(compr);
diff --git a/gzio.c b/gzio.c
index 7a3d05a..d323fbc 100644
--- a/gzio.c
+++ b/gzio.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
-/* $Id: gzio.c,v 1.7 1995/05/02 12:22:08 jloup Exp $ */
+/* $Id: gzio.c,v 1.8 1995/05/03 17:27:09 jloup Exp $ */
 
 #include <stdio.h>
 
@@ -68,13 +68,13 @@
 
     if (s->stream.state != NULL) {
        if (s->mode == 'w') {
-	   err = deflateEnd(&(s->stream));
+           err = deflateEnd(&(s->stream));
        } else if (s->mode == 'r') {
-	   err = inflateEnd(&(s->stream));
+           err = inflateEnd(&(s->stream));
        }
     }
     if (s->file != NULL && fclose(s->file)) {
-	err = Z_ERRNO;
+        err = Z_ERRNO;
     }
     if (s->z_err < 0) err = s->z_err;
     zcfree((voidp)0, s);
@@ -115,34 +115,34 @@
 
     s->path = (char*)ALLOC(strlen(path)+1);
     if (s->path == NULL) {
-	return destroy(s), (gzFile)Z_NULL;
+        return destroy(s), (gzFile)Z_NULL;
     }
     strcpy(s->path, path); /* do this early for debugging */
 
     s->mode = '\0';
     do {
-	if (*p == 'r') s->mode = 'r';
-	if (*p == 'w') s->mode = 'w';
+        if (*p == 'r') s->mode = 'r';
+        if (*p == 'w') s->mode = 'w';
     } while (*p++);
     if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
     
     if (s->mode == 'w') {
-	err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
-			   DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0);
-	/* windowBits is passed < 0 to suppress zlib header */
+        err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION,
+                           DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0);
+        /* windowBits is passed < 0 to suppress zlib header */
 
-	s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);
+        s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE);
 
-	if (err != Z_OK || s->outbuf == Z_NULL) {
-	    return destroy(s), (gzFile)Z_NULL;
-	}
+        if (err != Z_OK || s->outbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
     } else {
-	err = inflateInit2(&(s->stream), -MAX_WBITS);
-	s->stream.next_in  = s->inbuf = ALLOC(Z_BUFSIZE);
+        err = inflateInit2(&(s->stream), -MAX_WBITS);
+        s->stream.next_in  = s->inbuf = ALLOC(Z_BUFSIZE);
 
-	if (err != Z_OK || s->inbuf == Z_NULL) {
-	    return destroy(s), (gzFile)Z_NULL;
-	}
+        if (err != Z_OK || s->inbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
     }
     s->stream.avail_out = Z_BUFSIZE;
 
@@ -150,55 +150,55 @@
     s->file = fd < 0 ? FOPEN(path, mode) : fdopen(fd, mode);
 
     if (s->file == NULL) {
-	return destroy(s), (gzFile)Z_NULL;
+        return destroy(s), (gzFile)Z_NULL;
     }
     if (s->mode == 'w') {
-	/* Write a very simple .gz header:
-	 */
-	fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
-	       DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
-    } else {
-	/* Check and skip the header:
+        /* Write a very simple .gz header:
          */
-	Byte c1 = 0, c2 = 0;
-	Byte method = 0;
-	Byte flags = 0;
-	Byte xflags = 0;
-	Byte time[4];
-	Byte osCode;
-	int c;
+        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
+               DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+    } else {
+        /* Check and skip the header:
+         */
+        Byte c1 = 0, c2 = 0;
+        Byte method = 0;
+        Byte flags = 0;
+        Byte xflags = 0;
+        Byte time[4];
+        Byte osCode;
+        int c;
 
-	s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
-	if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
-	    || s->inbuf[1] != GZ_MAGIC_2) {
-	    s->transparent = 1;
-	    return (gzFile)s;
-	}
-	s->stream.avail_in = 0;
-	fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
+        s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
+        if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
+            || s->inbuf[1] != GZ_MAGIC_2) {
+            s->transparent = 1;
+            return (gzFile)s;
+        }
+        s->stream.avail_in = 0;
+        fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
 
-	if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
-	    s->z_err = Z_DATA_ERROR;
-	    return (gzFile)s;
-	}
-	if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
-	    long len;
-	    fscanf(s->file, "%c%c", &c1, &c2);
-	    len = c1 + ((long)c2<<8);
-	    fseek(s->file, len, SEEK_CUR);
-	}
-	if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
-	    while ((c = getc(s->file)) != 0 && c != EOF) ;
-	}
-	if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
-	    while ((c = getc(s->file)) != 0 && c != EOF) ;
-	}
-	if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
-	    fscanf(s->file, "%c%c", &c1, &c2);
-	}
-	if (feof(s->file)) {
-	    s->z_err = Z_DATA_ERROR;
-	}
+        if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
+            s->z_err = Z_DATA_ERROR;
+            return (gzFile)s;
+        }
+        if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+            long len;
+            fscanf(s->file, "%c%c", &c1, &c2);
+            len = c1 + ((long)c2<<8);
+            fseek(s->file, len, SEEK_CUR);
+        }
+        if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
+            fscanf(s->file, "%c%c", &c1, &c2);
+        }
+        if (feof(s->file)) {
+            s->z_err = Z_DATA_ERROR;
+        }
     }
     return (gzFile)s;
 }
@@ -240,16 +240,16 @@
     if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
 
     if (s->transparent) {
-	unsigned n = 0;
-	Byte *b = (Byte*)buf;
-	/* Copy the first two (non-magic) bytes if not done already */
-	while (s->stream.avail_in > 0 && len > 0) {
-	    *b++ = *s->stream.next_in++;
-	    s->stream.avail_in--;
-	    len--; n++;
-	}
-	if (len == 0) return n;
-	return n + fread(b, 1, len, s->file);
+        unsigned n = 0;
+        Byte *b = (Byte*)buf;
+        /* Copy the first two (non-magic) bytes if not done already */
+        while (s->stream.avail_in > 0 && len > 0) {
+            *b++ = *s->stream.next_in++;
+            s->stream.avail_in--;
+            len--; n++;
+        }
+        if (len == 0) return n;
+        return n + fread(b, 1, len, s->file);
     }
     if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */
     if (s->z_err == Z_STREAM_END) return 0;  /* don't read crc as data */
@@ -259,24 +259,24 @@
 
     while (s->stream.avail_out != 0) {
 
-	if (s->stream.avail_in == 0 && !s->z_eof) {
+        if (s->stream.avail_in == 0 && !s->z_eof) {
 
-	    errno = 0;
-	    s->stream.avail_in =
-		fread(s->inbuf, 1, Z_BUFSIZE, s->file);
-	    if (s->stream.avail_in == 0) {
-		s->z_eof = 1;
-	    } else if (s->stream.avail_in == (uInt)EOF) {
-		s->stream.avail_in = 0;
-		s->z_eof = 1;
-		s->z_err = Z_ERRNO;
-		break;
-	    }
-	    s->stream.next_in = s->inbuf;
-	}
-	s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+            errno = 0;
+            s->stream.avail_in =
+                fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            if (s->stream.avail_in == 0) {
+                s->z_eof = 1;
+            } else if (s->stream.avail_in == (uInt)EOF) {
+                s->stream.avail_in = 0;
+                s->z_eof = 1;
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.next_in = s->inbuf;
+        }
+        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
 
-	if (s->z_err == Z_STREAM_END ||
+        if (s->z_err == Z_STREAM_END ||
             s->z_err != Z_OK  || s->z_eof) break;
     }
     len -= s->stream.avail_out;
@@ -302,18 +302,18 @@
 
     while (s->stream.avail_in != 0) {
 
-	if (s->stream.avail_out == 0) {
+        if (s->stream.avail_out == 0) {
 
-	    s->stream.next_out = s->outbuf;
-	    if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
-		s->z_err = Z_ERRNO;
-		break;
-	    }
-	    s->stream.avail_out = Z_BUFSIZE;
-	}
-	s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+            s->stream.next_out = s->outbuf;
+            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
 
-	if (s->z_err != Z_OK) break;
+        if (s->z_err != Z_OK) break;
     }
     s->crc = crc32(s->crc, buf, len);
 
@@ -339,25 +339,25 @@
     s->stream.avail_in = 0; /* should be zero already anyway */
 
     for (;;) {
-	len = Z_BUFSIZE - s->stream.avail_out;
+        len = Z_BUFSIZE - s->stream.avail_out;
 
-	if (len != 0) {
-	    if (fwrite(s->outbuf, 1, len, s->file) != len) {
-		s->z_err = Z_ERRNO;
-		return Z_ERRNO;
-	    }
-	    s->stream.next_out = s->outbuf;
-	    s->stream.avail_out = Z_BUFSIZE;
-	}
-	if (done) break;
-	s->z_err = deflate(&(s->stream), flush);
+        if (len != 0) {
+            if (fwrite(s->outbuf, 1, len, s->file) != len) {
+                s->z_err = Z_ERRNO;
+                return Z_ERRNO;
+            }
+            s->stream.next_out = s->outbuf;
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        if (done) break;
+        s->z_err = deflate(&(s->stream), flush);
 
         /* deflate has finished flushing only when it hasn't used up
          * all the available space in the output buffer: 
          */
         done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
  
-	if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
     }
     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 }
@@ -371,8 +371,8 @@
 {
     int n;
     for (n = 0; n < 4; n++) {
-	fputc((int)(x & 0xff), file);
-	x >>= 8;
+        fputc((int)(x & 0xff), file);
+        x >>= 8;
     }
 }
 
@@ -386,8 +386,8 @@
     Byte *p = buf+4;
 
     do {
-	x <<= 8;
-	x |= *--p; 
+        x <<= 8;
+        x |= *--p; 
     } while (p != buf);
     return x;
 }
@@ -406,31 +406,31 @@
     if (s == NULL) return Z_STREAM_ERROR;
 
     if (s->mode == 'w') {
-	err = gzflush (file, Z_FINISH);
-	if (err != Z_OK) return destroy(file);
+        err = gzflush (file, Z_FINISH);
+        if (err != Z_OK) return destroy(file);
 
-	putLong (s->file, s->crc);
-	putLong (s->file, s->stream.total_in);
+        putLong (s->file, s->crc);
+        putLong (s->file, s->stream.total_in);
 
     } else if (s->mode == 'r' && s->z_err == Z_STREAM_END) {
 
-	/* slide CRC and original size if they are at the end of inbuf */
-	if ((n = s->stream.avail_in) < 8  && !s->z_eof) {
-	    Byte *p = s->inbuf;
-	    Byte *q = s->stream.next_in;
-	    while (n--) { *p++ = *q++; };
+        /* slide CRC and original size if they are at the end of inbuf */
+        if ((n = s->stream.avail_in) < 8  && !s->z_eof) {
+            Byte *p = s->inbuf;
+            Byte *q = s->stream.next_in;
+            while (n--) { *p++ = *q++; };
 
-	    n = s->stream.avail_in;
-	    n += fread(p, 1, 8, s->file);
-	    s->stream.next_in = s->inbuf;
-	}
-	/* check CRC and original size */
-	if (n < 8 ||
-	    getLong(s->stream.next_in) != s->crc ||
-	    getLong(s->stream.next_in + 4) != s->stream.total_out) {
+            n = s->stream.avail_in;
+            n += fread(p, 1, 8, s->file);
+            s->stream.next_in = s->inbuf;
+        }
+        /* check CRC and original size */
+        if (n < 8 ||
+            getLong(s->stream.next_in) != s->crc ||
+            getLong(s->stream.next_in + 4) != s->stream.total_out) {
 
-	    s->z_err = Z_DATA_ERROR;
-	}
+            s->z_err = Z_DATA_ERROR;
+        }
     }
     return destroy(file);
 }
@@ -450,8 +450,8 @@
     gz_stream *s = (gz_stream*)file;
 
     if (s == NULL) {
-	*errnum = Z_STREAM_ERROR;
-	return z_errmsg[1-Z_STREAM_ERROR];
+        *errnum = Z_STREAM_ERROR;
+        return z_errmsg[1-Z_STREAM_ERROR];
     }
     *errnum = s->z_err;
     if (*errnum == Z_OK) return "";
diff --git a/infblock.c b/infblock.c
index 538fa62..3a9cf85 100644
--- a/infblock.c
+++ b/infblock.c
@@ -12,7 +12,7 @@
 struct inflate_codes_state {int dummy;}; /* for buggy compilers */
 
 /* Table for deflate from PKZIP's appnote.txt. */
-local uInt border[] = {	/* Order of the bit length code lengths */
+local uInt border[] = { /* Order of the bit length code lengths */
         16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 
 /*
@@ -111,13 +111,13 @@
 z_stream *z;
 int r;
 {
-  uInt t;		/* temporary storage */
-  uLong b;		/* bit buffer */
-  uInt k;		/* bits in bit buffer */
-  Byte *p;		/* input data pointer */
-  uInt n;		/* bytes available there */
-  Byte *q;		/* output window write pointer */
-  uInt m;		/* bytes to end of window or read pointer */
+  uInt t;               /* temporary storage */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Byte *p;              /* input data pointer */
+  uInt n;               /* bytes available there */
+  Byte *q;              /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
 
   /* copy input/output information to locals (UPDATE macro restores) */
   LOAD
@@ -131,44 +131,44 @@
       s->last = t & 1;
       switch (t >> 1)
       {
-        case 0:				/* stored */
-	  Trace((stderr, "inflate:     stored block%s\n",
-		 s->last ? " (last)" : ""));
-	  DUMPBITS(3)
-	  t = k & 7;			/* go to byte boundary */
-	  DUMPBITS(t)
-	  s->mode = LENS;		/* get length of stored block */
-	  break;
-	case 1:				/* fixed */
-	  Trace((stderr, "inflate:     fixed codes block%s\n",
-		 s->last ? " (last)" : ""));
-	  {
-	    uInt bl, bd;
-	    inflate_huft *tl, *td;
+        case 0:                         /* stored */
+          Trace((stderr, "inflate:     stored block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          t = k & 7;                    /* go to byte boundary */
+          DUMPBITS(t)
+          s->mode = LENS;               /* get length of stored block */
+          break;
+        case 1:                         /* fixed */
+          Trace((stderr, "inflate:     fixed codes block%s\n",
+                 s->last ? " (last)" : ""));
+          {
+            uInt bl, bd;
+            inflate_huft *tl, *td;
 
-	    inflate_trees_fixed(&bl, &bd, &tl, &td);
-	    s->sub.codes = inflate_codes_new(bl, bd, tl, td, z);
-	    if (s->sub.codes == Z_NULL)
-	    {
-	      r = Z_MEM_ERROR;
-	      LEAVE
-	    }
-	  }
-	  DUMPBITS(3)
-	  s->mode = CODES;
-	  break;
-	case 2:				/* dynamic */
-	  Trace((stderr, "inflate:     dynamic codes block%s\n",
-		 s->last ? " (last)" : ""));
-	  DUMPBITS(3)
-	  s->mode = TABLE;
-	  break;
-	case 3:				/* illegal */
-	  DUMPBITS(3)
-	  s->mode = BAD;
-	  z->msg = "invalid block type";
-	  r = Z_DATA_ERROR;
-	  LEAVE
+            inflate_trees_fixed(&bl, &bd, &tl, &td);
+            s->sub.codes = inflate_codes_new(bl, bd, tl, td, z);
+            if (s->sub.codes == Z_NULL)
+            {
+              r = Z_MEM_ERROR;
+              LEAVE
+            }
+          }
+          DUMPBITS(3)
+          s->mode = CODES;
+          break;
+        case 2:                         /* dynamic */
+          Trace((stderr, "inflate:     dynamic codes block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          s->mode = TABLE;
+          break;
+        case 3:                         /* illegal */
+          DUMPBITS(3)
+          s->mode = BAD;
+          z->msg = "invalid block type";
+          r = Z_DATA_ERROR;
+          LEAVE
       }
       break;
     case LENS:
@@ -176,24 +176,30 @@
       if ((~b) >> 16 != (b & 0xffff))
       {
         s->mode = BAD;
-	z->msg = "invalid stored block lengths";
-	r = Z_DATA_ERROR;
-	LEAVE
+        z->msg = "invalid stored block lengths";
+        r = Z_DATA_ERROR;
+        LEAVE
       }
-      k = 0;				/* dump bits */
       s->sub.left = (uInt)b & 0xffff;
+      k = b = 0;                      /* dump bits */
       Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));
       s->mode = s->sub.left ? STORED : TYPE;
       break;
     case STORED:
-      do {
-        NEEDBYTE
-	NEEDOUT
-	OUTBYTE(NEXTBYTE)
-      } while (--s->sub.left);
+      if (n == 0)
+        LEAVE
+      NEEDOUT
+      t = s->sub.left;
+      if (t > n) t = n;
+      if (t > m) t = m;
+      zmemcpy(q, p, t);
+      p += t;  n -= t;
+      q += t;  m -= t;
+      if ((s->sub.left -= t) != 0)
+        break;
       Tracev((stderr, "inflate:       stored end, %lu total out\n",
-	      z->total_out + (q >= s->read ? q - s->read :
-	      (s->end - s->read) + (q - s->window))));
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
       s->mode = s->last ? DRY : TYPE;
       break;
     case TABLE:
@@ -204,8 +210,8 @@
       {
         s->mode = BAD;
         z->msg = "too many length or distance symbols";
-	r = Z_DATA_ERROR;
-	LEAVE
+        r = Z_DATA_ERROR;
+        LEAVE
       }
 #endif
       t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
@@ -214,7 +220,7 @@
       if ((s->sub.trees.blens = (uInt*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
       {
         r = Z_MEM_ERROR;
-	LEAVE
+        LEAVE
       }
       DUMPBITS(14)
       s->sub.trees.index = 0;
@@ -224,118 +230,118 @@
       while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
       {
         NEEDBITS(3)
-	s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
-	DUMPBITS(3)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
+        DUMPBITS(3)
       }
       while (s->sub.trees.index < 19)
         s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
       s->sub.trees.bb = 7;
       t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
-			     &s->sub.trees.tb, z);
+                             &s->sub.trees.tb, z);
       if (t != Z_OK)
       {
         r = t;
-	if (r == Z_DATA_ERROR)
-	  s->mode = BAD;
-	LEAVE
+        if (r == Z_DATA_ERROR)
+          s->mode = BAD;
+        LEAVE
       }
       s->sub.trees.index = 0;
       Tracev((stderr, "inflate:       bits tree ok\n"));
       s->mode = DTREE;
     case DTREE:
       while (t = s->sub.trees.table,
-      	     s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+             s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
       {
         inflate_huft *h;
-	uInt i, j, c;
+        uInt i, j, c;
 
         t = s->sub.trees.bb;
         NEEDBITS(t)
-	h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
-	t = h->word.what.Bits;
-	c = h->more.Base;
-	if (c < 16)
-	{
-	  DUMPBITS(t)
-	  s->sub.trees.blens[s->sub.trees.index++] = c;
-	}
-	else /* c == 16..18 */
-	{
-	  i = c == 18 ? 7 : c - 14;
-	  j = c == 18 ? 11 : 3;
-	  NEEDBITS(t + i)
-	  DUMPBITS(t)
-	  j += (uInt)b & inflate_mask[i];
-	  DUMPBITS(i)
-	  i = s->sub.trees.index;
-	  t = s->sub.trees.table;
-	  if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
-	      (c == 16 && i < 1))
-	  {
-	    s->mode = BAD;
-	    z->msg = "invalid bit length repeat";
-	    r = Z_DATA_ERROR;
-	    LEAVE
-	  }
-	  c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
-	  do {
-	    s->sub.trees.blens[i++] = c;
-	  } while (--j);
-	  s->sub.trees.index = i;
-	}
+        h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
+        t = h->word.what.Bits;
+        c = h->more.Base;
+        if (c < 16)
+        {
+          DUMPBITS(t)
+          s->sub.trees.blens[s->sub.trees.index++] = c;
+        }
+        else /* c == 16..18 */
+        {
+          i = c == 18 ? 7 : c - 14;
+          j = c == 18 ? 11 : 3;
+          NEEDBITS(t + i)
+          DUMPBITS(t)
+          j += (uInt)b & inflate_mask[i];
+          DUMPBITS(i)
+          i = s->sub.trees.index;
+          t = s->sub.trees.table;
+          if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
+              (c == 16 && i < 1))
+          {
+            s->mode = BAD;
+            z->msg = "invalid bit length repeat";
+            r = Z_DATA_ERROR;
+            LEAVE
+          }
+          c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
+          do {
+            s->sub.trees.blens[i++] = c;
+          } while (--j);
+          s->sub.trees.index = i;
+        }
       }
       inflate_trees_free(s->sub.trees.tb, z);
       s->sub.trees.tb = Z_NULL;
       {
-	uInt bl, bd;
-	inflate_huft *tl, *td;
-	struct inflate_codes_state *c;
+        uInt bl, bd;
+        inflate_huft *tl, *td;
+        struct inflate_codes_state *c;
 
-	bl = 9;
-	bd = 6;
-	t = s->sub.trees.table;
-	t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
-				  s->sub.trees.blens, &bl, &bd, &tl, &td, z);
-	if (t != Z_OK)
-	{
-	  if (t == (uInt)Z_DATA_ERROR)
-	    s->mode = BAD;
-	  r = t;
-	  LEAVE
-	}
+        bl = 9;
+        bd = 6;
+        t = s->sub.trees.table;
+        t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
+                                  s->sub.trees.blens, &bl, &bd, &tl, &td, z);
+        if (t != Z_OK)
+        {
+          if (t == (uInt)Z_DATA_ERROR)
+            s->mode = BAD;
+          r = t;
+          LEAVE
+        }
         Tracev((stderr, "inflate:       trees ok\n"));
-	if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
-	{
-	  inflate_trees_free(td, z);
-	  inflate_trees_free(tl, z);
-	  r = Z_MEM_ERROR;
-	  LEAVE
-	}
-	ZFREE(z, s->sub.trees.blens);
-	s->sub.codes = c;
+        if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
+        {
+          inflate_trees_free(td, z);
+          inflate_trees_free(tl, z);
+          r = Z_MEM_ERROR;
+          LEAVE
+        }
+        ZFREE(z, s->sub.trees.blens);
+        s->sub.codes = c;
       }
       s->mode = CODES;
     case CODES:
       UPDATE
       if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
-	return inflate_flush(s, z, r);
+        return inflate_flush(s, z, r);
       r = Z_OK;
       inflate_codes_free(s->sub.codes, z);
       LOAD
       Tracev((stderr, "inflate:       codes end, %lu total out\n",
-	      z->total_out + (q >= s->read ? q - s->read :
-	      (s->end - s->read) + (q - s->window))));
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
       if (!s->last)
       {
         s->mode = TYPE;
-	break;
+        break;
       }
       if (k > 7)              /* return unused byte, if any */
       {
         Assert(k < 16, "inflate_codes grabbed too many bytes")
         k -= 8;
-	n++;
-	p--;                    /* can always return one */
+        n++;
+        p--;                    /* can always return one */
       }
       s->mode = DRY;
     case DRY:
diff --git a/infblock.h b/infblock.h
index 33e1696..c0712c1 100644
--- a/infblock.h
+++ b/infblock.h
@@ -18,7 +18,7 @@
 extern int inflate_blocks __P((
     struct inflate_blocks_state *,
     z_stream *,
-    int));			/* initial return code */
+    int));                      /* initial return code */
 
 extern void inflate_blocks_reset __P((
     struct inflate_blocks_state *,
diff --git a/infcodes.c b/infcodes.c
index fc56547..87e661b 100644
--- a/infcodes.c
+++ b/infcodes.c
@@ -19,38 +19,38 @@
 struct inflate_codes_state {
 
   /* mode */
-  enum {	/* waiting for "i:"=input, "o:"=output, "x:"=nothing */
-      START,	/* x: set up for LEN */
-      LEN,	/* i: get length/literal/eob next */
-      LENEXT,	/* i: getting length extra (have base) */
-      DIST,	/* i: get distance next */
-      DISTEXT,	/* i: getting distance extra */
-      COPY,	/* o: copying bytes in window, waiting for space */
-      LIT,	/* o: got literal, waiting for output space */
-      WASH,	/* o: got eob, possibly still output waiting */
-      END,	/* x: got eob and all data flushed */
-      BADCODE}	/* x: got error */
-    mode;		/* current inflate_codes mode */
+  enum {        /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+      START,    /* x: set up for LEN */
+      LEN,      /* i: get length/literal/eob next */
+      LENEXT,   /* i: getting length extra (have base) */
+      DIST,     /* i: get distance next */
+      DISTEXT,  /* i: getting distance extra */
+      COPY,     /* o: copying bytes in window, waiting for space */
+      LIT,      /* o: got literal, waiting for output space */
+      WASH,     /* o: got eob, possibly still output waiting */
+      END,      /* x: got eob and all data flushed */
+      BADCODE}  /* x: got error */
+    mode;               /* current inflate_codes mode */
 
   /* mode dependent information */
   uInt len;
   union {
     struct {
-      inflate_huft *tree;	/* pointer into tree */
-      uInt need;		/* bits needed */
-    } code;		/* if LEN or DIST, where in tree */
-    uInt lit;		/* if LIT, literal */
+      inflate_huft *tree;       /* pointer into tree */
+      uInt need;                /* bits needed */
+    } code;             /* if LEN or DIST, where in tree */
+    uInt lit;           /* if LIT, literal */
     struct {
-      uInt get;			/* bits to get for extra */
-      uInt dist;		/* distance back to copy from */
-    } copy;		/* if EXT or COPY, where and how much */
-  } sub;		/* submode */
+      uInt get;                 /* bits to get for extra */
+      uInt dist;                /* distance back to copy from */
+    } copy;             /* if EXT or COPY, where and how much */
+  } sub;                /* submode */
 
   /* mode independent information */
-  Byte lbits;		/* ltree bits decoded per branch */
-  Byte dbits;		/* dtree bits decoder per branch */
-  inflate_huft *ltree;		/* literal/length/eob tree */
-  inflate_huft *dtree;		/* distance tree */
+  Byte lbits;           /* ltree bits decoded per branch */
+  Byte dbits;           /* dtree bits decoder per branch */
+  inflate_huft *ltree;          /* literal/length/eob tree */
+  inflate_huft *dtree;          /* distance tree */
 
 };
 
@@ -81,79 +81,79 @@
 z_stream *z;
 int r;
 {
-  uInt j;		/* temporary storage */
-  inflate_huft *t;	/* temporary pointer */
-  int e;		/* extra bits or operation */
-  uLong b;		/* bit buffer */
-  uInt k;		/* bits in bit buffer */
-  Byte *p;		/* input data pointer */
-  uInt n;		/* bytes available there */
-  Byte *q;		/* output window write pointer */
-  uInt m;		/* bytes to end of window or read pointer */
-  Byte *f;		/* pointer to copy strings from */
-  struct inflate_codes_state *c = s->sub.codes;	/* codes state */
+  uInt j;               /* temporary storage */
+  inflate_huft *t;      /* temporary pointer */
+  int e;                /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Byte *p;              /* input data pointer */
+  uInt n;               /* bytes available there */
+  Byte *q;              /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  Byte *f;              /* pointer to copy strings from */
+  struct inflate_codes_state *c = s->sub.codes; /* codes state */
 
   /* copy input/output information to locals (UPDATE macro restores) */
   LOAD
 
   /* process input and output based on current state */
   while (1) switch (c->mode)
-  {		/* waiting for "i:"=input, "o:"=output, "x:"=nothing */
-    case START:		/* x: set up for LEN */
+  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+    case START:         /* x: set up for LEN */
 #ifndef SLOW
       if (m >= 258 && n >= 10)
       {
         UPDATE
-	r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
-	LOAD
-	if (r != Z_OK)
-	{
-	  c->mode = r == Z_STREAM_END ? WASH : BADCODE;
-	  break;
-	}
+        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
+        LOAD
+        if (r != Z_OK)
+        {
+          c->mode = r == Z_STREAM_END ? WASH : BADCODE;
+          break;
+        }
       }
 #endif /* !SLOW */
       c->sub.code.need = c->lbits;
       c->sub.code.tree = c->ltree;
       c->mode = LEN;
-    case LEN:		/* i: get length/literal/eob next */
+    case LEN:           /* i: get length/literal/eob next */
       j = c->sub.code.need;
       NEEDBITS(j)
       t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
       DUMPBITS(t->bits)
       if ((e = (int)(t->exop)) < 0)
       {
-        if (e == -128)		/* invalid code */
-	{
-	  c->mode = BADCODE;
-	  z->msg = "invalid literal/length code";
-	  r = Z_DATA_ERROR;
-	  LEAVE
-	}
-	e = -e;
-	if (e & 64)		/* end of block */
-	{
-	  Tracevv((stderr, "inflate:         end of block\n"));
-	  c->mode = WASH;
-	  break;
-	}
-	c->sub.code.need = e;
-	c->sub.code.tree = t->next;
-	break;
+        if (e == -128)          /* invalid code */
+        {
+          c->mode = BADCODE;
+          z->msg = "invalid literal/length code";
+          r = Z_DATA_ERROR;
+          LEAVE
+        }
+        e = -e;
+        if (e & 64)             /* end of block */
+        {
+          Tracevv((stderr, "inflate:         end of block\n"));
+          c->mode = WASH;
+          break;
+        }
+        c->sub.code.need = e;
+        c->sub.code.tree = t->next;
+        break;
       }
-      if (e & 16)		/* literal */
+      if (e & 16)               /* literal */
       {
-	c->sub.lit = t->base;
-	Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
-		 "inflate:         literal '%c'\n" :
-		 "inflate:         literal 0x%02x\n", t->base));
-	c->mode = LIT;
-	break;
+        c->sub.lit = t->base;
+        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                 "inflate:         literal '%c'\n" :
+                 "inflate:         literal 0x%02x\n", t->base));
+        c->mode = LIT;
+        break;
       }
       c->sub.copy.get = e;
       c->len = t->base;
       c->mode = LENEXT;
-    case LENEXT:	/* i: getting length extra (have base) */
+    case LENEXT:        /* i: getting length extra (have base) */
       j = c->sub.copy.get;
       NEEDBITS(j)
       c->len += (uInt)b & inflate_mask[j];
@@ -162,7 +162,7 @@
       c->sub.code.tree = c->dtree;
       Tracevv((stderr, "inflate:         length %u\n", c->len));
       c->mode = DIST;
-    case DIST:		/* i: get distance next */
+    case DIST:          /* i: get distance next */
       j = c->sub.code.need;
       NEEDBITS(j)
       t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
@@ -170,46 +170,46 @@
       if ((e = (int)(t->exop)) < 0)
       {
         if (e == -128)
-	{
-	  c->mode = BADCODE;
-	  z->msg = "invalid distance code";
-	  r = Z_DATA_ERROR;
-	  LEAVE
-	}
-	c->sub.code.need = -e;
-	c->sub.code.tree = t->next;
-	break;
+        {
+          c->mode = BADCODE;
+          z->msg = "invalid distance code";
+          r = Z_DATA_ERROR;
+          LEAVE
+        }
+        c->sub.code.need = -e;
+        c->sub.code.tree = t->next;
+        break;
       }
       c->sub.copy.dist = t->base;
       c->sub.copy.get = e;
       c->mode = DISTEXT;
-    case DISTEXT:	/* i: getting distance extra */
+    case DISTEXT:       /* i: getting distance extra */
       j = c->sub.copy.get;
       NEEDBITS(j)
       c->sub.copy.dist += (uInt)b & inflate_mask[j];
       DUMPBITS(j)
       Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
       c->mode = COPY;
-    case COPY:		/* o: copying bytes in window, waiting for space */
+    case COPY:          /* o: copying bytes in window, waiting for space */
       f = (uInt)(q - s->window) < c->sub.copy.dist ?
-	  s->end - (c->sub.copy.dist - (q - s->window)) :
-	  q - c->sub.copy.dist;
+          s->end - (c->sub.copy.dist - (q - s->window)) :
+          q - c->sub.copy.dist;
       while (c->len)
       {
-	NEEDOUT
-	OUTBYTE(*f++)
-	if (f == s->end)
-	  f = s->window;
-	c->len--;
+        NEEDOUT
+        OUTBYTE(*f++)
+        if (f == s->end)
+          f = s->window;
+        c->len--;
       }
       c->mode = START;
       break;
-    case LIT:		/* o: got literal, waiting for output space */
+    case LIT:           /* o: got literal, waiting for output space */
       NEEDOUT
       OUTBYTE(c->sub.lit)
       c->mode = START;
       break;
-    case WASH:		/* o: got eob, possibly more output */
+    case WASH:          /* o: got eob, possibly more output */
       FLUSH
       if (s->read != s->write)
         LEAVE
@@ -217,7 +217,7 @@
     case END:
       r = Z_STREAM_END;
       LEAVE
-    case BADCODE:	/* x: got error */
+    case BADCODE:       /* x: got error */
       r = Z_DATA_ERROR;
       LEAVE
     default:
diff --git a/inffast.c b/inffast.c
index 980a925..2fd707e 100644
--- a/inffast.c
+++ b/inffast.c
@@ -35,19 +35,19 @@
 struct inflate_blocks_state *s;
 z_stream *z;
 {
-  inflate_huft *t;	/* temporary pointer */
-  int e;		/* extra bits or operation */
-  uLong b;		/* bit buffer */
-  uInt k;		/* bits in bit buffer */
-  Byte *p;		/* input data pointer */
-  uInt n;		/* bytes available there */
-  Byte *q;		/* output window write pointer */
-  uInt m;		/* bytes to end of window or read pointer */
-  uInt ml;		/* mask for literal/length tree */
-  uInt md;		/* mask for distance tree */
-  uInt c;		/* bytes to copy */
-  uInt d;		/* distance back to copy from */
-  Byte *r;		/* copy source pointer */
+  inflate_huft *t;      /* temporary pointer */
+  int e;                /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Byte *p;              /* input data pointer */
+  uInt n;               /* bytes available there */
+  Byte *q;              /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  uInt ml;              /* mask for literal/length tree */
+  uInt md;              /* mask for distance tree */
+  uInt c;               /* bytes to copy */
+  uInt d;               /* distance back to copy from */
+  Byte *r;              /* copy source pointer */
 
   /* load input, output, bit values */
   LOAD
@@ -57,40 +57,40 @@
   md = inflate_mask[bd];
 
   /* do until not enough input or output space for fast loop */
-  do {				/* assume called with m >= 258 && n >= 10 */
+  do {                          /* assume called with m >= 258 && n >= 10 */
     /* get literal/length code */
-    GRABBITS(20)		/* max bits for literal/length code */
+    GRABBITS(20)                /* max bits for literal/length code */
     if ((e = (t = tl + ((uInt)b & ml))->exop) < 0)
       do {
-	if (e == -128)
-	{
-	  z->msg = "invalid literal/length code";
+        if (e == -128)
+        {
+          z->msg = "invalid literal/length code";
           UNGRAB
-	  UPDATE
-	  return Z_DATA_ERROR;
-	}
-	DUMPBITS(t->bits)
-	e = -e;
-	if (e & 64)		/* end of block */
-	{
-	  Tracevv((stderr, "inflate:         * end of block\n"));
+          UPDATE
+          return Z_DATA_ERROR;
+        }
+        DUMPBITS(t->bits)
+        e = -e;
+        if (e & 64)             /* end of block */
+        {
+          Tracevv((stderr, "inflate:         * end of block\n"));
           UNGRAB
-	  UPDATE
-	  return Z_STREAM_END;
-	}
+          UPDATE
+          return Z_STREAM_END;
+        }
       } while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
     DUMPBITS(t->bits)
 
     /* process literal or length (end of block already trapped) */
-    if (e & 16)			/* then it's a literal */
+    if (e & 16)                 /* then it's a literal */
     {
       Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
-		"inflate:         * literal '%c'\n" :
-		"inflate:         * literal 0x%02x\n", t->base));
+                "inflate:         * literal '%c'\n" :
+                "inflate:         * literal 0x%02x\n", t->base));
       *q++ = (Byte)t->base;
       m--;
     }
-    else			/* it's a length */
+    else                        /* it's a length */
     {
       /* get length of block to copy (already have extra bits) */
       c = t->base + ((uInt)b & inflate_mask[e]);
@@ -98,53 +98,53 @@
       Tracevv((stderr, "inflate:         * length %u\n", c));
 
       /* decode distance base of block to copy */
-      GRABBITS(15);		/* max bits for distance code */
+      GRABBITS(15);             /* max bits for distance code */
       if ((e = (t = td + ((uInt)b & md))->exop) < 0)
-	do {
-	  if (e == -128)
-	  {
-	    z->msg = "invalid distance code";
-	    UNGRAB
-	    UPDATE
-	    return Z_DATA_ERROR;
-	  }
-	  DUMPBITS(t->bits)
-	  e = -e;
-	} while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
+        do {
+          if (e == -128)
+          {
+            z->msg = "invalid distance code";
+            UNGRAB
+            UPDATE
+            return Z_DATA_ERROR;
+          }
+          DUMPBITS(t->bits)
+          e = -e;
+        } while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
       DUMPBITS(t->bits)
 
       /* get extra bits to add to distance base */
-      GRABBITS((uInt)e)		/* get extra bits (up to 13) */
+      GRABBITS((uInt)e)         /* get extra bits (up to 13) */
       d = t->base + ((uInt)b & inflate_mask[e]);
       DUMPBITS(e)
       Tracevv((stderr, "inflate:         * distance %u\n", d));
 
       /* do the copy */
       m -= c;
-      if ((uInt)(q - s->window) >= d)	/* if offset before destination, */
-      {					/*  just copy */
-	r = q - d;
-	*q++ = *r++;  c--;		/* minimum count is three, */
-	*q++ = *r++;  c--;		/*  so unroll loop a little */
-	do {
-	  *q++ = *r++;
-	} while (--c);
+      if ((uInt)(q - s->window) >= d)   /* if offset before destination, */
+      {                                 /*  just copy */
+        r = q - d;
+        *q++ = *r++;  c--;              /* minimum count is three, */
+        *q++ = *r++;  c--;              /*  so unroll loop a little */
+        do {
+          *q++ = *r++;
+        } while (--c);
       }
-      else				/* else offset after destination */
+      else                              /* else offset after destination */
       {
-	e = d - (q - s->window);	/* bytes from offset to end */
-	r = s->end - e;			/* pointer to offset */
-	if (c > (uInt)e)		/* if source crosses, */
-	{
-	  c -= e;			/* copy to end of window */
-	  do {
-	    *q++ = *r++;
-	  } while (--e);
-	  r = s->window;		/* copy rest from start of window */
-	}
-	do {				/* copy all or what's left */
-	  *q++ = *r++;
-	} while (--c);
+        e = d - (q - s->window);        /* bytes from offset to end */
+        r = s->end - e;                 /* pointer to offset */
+        if (c > (uInt)e)                /* if source crosses, */
+        {
+          c -= e;                       /* copy to end of window */
+          do {
+            *q++ = *r++;
+          } while (--e);
+          r = s->window;                /* copy rest from start of window */
+        }
+        do {                            /* copy all or what's left */
+          *q++ = *r++;
+        } while (--c);
       }
     }
   } while (m >= 258 && n >= 10);
diff --git a/inflate.c b/inflate.c
index 0b0ee87..1c58d98 100644
--- a/inflate.c
+++ b/inflate.c
@@ -13,32 +13,32 @@
 
   /* mode */
   enum {
-      METHOD,	/* waiting for method byte */
-      FLAG,	/* waiting for flag byte */
-      BLOCKS,	/* decompressing blocks */
-      CHECK4,	/* four check bytes to go */
-      CHECK3,	/* three check bytes to go */
-      CHECK2,	/* two check bytes to go */
-      CHECK1,	/* one check byte to go */
-      DONE,	/* finished check, done */
-      BAD}	/* got an error--stay here */
-    mode;		/* current inflate mode */
+      METHOD,   /* waiting for method byte */
+      FLAG,     /* waiting for flag byte */
+      BLOCKS,   /* decompressing blocks */
+      CHECK4,   /* four check bytes to go */
+      CHECK3,   /* three check bytes to go */
+      CHECK2,   /* two check bytes to go */
+      CHECK1,   /* one check byte to go */
+      DONE,     /* finished check, done */
+      BAD}      /* got an error--stay here */
+    mode;               /* current inflate mode */
 
   /* mode dependent information */
   union {
-    uInt method;	/* if FLAGS, method byte */
+    uInt method;        /* if FLAGS, method byte */
     struct {
       uLong was;                /* computed check value */
       uLong need;               /* stream check value */
     } check;            /* if CHECK, check values to compare */
-    uInt marker;	/* if BAD, inflateSync's marker bytes count */
-  } sub;	/* submode */
+    uInt marker;        /* if BAD, inflateSync's marker bytes count */
+  } sub;        /* submode */
 
   /* mode independent information */
-  int  nowrap;		/* flag for no wrapper */
-  uInt wbits;  		/* log2(window size)  (8..15, defaults to 15) */
+  int  nowrap;          /* flag for no wrapper */
+  uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */
   struct inflate_blocks_state
-    *blocks;		/* current inflate_blocks state */
+    *blocks;            /* current inflate_blocks state */
 
 };
 
@@ -135,7 +135,7 @@
 z_stream *z;
 int f;
 {
-  int r = f;	/* to avoid warning about unused f */
+  int r = f;    /* to avoid warning about unused f */
   uInt b;
 
   if (z == Z_NULL || z->next_in == Z_NULL)
@@ -148,16 +148,16 @@
       if (((z->state->sub.method = NEXTBYTE) & 0xf) != DEFLATED)
       {
         z->state->mode = BAD;
-	z->msg = "unknown compression method";
-	z->state->sub.marker = 5;	/* can't try inflateSync */
-	break;
+        z->msg = "unknown compression method";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
       }
       if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
       {
         z->state->mode = BAD;
-	z->msg = "invalid window size";
-	z->state->sub.marker = 5;	/* can't try inflateSync */
-	break;
+        z->msg = "invalid window size";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
       }
       z->state->mode = FLAG;
     case FLAG:
@@ -165,16 +165,16 @@
       if ((b = NEXTBYTE) & 0x20)
       {
         z->state->mode = BAD;
-	z->msg = "invalid reserved bit";
-	z->state->sub.marker = 5;	/* can't try inflateSync */
-	break;
+        z->msg = "invalid reserved bit";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
       }
       if (((z->state->sub.method << 8) + b) % 31)
       {
         z->state->mode = BAD;
-	z->msg = "incorrect header check";
-	z->state->sub.marker = 5;	/* can't try inflateSync */
-	break;
+        z->msg = "incorrect header check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
       }
       Trace((stderr, "inflate: zlib header ok\n"));
       z->state->mode = BLOCKS;
@@ -183,17 +183,17 @@
       if (r == Z_DATA_ERROR)
       {
         z->state->mode = BAD;
-	z->state->sub.marker = 0;	/* can try inflateSync */
-	break;
+        z->state->sub.marker = 0;       /* can try inflateSync */
+        break;
       }
       if (r != Z_STREAM_END)
-	return r;
+        return r;
       r = Z_OK;
       inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
       if (z->state->nowrap)
       {
-	z->state->mode = DONE;
-	break;
+        z->state->mode = DONE;
+        break;
       }
       z->state->mode = CHECK4;
     case CHECK4:
@@ -216,8 +216,8 @@
       {
         z->state->mode = BAD;
         z->msg = "incorrect data check";
-	z->state->sub.marker = 5;	/* can't try inflateSync */
-	break;
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
       }
       Trace((stderr, "inflate: zlib check ok\n"));
       z->state->mode = DONE;
@@ -234,10 +234,10 @@
 int inflateSync(z)
 z_stream *z;
 {
-  uInt n;	/* number of bytes to look at */
-  Byte *p;	/* pointer to bytes */
-  uInt m;	/* number of marker bytes found in a row */
-  uLong r, w;	/* temporaries to save total_in and total_out */
+  uInt n;       /* number of bytes to look at */
+  Byte *p;      /* pointer to bytes */
+  uInt m;       /* number of marker bytes found in a row */
+  uLong r, w;   /* temporaries to save total_in and total_out */
 
   /* set up */
   if (z == Z_NULL || z->state == Z_NULL)
diff --git a/inftest.c b/inftest.c
deleted file mode 100644
index d711bfa..0000000
--- a/inftest.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "zutil.h"
-
-void main __P((void));
-
-/* This test is in honor of Ed Hamrick who suggested that the interface
-   to inflate be a byte at a time--this implements that, and is, of course,
-   monumentally slow.  It has the virtue though of stressing the push-pull
-   interface for testing purposes. */
-
-void main()
-{
-  int a, r;
-  char c;
-  z_stream z;
-
-  z.zalloc = Z_NULL;
-  z.zfree = Z_NULL;
-  r = inflateInit(&z);
-  if (r != Z_OK)
-    fprintf(stderr, "init error: %s\n", z_errmsg[1 - r]);
-  while ((a = getchar()) != EOF)
-  {
-    /* feed one byte of input */
-    z.avail_out = 0;
-    c = (char)a;
-    z.next_in = (Byte*)&c;
-    z.avail_in = 1;
-    r = inflate(&z, 0);
-    if (r == Z_STREAM_END)
-      break;
-    if (r != Z_OK)
-    {
-      fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
-      break;
-    }
-    if (z.avail_in != 0)
-    {
-      fprintf(stderr, "inflate didn't eat byte and didn't say buf err!\n");
-      break;
-    }
-
-    /* empty output one byte at a time */
-    while (1)
-    {
-      z.next_out = (Byte*)&c;
-      z.avail_out = 1;
-      r = inflate(&z, 0);
-      if (r == Z_STREAM_END)
-	break;
-      if (r != Z_OK && r != Z_BUF_ERROR)
-      {
-	fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]);
-	break;
-      }
-      if (z.avail_out == 0)
-        putchar(c);
-      else
-        break;
-    }
-    if (r != Z_OK && r != Z_BUF_ERROR)
-      break;
-  }
-  inflateEnd(&z);
-  fprintf(stderr, "%ld bytes in, %ld bytes out\n", z.total_in, z.total_out);
-  if (z.msg != NULL)
-    fprintf(stderr, "msg is <%s>\n", z.msg);
-}
diff --git a/inftrees.c b/inftrees.c
index ab0ed2c..9858927 100644
--- a/inftrees.c
+++ b/inftrees.c
@@ -16,37 +16,37 @@
 
 
 local int huft_build __P((
-    uInt *,		/* code lengths in bits */
-    uInt,		/* number of codes */
-    uInt,		/* number of "simple" codes */
-    uInt *,		/* list of base values for non-simple codes */
-    uInt *,		/* list of extra bits for non-simple codes */
-    inflate_huft **,	/* result: starting table */
-    uInt *,		/* maximum lookup bits (returns actual) */
-    z_stream *));	/* for zalloc function */
+    uInt *,             /* code lengths in bits */
+    uInt,               /* number of codes */
+    uInt,               /* number of "simple" codes */
+    uInt *,             /* list of base values for non-simple codes */
+    uInt *,             /* list of extra bits for non-simple codes */
+    inflate_huft **,    /* result: starting table */
+    uInt *,             /* maximum lookup bits (returns actual) */
+    z_stream *));       /* for zalloc function */
 
 local voidp falloc __P((
-    voidp,		/* opaque pointer (not used) */
-    uInt,		/* number of items */
-    uInt));		/* size of item */
+    voidp,              /* opaque pointer (not used) */
+    uInt,               /* number of items */
+    uInt));             /* size of item */
 
 local void ffree __P((
-    voidp q,		/* opaque pointer (not used) */
-    voidp p));		/* what to free (not used) */
+    voidp q,            /* opaque pointer (not used) */
+    voidp p));          /* what to free (not used) */
 
 /* Tables for deflate from PKZIP's appnote.txt. */
-local uInt cplens[] = {	/* Copy lengths for literal codes 257..285 */
+local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */
         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};
         /* actually lengths - 2; also see note #13 above about 258 */
-local uInt cplext[] = {	/* Extra bits for literal codes 257..285 */
+local uInt cplext[] = { /* Extra bits for literal codes 257..285 */
         0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
         3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 128, 128}; /* 128==invalid */
-local uInt cpdist[] = {	/* Copy offsets for distance codes 0..29 */
+local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */
         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};
-local uInt cpdext[] = {	/* Extra bits for distance codes */
+local uInt cpdext[] = { /* Extra bits for distance codes */
         0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
         7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
         12, 12, 13, 13};
@@ -100,32 +100,32 @@
 uInt *e;                /* list of extra bits for non-simple codes */
 inflate_huft **t;       /* result: starting table */
 uInt *m;                /* maximum lookup bits, returns actual */
-z_stream *zs;		/* for zalloc function */
+z_stream *zs;           /* for zalloc function */
 /* Given a list of code lengths and a maximum table size, make a set of
    tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
    if the given code set is incomplete (the tables are still built in this
    case), Z_DATA_ERROR if the input is invalid (all zero length codes or an
    over-subscribed set of lengths), or Z_MEM_ERROR if not enough memory. */
 {
-  uInt a;			/* counter for codes of length k */
-  uInt c[BMAX+1];		/* bit length count table */
-  uInt f;			/* i repeats in table every f entries */
-  int g;			/* maximum code length */
-  int h;			/* table level */
-  register uInt i;		/* counter, current code */
-  register uInt j;		/* counter */
-  register int k;		/* number of bits in current code */
-  int l;			/* bits per table (returned in m) */
-  register uInt *p;		/* pointer into c[], b[], or v[] */
-  register inflate_huft *q;	/* points to current table */
-  inflate_huft r;		/* table entry for structure assignment */
-  inflate_huft *u[BMAX];	/* table stack */
-  uInt v[N_MAX];		/* values in order of bit length */
-  register int w;		/* bits before this table == (l * h) */
-  uInt x[BMAX+1];		/* bit offsets, then code stack */
-  uInt *xp;			/* pointer into x */
-  int y;			/* number of dummy codes added */
-  uInt z;			/* number of entries in current table */
+  uInt a;                       /* counter for codes of length k */
+  uInt c[BMAX+1];               /* bit length count table */
+  uInt f;                       /* i repeats in table every f entries */
+  int g;                        /* maximum code length */
+  int h;                        /* table level */
+  register uInt i;              /* counter, current code */
+  register uInt j;              /* counter */
+  register int k;               /* number of bits in current code */
+  int l;                        /* bits per table (returned in m) */
+  register uInt *p;             /* pointer into c[], b[], or v[] */
+  register inflate_huft *q;     /* points to current table */
+  inflate_huft r;               /* table entry for structure assignment */
+  inflate_huft *u[BMAX];        /* table stack */
+  uInt v[N_MAX];                /* values in order of bit length */
+  register int w;               /* bits before this table == (l * h) */
+  uInt x[BMAX+1];               /* bit offsets, then code stack */
+  uInt *xp;                     /* pointer into x */
+  int y;                        /* number of dummy codes added */
+  uInt z;                       /* number of entries in current table */
 
 
   /* Generate counts for each bit length */
@@ -133,7 +133,7 @@
 #define C0 *p++ = 0;
 #define C2 C0 C0 C0 C0
 #define C4 C2 C2 C2 C2
-  C4				/* clear c[]--assume BMAX+1 is 16 */
+  C4                            /* clear c[]--assume BMAX+1 is 16 */
   p = b;  i = n;
   do {
     c[*p++]++;                  /* assume all entries <= BMAX */
@@ -193,8 +193,8 @@
   p = v;                        /* grab values in bit order */
   h = -1;                       /* no tables yet--level -1 */
   w = -l;                       /* bits decoded == (l * h) */
-  u[0] = (inflate_huft *)Z_NULL;	/* just to keep compilers happy */
-  q = (inflate_huft *)Z_NULL;	/* ditto */
+  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
+  q = (inflate_huft *)Z_NULL;   /* ditto */
   z = 0;                        /* ditto */
 
   /* go through the bit lengths (k already is bits in shortest code) */
@@ -217,25 +217,25 @@
           f -= a + 1;           /* deduct codes from patterns left */
           xp = c + k;
           if (j < z)
-	    while (++j < z)	/* try smaller tables up to z bits */
-	    {
-	      if ((f <<= 1) <= *++xp)
-		break;		/* enough codes to use up j bits */
-	      f -= *xp;		/* else deduct codes from patterns */
-	    }
+            while (++j < z)     /* try smaller tables up to z bits */
+            {
+              if ((f <<= 1) <= *++xp)
+                break;          /* enough codes to use up j bits */
+              f -= *xp;         /* else deduct codes from patterns */
+            }
         }
         z = 1 << j;             /* table entries for j-bit table */
 
         /* allocate and link in new table */
         if ((q = (inflate_huft *)ZALLOC
-	     (zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
+             (zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
         {
           if (h)
             inflate_trees_free(u[0], zs);
-          return Z_MEM_ERROR;	/* not enough memory */
+          return Z_MEM_ERROR;   /* not enough memory */
         }
 #ifdef DEBUG
-	inflate_hufts += z + 1;
+        inflate_hufts += z + 1;
 #endif
         *t = q + 1;             /* link to list for huft_free() */
         *(t = &(q->next)) = (inflate_huft *)Z_NULL;
@@ -245,8 +245,8 @@
         if (h)
         {
           x[h] = i;             /* save pattern for backing up */
-          r.bits = (char)l;     /* bits to dump before this table */
-          r.exop = -(char)j;    /* bits in this table */
+          r.bits = (Byte)l;     /* bits to dump before this table */
+          r.exop = -(Char)j;    /* bits in this table */
           r.next = q;           /* pointer to this table */
           j = i >> (w - l);     /* (get around Turbo C bug) */
           u[h-1][j] = r;        /* connect to last table */
@@ -254,17 +254,17 @@
       }
 
       /* set up table entry in r */
-      r.bits = (char)(k - w);
+      r.bits = (Byte)(k - w);
       if (p >= v + n)
-        r.exop = -128;          /* out of values--invalid code */
+        r.exop = (Char)(-128);        /* out of values--invalid code */
       else if (*p < s)
       {
-        r.exop = (char)(*p < 256 ? 16 : -64);   /* 256 is end-of-block code */
+        r.exop = (Char)(*p < 256 ? 16 : -64);   /* 256 is end-of-block code */
         r.base = *p++;          /* simple code is just the value */
       }
       else
       {
-        r.exop = (char)e[*p - s];       /* non-simple--look up in lists */
+        r.exop = (Char)e[*p - s];       /* non-simple--look up in lists */
         r.base = d[*p++ - s];
       }
 
@@ -294,10 +294,10 @@
 
 
 int inflate_trees_bits(c, bb, tb, z)
-uInt *c;		/* 19 code lengths */
-uInt *bb;		/* bits tree desired/actual depth */
-inflate_huft **tb;	/* bits tree result */
-z_stream *z;		/* for zfree function */
+uInt *c;                /* 19 code lengths */
+uInt *bb;               /* bits tree desired/actual depth */
+inflate_huft **tb;      /* bits tree result */
+z_stream *z;            /* for zfree function */
 {
   int r;
 
@@ -315,14 +315,14 @@
 
 
 int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
-uInt nl;		/* number of literal/length codes */
-uInt nd;		/* number of distance codes */
-uInt *c;		/* that many (total) code lengths */
-uInt *bl;		/* literal desired/actual bit depth */
-uInt *bd;		/* distance desired/actual bit depth */
-inflate_huft **tl;	/* literal/length tree result */
-inflate_huft **td;	/* distance tree result */
-z_stream *z;		/* for zfree function */
+uInt nl;                /* number of literal/length codes */
+uInt nd;                /* number of distance codes */
+uInt *c;                /* that many (total) code lengths */
+uInt *bl;               /* literal desired/actual bit depth */
+uInt *bd;               /* distance desired/actual bit depth */
+inflate_huft **tl;      /* literal/length tree result */
+inflate_huft **td;      /* distance tree result */
+z_stream *z;            /* for zfree function */
 {
   int r;
 
@@ -367,7 +367,7 @@
 /* build fixed tables only once--keep them here */
 local int fixed_lock = 0;
 local int fixed_built = 0;
-#define FIXEDH 530	/* number of hufts used by fixed tables */
+#define FIXEDH 530      /* number of hufts used by fixed tables */
 local uInt fixed_left = FIXEDH;
 local inflate_huft fixed_mem[FIXEDH];
 local uInt fixed_bl;
@@ -377,9 +377,9 @@
 
 
 local voidp falloc(q, n, s)
-voidp q;	/* opaque pointer (not used) */
-uInt n;		/* number of items */
-uInt s;		/* size of item */
+voidp q;        /* opaque pointer (not used) */
+uInt n;         /* number of items */
+uInt s;         /* size of item */
 {
   Assert(s == sizeof(inflate_huft) && n <= fixed_left,
          "inflate_trees falloc overflow");
@@ -399,19 +399,19 @@
 
 
 int inflate_trees_fixed(bl, bd, tl, td)
-uInt *bl;		/* literal desired/actual bit depth */
-uInt *bd;		/* distance desired/actual bit depth */
-inflate_huft **tl;	/* literal/length tree result */
-inflate_huft **td;	/* distance tree result */
+uInt *bl;               /* literal desired/actual bit depth */
+uInt *bd;               /* distance desired/actual bit depth */
+inflate_huft **tl;      /* literal/length tree result */
+inflate_huft **td;      /* distance tree result */
 {
   /* build fixed tables if not built already--lock out other instances */
   while (++fixed_lock > 1)
     fixed_lock--;
   if (!fixed_built)
   {
-    int k;		/* temporary variable */
-    unsigned c[288];	/* length list for huft_build */
-    z_stream z;		/* for falloc function */
+    int k;              /* temporary variable */
+    unsigned c[288];    /* length list for huft_build */
+    z_stream z;         /* for falloc function */
 
     /* set up fake z_stream for memory routines */
     z.zalloc = falloc;
@@ -449,8 +449,8 @@
 
 
 int inflate_trees_free(t, z)
-inflate_huft *t;	/* table to free */
-z_stream *z;		/* for zfree function */
+inflate_huft *t;        /* table to free */
+z_stream *z;            /* for zfree function */
 /* Free the malloc'ed tables built by huft_build(), which makes a linked
    list of the tables it made, with the links in a dummy first entry of
    each table. */
diff --git a/inftrees.h b/inftrees.h
index 6001a4e..27e7222 100644
--- a/inftrees.h
+++ b/inftrees.h
@@ -16,12 +16,18 @@
    indicates an unused code.  If a code with exop == -128 is looked up,
    this implies an error in the data. */
 
+#if defined(STDC) || defined(sgi)
+typedef signed char Char;
+#else
+typedef char Char; /* just hope that char is signed */
+#endif
+
 typedef struct inflate_huft_s inflate_huft;
 struct inflate_huft_s {
   union {
     struct {
-      char Exop;        /* number of extra bits or operation */
-      char Bits;        /* number of bits in this code or subcode */
+      Char Exop;        /* number of extra bits or operation */
+      Byte Bits;        /* number of bits in this code or subcode */
     } what;
     Byte *pad;          /* pad structure to a power of 2 (4 bytes for */
   } word;               /*  16-bit, 8 bytes for 32-bit machines) */
@@ -36,27 +42,27 @@
 #endif
 
 extern int inflate_trees_bits __P((
-    uInt *,			/* 19 code lengths */
-    uInt *,			/* bits tree desired/actual depth */
-    inflate_huft **,		/* bits tree result */
-    z_stream *));		/* for zalloc, zfree functions */
+    uInt *,                     /* 19 code lengths */
+    uInt *,                     /* bits tree desired/actual depth */
+    inflate_huft **,            /* bits tree result */
+    z_stream *));               /* for zalloc, zfree functions */
 
 extern int inflate_trees_dynamic __P((
-    uInt,			/* number of literal/length codes */
-    uInt,			/* number of distance codes */
-    uInt *,			/* that many (total) code lengths */
-    uInt *,			/* literal desired/actual bit depth */
-    uInt *,			/* distance desired/actual bit depth */
-    inflate_huft **,		/* literal/length tree result */
-    inflate_huft **,		/* distance tree result */
-    z_stream *));		/* for zalloc, zfree functions */
+    uInt,                       /* number of literal/length codes */
+    uInt,                       /* number of distance codes */
+    uInt *,                     /* that many (total) code lengths */
+    uInt *,                     /* literal desired/actual bit depth */
+    uInt *,                     /* distance desired/actual bit depth */
+    inflate_huft **,            /* literal/length tree result */
+    inflate_huft **,            /* distance tree result */
+    z_stream *));               /* for zalloc, zfree functions */
 
 extern int inflate_trees_fixed __P((
-    uInt *,			/* literal desired/actual bit depth */
-    uInt *,			/* distance desired/actual bit depth */
-    inflate_huft **,		/* literal/length tree result */
-    inflate_huft **));		/* distance tree result */
+    uInt *,                     /* literal desired/actual bit depth */
+    uInt *,                     /* distance desired/actual bit depth */
+    inflate_huft **,            /* literal/length tree result */
+    inflate_huft **));          /* distance tree result */
 
 extern int inflate_trees_free __P((
-    inflate_huft *,		/* tables to free */
-    z_stream *));		/* for zfree function */
+    inflate_huft *,             /* tables to free */
+    z_stream *));               /* for zfree function */
diff --git a/infutil.h b/infutil.h
index f468f1a..f234e9b 100644
--- a/infutil.h
+++ b/infutil.h
@@ -13,42 +13,42 @@
 
   /* mode */
   enum {
-      TYPE,	/* get type bits (3, including end bit) */
-      LENS,	/* get lengths for stored */
-      STORED,	/* processing stored block */
-      TABLE,	/* get table lengths */
-      BTREE,	/* get bit lengths tree for a dynamic block */
-      DTREE,	/* get length, distance trees for a dynamic block */
-      CODES,	/* processing fixed or dynamic block */
-      DRY,	/* output remaining window bytes */
-      DONE,	/* finished last block, done */
-      BAD}	/* got a data error--stuck here */
-    mode;		/* current inflate_block mode */
+      TYPE,     /* get type bits (3, including end bit) */
+      LENS,     /* get lengths for stored */
+      STORED,   /* processing stored block */
+      TABLE,    /* get table lengths */
+      BTREE,    /* get bit lengths tree for a dynamic block */
+      DTREE,    /* get length, distance trees for a dynamic block */
+      CODES,    /* processing fixed or dynamic block */
+      DRY,      /* output remaining window bytes */
+      DONE,     /* finished last block, done */
+      BAD}      /* got a data error--stuck here */
+    mode;               /* current inflate_block mode */
 
   /* mode dependent information */
   union {
-    uInt left;		/* if STORED, bytes left to copy */
+    uInt left;          /* if STORED, bytes left to copy */
     struct {
-      uInt table;		/* table lengths (14 bits) */
-      uInt index;		/* index into blens (or border) */
-      uInt *blens;		/* bit lengths of codes */
-      uInt bb;			/* bit length tree depth */
-      inflate_huft *tb;		/* bit length decoding tree */
-    } trees;		/* if DTREE, decoding info for trees */
+      uInt table;               /* table lengths (14 bits) */
+      uInt index;               /* index into blens (or border) */
+      uInt *blens;              /* bit lengths of codes */
+      uInt bb;                  /* bit length tree depth */
+      inflate_huft *tb;         /* bit length decoding tree */
+    } trees;            /* if DTREE, decoding info for trees */
     struct inflate_codes_state
-      *codes;		/* if CODES, current state */
-  } sub;		/* submode */
-  uInt last;		/* true if this block is the last block */
+      *codes;           /* if CODES, current state */
+  } sub;                /* submode */
+  uInt last;            /* true if this block is the last block */
 
   /* mode independent information */
-  uInt bitk;		/* bits in bit buffer */
-  uLong bitb;		/* bit buffer */
-  Byte *window;		/* sliding window */
-  Byte *end;		/* one byte after sliding window */
-  Byte *read;		/* window read pointer */
-  Byte *write;		/* window write pointer */
+  uInt bitk;            /* bits in bit buffer */
+  uLong bitb;           /* bit buffer */
+  Byte *window;         /* sliding window */
+  Byte *end;            /* one byte after sliding window */
+  Byte *read;           /* window read pointer */
+  Byte *write;          /* window write pointer */
   check_func checkfn;   /* check function */
-  uLong check;		/* check on output */
+  uLong check;          /* check on output */
 
 };
 
diff --git a/minigzip.c b/minigzip.c
index 8f58080..017c3e4 100644
--- a/minigzip.c
+++ b/minigzip.c
@@ -13,7 +13,7 @@
  * or in pipe mode.
  */
 
-/* $Id: minigzip.c,v 1.4 1995/05/02 15:54:22 jloup Exp $ */
+/* $Id: minigzip.c,v 1.5 1995/05/03 17:27:11 jloup Exp $ */
 
 #include <stdio.h>
 #include "zlib.h"
@@ -75,14 +75,14 @@
     int err;
 
     for (;;) {
-	len = fread(buf, 1, sizeof(buf), in);
-	if (ferror(in)) {
-	    perror("fread");
-	    exit(1);
-	}
-	if (len == 0) break;
+        len = fread(buf, 1, sizeof(buf), in);
+        if (ferror(in)) {
+            perror("fread");
+            exit(1);
+        }
+        if (len == 0) break;
 
-	if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
+        if (gzwrite(out, buf, len) != len) error(gzerror(out, &err));
     }
     fclose(in);
     if (gzclose(out) != Z_OK) error("failed gzclose");
@@ -100,11 +100,11 @@
     int err;
 
     for (;;) {
-	len = gzread(in, buf, sizeof(buf));
-	if (len < 0) error (gzerror(in, &err));
-	if (len == 0) break;
+        len = gzread(in, buf, sizeof(buf));
+        if (len < 0) error (gzerror(in, &err));
+        if (len == 0) break;
 
-	if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite");
+        if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite");
     }
     if (fclose(out)) error("failed fclose");
 
@@ -128,13 +128,13 @@
 
     in = fopen(file, "rb");
     if (in == NULL) {
-	perror(file);
-	exit(1);
+        perror(file);
+        exit(1);
     }
     out = gzopen(outfile, "wb");
     if (out == NULL) {
-	fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
-	exit(1);
+        fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
+        exit(1);
     }
     gz_compress(in, out);
 
@@ -157,23 +157,23 @@
     strcpy(buf, file);
 
     if (len > 3 && strcmp(file+len-3, ".gz") == 0) {
-	infile = file;
-	outfile = buf;
-	outfile[len-3] = '\0';
+        infile = file;
+        outfile = buf;
+        outfile[len-3] = '\0';
     } else {
-	outfile = file;
-	infile = buf;
-	strcat(infile, ".gz");
+        outfile = file;
+        infile = buf;
+        strcat(infile, ".gz");
     }
     in = gzopen(infile, "rb");
     if (in == NULL) {
-	fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
-	exit(1);
+        fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
+        exit(1);
     }
     out = fopen(outfile, "wb");
     if (out == NULL) {
-	perror(file);
-	exit(1);
+        perror(file);
+        exit(1);
     }
 
     gz_uncompress(in, out);
@@ -197,31 +197,31 @@
     argc--, argv++;
 
     if (argc > 0) {
-	uncompr = (strcmp(*argv, "-d") == 0);
-	if (uncompr) {
-	    argc--, argv++;
-	}
+        uncompr = (strcmp(*argv, "-d") == 0);
+        if (uncompr) {
+            argc--, argv++;
+        }
     }
     if (argc == 0) {
         SET_BINARY_MODE(stdin);
         SET_BINARY_MODE(stdout);
-	if (uncompr) {
-	    file = gzdopen(fileno(stdin), "rb");
+        if (uncompr) {
+            file = gzdopen(fileno(stdin), "rb");
             if (file == NULL) error("can't gzdopen stdin");
-	    gz_uncompress(file, stdout);
-	} else {
-	    file = gzdopen(fileno(stdout), "wb");
+            gz_uncompress(file, stdout);
+        } else {
+            file = gzdopen(fileno(stdout), "wb");
             if (file == NULL) error("can't gzdopen stdout");
-	    gz_compress(stdin, file);
-	}
+            gz_compress(stdin, file);
+        }
     } else {
-	do {
-	    if (uncompr) {
-		file_uncompress(*argv);
-	    } else {
-		file_compress(*argv);
-	    }
-	} while (argv++, --argc);
+        do {
+            if (uncompr) {
+                file_uncompress(*argv);
+            } else {
+                file_compress(*argv);
+            }
+        } while (argv++, --argc);
     }
     exit(0);
 }
diff --git a/trees.c b/trees.c
index eb69d49..f85716e 100644
--- a/trees.c
+++ b/trees.c
@@ -29,7 +29,7 @@
  *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
  */
 
-/* $Id: trees.c,v 1.4 1995/05/01 16:53:44 jloup Exp $ */
+/* $Id: trees.c,v 1.5 1995/05/03 17:27:12 jloup Exp $ */
 
 #include "deflate.h"
 
@@ -139,15 +139,15 @@
 local void send_tree      __P((deflate_state *s, ct_data *tree, int max_code));
 local int  build_bl_tree  __P((deflate_state *s));
 local void send_all_trees __P((deflate_state *s, int lcodes, int dcodes,
-			      int blcodes));
+                              int blcodes));
 local void compress_block __P((deflate_state *s, ct_data *ltree,
-			      ct_data *dtree));
+                              ct_data *dtree));
 local void set_data_type  __P((deflate_state *s));
 local void send_bits      __P((deflate_state *s, int value, int length));
 local unsigned bi_reverse __P((unsigned value, int length));
 local void bi_windup      __P((deflate_state *s));
 local void copy_block     __P((deflate_state *s, char *buf, unsigned len,
-			       int header));
+                               int header));
 
 #ifndef DEBUG
 #  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
@@ -243,7 +243,7 @@
     deflate_state *s;
 {
     if (static_dtree[0].Len == 0) {
-	ct_static_init();              /* To do: at compile time */
+        ct_static_init();              /* To do: at compile time */
     }
 
     s->compressed_len = 0L;
@@ -324,9 +324,9 @@
     while (j <= s->heap_len) {
         /* Set j to the smallest of the two sons: */
         if (j < s->heap_len &&
-	    smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
-	    j++;
-	}
+            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+            j++;
+        }
         /* Exit if v is smaller than both sons */
         if (smaller(tree, v, s->heap[j], s->depth)) break;
 
@@ -420,7 +420,7 @@
             if (tree[m].Len != (unsigned) bits) {
                 Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
                 s->opt_len += ((long)bits - (long)tree[m].Len)
-		              *(long)tree[m].Freq;
+                              *(long)tree[m].Freq;
                 tree[m].Len = (ush)bits;
             }
             n--;
@@ -686,7 +686,7 @@
     /* Update opt_len to include the bit length tree and counts */
     s->opt_len += 3*(max_blindex+1) + 5+5+4;
     Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
-	    s->opt_len, s->static_len));
+            s->opt_len, s->static_len));
 
     return max_blindex;
 }
@@ -758,11 +758,11 @@
     /* Construct the literal and distance trees */
     build_tree(s, (tree_desc *)(&(s->l_desc)));
     Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
-	    s->static_len));
+            s->static_len));
 
     build_tree(s, (tree_desc *)(&(s->d_desc)));
     Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
-	    s->static_len));
+            s->static_len));
     /* At this point, opt_len and static_len are the total bit lengths of
      * the compressed block data, excluding the tree representations.
      */
@@ -813,7 +813,7 @@
          * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
          * transform a block into a stored block.
          */
-	ct_stored_block(s, buf, stored_len, eof);
+        ct_stored_block(s, buf, stored_len, eof);
 
 #ifdef FORCE_STATIC
     } else if (static_lenb >= 0) { /* force static trees */
@@ -826,7 +826,7 @@
     } else {
         send_bits(s, (DYN_TREES<<1)+eof, 3);
         send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
-		       max_blindex+1);
+                       max_blindex+1);
         compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
         s->compressed_len += 3 + s->opt_len;
     }
@@ -858,7 +858,7 @@
         /* lc is the unmatched char */
         s->dyn_ltree[lc].Freq++;
     } else {
-	s->matches++;
+        s->matches++;
         /* Here, lc is the match length - MIN_MATCH */
         dist--;             /* dist = match distance - 1 */
         Assert((ush)dist < (ush)MAX_DIST(s) &&
@@ -877,7 +877,7 @@
         int dcode;
         for (dcode = 0; dcode < D_CODES; dcode++) {
             out_length += (ulg)s->dyn_dtree[dcode].Freq *
-		(5L+extra_dbits[dcode]);
+                (5L+extra_dbits[dcode]);
         }
         out_length >>= 3;
         Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
@@ -907,7 +907,7 @@
     int extra;          /* number of extra bits to send */
 
     if (s->last_lit != 0) do {
-	dist = s->d_buf[lx];
+        dist = s->d_buf[lx];
         lc = s->l_buf[lx++];
         if (dist == 0) {
             send_code(s, lc, ltree); /* send a literal byte */
@@ -921,7 +921,7 @@
                 lc -= base_length[code];
                 send_bits(s, lc, extra);       /* send the extra length bits */
             }
-	    dist--; /* dist is now the match distance - 1 */
+            dist--; /* dist is now the match distance - 1 */
             code = d_code(dist);
             Assert (code < D_CODES, "bad d_code");
 
@@ -933,8 +933,8 @@
             }
         } /* literal or match pair ? */
 
-	/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
-	Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
+        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+        Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
 
     } while (lx < s->last_lit);
 
@@ -1055,6 +1055,6 @@
     s->bits_sent += (ulg)len<<3;
 #endif
     while (len--) {
-	put_byte(s, *buf++);
+        put_byte(s, *buf++);
     }
 }
diff --git a/uncompr.c b/uncompr.c
index 4c8b3af..c76286c 100644
--- a/uncompr.c
+++ b/uncompr.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: uncompr.c,v 1.4 1995/04/10 16:22:22 jloup Exp $ */
+/* $Id: uncompr.c,v 1.5 1995/05/03 17:27:12 jloup Exp $ */
 
 #include "zlib.h"
 
@@ -48,8 +48,8 @@
 
     err = inflate(&stream, Z_FINISH);
     if (err != Z_STREAM_END) {
-	inflateEnd(&stream);
-	return err;
+        inflateEnd(&stream);
+        return err;
     }
     *destLen = stream.total_out;
 
diff --git a/zconf.h b/zconf.h
index 1abb0ea..ce93061 100644
--- a/zconf.h
+++ b/zconf.h
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: zconf.h,v 1.11 1995/05/02 13:07:21 jloup Exp $ */
+/* $Id: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp $ */
 
 #ifndef _ZCONF_H
 #define _ZCONF_H
@@ -59,7 +59,7 @@
  for small objects.
 */
 
-			/* Type declarations */
+                        /* Type declarations */
 
 #ifndef __P /* function prototypes */
 #  ifdef STDC
diff --git a/zlib.h b/zlib.h
index 1712209..00a4394 100644
--- a/zlib.h
+++ b/zlib.h
@@ -1,5 +1,5 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 0.91 May 2nd, 1995.
+  version 0.92 May 3rd, 1995.
 
   Copyright (C) 1995 Jean-loup Gailly and Mark Adler
 
@@ -28,7 +28,7 @@
 
 #include "zconf.h"
 
-#define ZLIB_VERSION "0.91"
+#define ZLIB_VERSION "0.92"
 
 /* 
      The 'zlib' compression library provides in-memory compression and
@@ -103,7 +103,7 @@
    a single step).
 */
 
-			/* constants */
+                        /* constants */
 
 #define Z_NO_FLUSH      0
 #define Z_PARTIAL_FLUSH 1
@@ -142,7 +142,7 @@
    not compatible with the zlib.h header file used by the application.
  */
 
-			/* basic functions */
+                        /* basic functions */
 
 extern int deflateInit __P((z_stream *strm, int level));
 /* 
@@ -313,8 +313,8 @@
 */
 
 extern int deflateInit2 __P((z_stream *strm,
-			     int  level,
-			     int  method,
+                             int  level,
+                             int  method,
                              int  windowBits,
                              int  memLevel,
                              int  strategy));
diff --git a/zutil.c b/zutil.c
index 508ad62..2cddcff 100644
--- a/zutil.c
+++ b/zutil.c
@@ -3,7 +3,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: zutil.c,v 1.7 1995/05/02 15:54:47 jloup Exp $ */
+/* $Id: zutil.c,v 1.8 1995/05/03 17:27:12 jloup Exp $ */
 
 #include <stdio.h>
 
@@ -42,7 +42,7 @@
 {
     if (len == 0) return;
     do {
-	*dest++ = *source++; /* ??? to be unrolled */
+        *dest++ = *source++; /* ??? to be unrolled */
     } while (--len != 0);
 }
 
@@ -52,7 +52,7 @@
 {
     if (len == 0) return;
     do {
-	*dest++ = 0;  /* ??? to be unrolled */
+        *dest++ = 0;  /* ??? to be unrolled */
     } while (--len != 0);
 }
 #endif
@@ -91,10 +91,10 @@
     ulg bsize = (ulg)items*size;
 
     if (bsize < 65536L) {
-	buf = farmalloc(bsize);
-	if (*(ush*)&buf != 0) return buf;
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
     } else {
-	buf = farmalloc(bsize + 16L);
+        buf = farmalloc(bsize + 16L);
     }
     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
     table[next_ptr].org_ptr = buf;
@@ -110,19 +110,19 @@
 {
     int n;
     if (*(ush*)&ptr != 0) { /* object < 64K */
-	farfree(ptr);
-	return;
+        farfree(ptr);
+        return;
     }
     /* Find the original pointer */
     for (n = 0; n < next_ptr; n++) {
-	if (ptr != table[n].new_ptr) continue;
+        if (ptr != table[n].new_ptr) continue;
 
-	farfree(table[n].org_ptr);
-	while (++n < next_ptr) {
-	    table[n-1] = table[n];
-	}
-	next_ptr--;
-	return;
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
     }
     ptr = opaque; /* just to make some compilers happy */
     z_error("zcfree: ptr not found");
diff --git a/zutil.h b/zutil.h
index 503a445..bc8af52 100644
--- a/zutil.h
+++ b/zutil.h
@@ -8,13 +8,19 @@
    subject to change. Applications should only use zlib.h.
  */
 
-/* $Id: zutil.h,v 1.8 1995/05/02 15:44:46 jloup Exp $ */
+/* $Id: zutil.h,v 1.9 1995/05/03 17:27:12 jloup Exp $ */
 
 #ifndef _Z_UTIL_H
 #define _Z_UTIL_H
 
 #include "zlib.h"
 
+#ifdef __GNUC__
+#  define INLINE inline
+#else
+#  define INLINE
+#endif
+
 #ifdef MSDOS
 #   include <stddef.h>
 #   include <errno.h>
@@ -39,7 +45,7 @@
 #define ERR_RETURN(strm,err) return (strm->msg=z_errmsg[1-err], err)
 /* To be used only when the state is known to be valid */
 
-	/* common constants */
+        /* common constants */
 
 #define DEFLATED   8
 
@@ -62,7 +68,7 @@
 #define MAX_MATCH  258
 /* The minimum and maximum match lengths */
 
-	/* target dependencies */
+        /* target dependencies */
 
 #ifdef MSDOS
 #  define OS_CODE  0x00
@@ -107,7 +113,7 @@
 #  define OS_CODE  0x0a
 #endif
 
-	/* Common defaults */
+        /* Common defaults */
 
 #ifndef OS_CODE
 #  define OS_CODE  0x03  /* assume Unix */
@@ -126,7 +132,10 @@
 #  define zstrerror(errnum) ""
 #endif
 
-#if defined(STDC) && !defined(HAVE_MEMCPY)
+#if defined(pyr) && !defined(NO_MEMCPY)
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
 #  define HAVE_MEMCPY
 #endif
 #ifdef HAVE_MEMCPY