diff --git a/ChangeLog b/ChangeLog
index 40fc89f..c0536d2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,10 @@
 		ChangeLog file for zlib
 
+Changes in 0.79 (28 April 95)
+- add fast inflate (inffast.c)
+- In gzio destroy(), don't reference a freed structure
+- avoid many warnings for MSDOS
+
 Changes in 0.71 (14 April 95)
 - Fixed more MSDOS compilation problems :( There is still a bug with
   TurboC large model.
diff --git a/Makefile b/Makefile
index 478920a..facba8a 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,7 @@
 RANLIB=ranlib
 
 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
+       zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o
 
 TEST_OBJS = example.o minigzip.o inftest.o
 
@@ -48,7 +48,8 @@
 example.o: zlib.h zconf.h
 gzio.o: zutil.h zlib.h zconf.h
 infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h
-infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h
+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
diff --git a/README b/README
index 5c42402..5705062 100644
--- a/README
+++ b/README
@@ -1,4 +1,4 @@
-zlib 0.71 is a beta version of a general purpose compression library.
+zlib 0.79 is a beta version of a general purpose compression library.
 
 The data format used by the zlib library is described in the
 file zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
@@ -9,16 +9,10 @@
 which also tests that the library is working correctly.
 To compile all files and run the test program, just type: make test
 
-The changes made in version 0.71 are documented in the file ChangeLog.
-The main changes since 0.5 are:
-- added full inflate support
-- added minigzip.c
-- added gzdopen to reopen a file descriptor as gzFile
-- added transparent reading of non-gziped files in gzread.
-- fix some MSDOS problems. example and minigzip now work on MSDOS.
-- Simplified the crc32() interface. The pre- and post-conditioning
-  (one's complement) is now done inside crc32(). WARNING: this is
-  incompatible with previous versions; see zlib.h for the new usage.
+The changes made in version 0.79 are documented in the file ChangeLog.
+The main changes since 0.71 are:
+- add fast inflate (inffast.c)
+- In gzio destroy(), don't reference a freed structure
 
 On MSDOS, this version works in large and small model with MSC; in
 small model only with TurboC (bug being investigated). For both
diff --git a/deflate.c b/deflate.c
index 2409f07..7d44627 100644
--- a/deflate.c
+++ b/deflate.c
@@ -47,7 +47,7 @@
  *
  */
 
-/* $Id: deflate.c,v 1.3 1995/04/10 16:03:45 jloup Exp $ */
+/* $Id: deflate.c,v 1.4 1995/04/14 19:49:46 jloup Exp $ */
 
 #include "deflate.h"
 
@@ -195,9 +195,11 @@
     s->noheader = noheader;
     s->w_bits = windowBits;
     s->w_size = 1 << s->w_bits;
+    s->w_mask = s->w_size - 1;
 
     s->hash_bits = memLevel + 7;
     s->hash_size = 1 << s->hash_bits;
+    s->hash_mask = s->hash_size - 1;
     s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
 
     s->window = (Byte*) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
diff --git a/example.c b/example.c
index ea1a9eb..86541a7 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.4 1995/04/14 13:32:49 jloup Exp $ */
+/* $Id: example.c,v 1.5 1995/04/14 20:35:56 jloup Exp $ */
 
 #include <stdio.h>
 #include "zlib.h"
@@ -60,7 +60,7 @@
     char *in;  /* input file */
 {
     local Byte uncompr[BUFLEN];
-    uLong uncomprLen = sizeof(uncompr);
+    int uncomprLen = sizeof(uncompr);
     int err;
     int len = strlen(hello)+1;
     gzFile file;
@@ -114,7 +114,7 @@
     c_stream.next_in  = (Byte*)hello;
     c_stream.next_out = compr;
 
-    while (c_stream.total_in != len) {
+    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");
diff --git a/gzio.c b/gzio.c
index b488e96..365b6f5 100644
--- a/gzio.c
+++ b/gzio.c
@@ -71,8 +71,9 @@
     if (s->file != NULL && fclose(s->file)) {
 	err = Z_ERRNO;
     }
+    if (s->z_err < 0) err = s->z_err;
     zcfree((voidp)0, s);
-    return s->z_err < 0 ? s->z_err : err;
+    return err;
 }
 
 /* ===========================================================================
@@ -235,9 +236,10 @@
 
     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) {
-	    *((Byte*)buf)++ = *s->stream.next_in++;
+	    *b++ = *s->stream.next_in++;
 	    s->stream.avail_in--;
 	    len--; n++;
 	}
@@ -364,7 +366,7 @@
 {
     int n;
     for (n = 0; n < 4; n++) {
-	fputc(x & 0xff, file);
+	fputc((int)(x & 0xff), file);
 	x >>= 8;
     }
 }
diff --git a/infblock.c b/infblock.c
index 3a58280..4d8bd48 100644
--- a/infblock.c
+++ b/infblock.c
@@ -60,16 +60,17 @@
       the two sets of lengths.
  */
 
-struct inflate_blocks_state *inflate_blocks_new(z,wsize)
+struct inflate_blocks_state *inflate_blocks_new(z, c, w)
 z_stream *z;
-uInt wsize;
+check_func c;
+uInt w;
 {
   struct inflate_blocks_state *s;
 
   if ((s = (struct inflate_blocks_state *)ZALLOC
        (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
     return s;
-  if ((s->window = (Byte *)ZALLOC(z,1,wsize)) == Z_NULL)
+  if ((s->window = (Byte *)ZALLOC(z, 1, w)) == Z_NULL)
   {
     ZFREE(z, s);
     return Z_NULL;
@@ -77,8 +78,10 @@
   s->mode = TYPE;
   s->bitk = 0;
   s->read = s->write = s->window;
-  s->end = s->window + wsize;
-  s->check = 1;
+  s->end = s->window + w;
+  s->checkfn = c;
+  if (s->checkfn != Z_NULL)
+    s->check = (*s->checkfn)(0L, Z_NULL, 0);
   return s;
 }
 
@@ -312,8 +315,9 @@
 uLong *c;
 int *e;
 {
-  *e = s->bitk > 7 ? (s->bitb >> (s->bitk & 7)) & 0xff : -1;
-  *c = s->check;
+  *e = (int)(s->bitk > 7 ? (s->bitb >> (s->bitk & 7)) & 0xff : -1);
+  if (s->checkfn != Z_NULL)
+    *c = s->check;
   if (s->mode == BTREE || s->mode == DTREE)
     ZFREE(z, s->sub.trees.blens);
   if (s->mode == CODES)
diff --git a/infblock.h b/infblock.h
index f70c471..a21d730 100644
--- a/infblock.h
+++ b/infblock.h
@@ -12,6 +12,7 @@
 
 extern struct inflate_blocks_state * inflate_blocks_new __P((
     z_stream *,
+    check_func checkfn,               /* check function */
     uInt));                     /* window size */
 
 extern int inflate_blocks __P((
diff --git a/infcodes.c b/infcodes.c
index ffae26d..489f9d6 100644
--- a/infcodes.c
+++ b/infcodes.c
@@ -6,6 +6,7 @@
 #include "zutil.h"
 #include "inftrees.h"
 #include "infutil.h"
+#include "inffast.h"
 #include "infcodes.h"
 
 /* simplify the use of the inflate_huft type with some defines */
@@ -98,7 +99,19 @@
   while (1) switch (c->mode)
   {		/* waiting for "i:"=input, "o:"=output, "x:"=nothing */
     case START:		/* x: set up for LEN */
-      /* %%% check for avail in and out to do fast loop %%% */
+#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 : BAD;
+	  break;
+	}
+      }
+#endif /* !SLOW */
       c->sub.code.need = c->lbits;
       c->sub.code.tree = c->ltree;
       c->mode = LEN;
@@ -112,14 +125,14 @@
         if (e == -128)		/* invalid code */
 	{
 	  c->mode = BAD;
-	  z->msg = "invalid huffman code";
+	  z->msg = "invalid literal/length code";
 	  r = Z_DATA_ERROR;
 	  LEAVE
 	}
 	e = -e;
 	if (e & 64)		/* end of block */
 	{
-	  c->mode = END;
+	  c->mode = WASH;
 	  break;
 	}
 	c->sub.code.need = e;
@@ -153,7 +166,7 @@
         if (e == -128)
 	{
 	  c->mode = BAD;
-	  z->msg = "invalid huffman code";
+	  z->msg = "invalid distance code";
 	  r = Z_DATA_ERROR;
 	  LEAVE
 	}
@@ -171,7 +184,7 @@
       DUMPBITS(j)
       c->mode = COPY;
     case COPY:		/* o: copying bytes in window, waiting for space */
-      f = q - s->window < c->sub.copy.dist ?
+      f = (uInt)(q - s->window) < c->sub.copy.dist ?
 	  s->end - (c->sub.copy.dist - (q - s->window)) :
 	  q - c->sub.copy.dist;
       while (c->len)
diff --git a/inffast.c b/inffast.c
new file mode 100644
index 0000000..8c3e4ce
--- /dev/null
+++ b/inffast.c
@@ -0,0 +1,148 @@
+/* inffast.c -- process literals and length/distance pairs fast
+ * Copyright (C) 1995 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infutil.h"
+#include "inffast.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define base more.Base
+#define next more.Next
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* macros for bit input with no checking and for returning unused bytes */
+#ifdef DEBUG
+#  undef NEXTBYTE
+#  define NEXTBYTE (n--?0:fprintf(stderr,"inffast underrun\n"),*p++)
+#endif
+#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define UNGRAB {n+=(c=k>>3);p-=c;k&=7;}
+
+/* Called with number of bytes left to write in window at least 258
+   (the maximum string length) and number of input bytes available
+   at least ten.  The ten bytes are six bytes for the longest length/
+   distance pair plus four bytes for overloading the bit buffer. */
+
+int inflate_fast(bl, bd, tl, td, s, z)
+uInt bl, bd;
+inflate_huft *tl, *td;
+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 */
+
+  /* load input, output, bit values */
+  LOAD
+
+  /* initialize masks in registers */
+  ml = inflate_mask[bl];
+  md = inflate_mask[bd];
+
+  /* do until not enough input or output space for fast loop */
+  do {				/* assume called with m >= 258 && n >= 10 */
+    /* get 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";
+          UNGRAB
+	  UPDATE
+	  return Z_DATA_ERROR;
+	}
+	DUMPBITS(t->bits)
+	e = -e;
+	if (e & 64)		/* end of block */
+	{
+          UNGRAB
+	  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 */
+    {
+      *q++ = (Byte)t->base;
+      m--;
+    }
+    else			/* it's a length */
+    {
+      /* get length of block to copy (already have extra bits) */
+      c = t->base + ((uInt)b & inflate_mask[e]);
+      DUMPBITS(e);
+
+      /* decode distance base of block to copy */
+      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);
+      DUMPBITS(t->bits)
+
+      /* get extra bits to add to distance base */
+      GRABBITS(e)           /* get extra bits (up to 13) */
+      d = t->base + ((uInt)b & inflate_mask[e]);
+      DUMPBITS(e)
+
+      /* do the copy */
+      m -= c;
+      if (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 */
+      {
+	e = d - (q - s->window);	/* bytes from offset to end */
+	r = s->end - e;			/* pointer to offset */
+	if (c > 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);
+
+  /* not enough input or output--restore pointers and return */
+  UNGRAB
+  UPDATE
+  return Z_OK;
+}
diff --git a/inffast.h b/inffast.h
new file mode 100644
index 0000000..2c05820
--- /dev/null
+++ b/inffast.h
@@ -0,0 +1,17 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+extern int inflate_fast __P((
+    uInt,
+    uInt,
+    inflate_huft *,
+    inflate_huft *,
+    struct inflate_blocks_state *,
+    z_stream *));
diff --git a/inflate-0.72.c b/inflate-0.72.c
new file mode 100644
index 0000000..56b0665
--- /dev/null
+++ b/inflate-0.72.c
@@ -0,0 +1,230 @@
+/* inflate.c -- zlib interface to inflate modules
+ * Copyright (C) 1995 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+
+struct inflate_blocks_state {int dummy;}; /* for buggy compilers */
+
+/* inflate private state */
+struct internal_state {
+
+  /* mode */
+  enum {
+      METHOD,	/* waiting for method byte */
+      FLAG,	/* waiting for flag byte */
+      START,	/* make new blocks state */
+      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 */
+      ERROR}	/* got an error--stay here */
+    mode;		/* current inflate mode */
+
+  /* mode dependent information */
+  union {
+    uInt method;	/* if FLAGS, method byte */
+    struct inflate_blocks_state
+      *blocks;		/* if BLOCKS, current state */
+    struct {
+      uLong was;		/* computed check value */
+      uLong need;		/* stream check value */
+    } check;		/* if CHECK, check values to compare */
+  } sub;	/* submode */
+
+  /* mode independent information */
+  int  nowrap;		/* flag for no wrapper */
+  uInt wbits;  		/* log2(window size)  (8..15, defaults to 15) */
+
+};
+
+
+int inflateInit(z)
+z_stream *z;
+{
+    return inflateInit2(z, WBITS);
+}
+
+
+int inflateInit2(z, w)
+z_stream *z;
+int w;
+{
+  /* initialize state */
+  if (z == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->zalloc == Z_NULL) z->zalloc = zcalloc;
+  if (z->zfree == Z_NULL) z->zfree = zcfree;
+  z->total_in = z->total_out = 0;
+  z->msg = Z_NULL;
+  if ((z->state = (struct internal_state *)
+       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
+    return Z_MEM_ERROR;
+  z->state->mode = METHOD;
+
+  /* handle undocumented nowrap option (no zlib header or check) */
+  z->state->nowrap = 0;
+  if (w < 0)
+  {
+    w = - w;
+    z->state->nowrap = 1;
+    z->state->mode = START;
+  }
+
+  /* set window size */
+  if (w < 8 || w > 15)
+  {
+    inflateEnd(z);
+    return Z_STREAM_ERROR;
+  }
+  z->state->wbits = w;
+  return Z_OK;
+}
+
+
+#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
+
+int inflate(z, f)
+z_stream *z;
+int f;
+{
+  int r;
+  uInt b;
+  uLong c;
+
+  if (z == Z_NULL || z->next_in == Z_NULL)
+    return Z_STREAM_ERROR;
+  r = Z_BUF_ERROR;
+  while (1) switch (z->state->mode)
+  {
+    case METHOD:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      if (((z->state->sub.method = NEXTBYTE) & 0xf != DEFLATED))
+      {
+        z->state->mode = ERROR;
+	z->msg = "unknown compression method";
+	return Z_DATA_ERROR;
+      }
+      if ((z->state->sub.method >> 4) > z->state->wbits)
+      {
+        z->state->mode = ERROR;
+	z->msg = "invalid window size";
+	return Z_DATA_ERROR;
+      }
+      z->state->mode = FLAG;
+    case FLAG:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      if ((b = NEXTBYTE) & 0x20)
+      {
+        z->state->mode = ERROR;
+	z->msg = "invalid reserved bit";
+	return Z_DATA_ERROR;
+      }
+      if (((z->state->sub.method << 8) + b) % 31)
+      {
+        z->state->mode = ERROR;
+	z->msg = "incorrect header check";
+	return Z_DATA_ERROR;
+      }
+      z->state->mode = START;
+    case START:
+      if ((z->state->sub.blocks =
+           inflate_blocks_new(z,1<< z->state->wbits)) == Z_NULL)
+        return Z_MEM_ERROR;
+      z->state->mode = BLOCKS;
+    case BLOCKS:
+      if ((r = inflate_blocks(z->state->sub.blocks, z, r)) != Z_STREAM_END)
+        return r;
+      inflate_blocks_free(z->state->sub.blocks, z, &c, &r);
+      if (z->state->nowrap)
+      {
+        if (r != -1)
+	  z->msg = "inflate bug--took one too many bytes";
+	z->state->mode = r == -1 ? DONE : ERROR;
+	break;
+      }
+      z->state->sub.check.was = c;
+      if (r != -1)
+      {
+	z->state->sub.check.need = (uLong)r << 24;
+        z->state->mode = CHECK3;
+        r = Z_OK;
+	break;
+      }
+      r = Z_OK;
+      z->state->mode = CHECK4;
+    case CHECK4:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = CHECK3;
+    case CHECK3:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = CHECK2;
+    case CHECK2:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = CHECK1;
+    case CHECK1:
+      if (z->avail_in == 0) return r;  r = Z_OK;
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+      if (z->state->sub.check.was != z->state->sub.check.need)
+      {
+        z->state->mode = ERROR;
+        z->msg = "incorrect data check";
+	return Z_DATA_ERROR;
+      }
+      z->state->mode = DONE;
+    case DONE:
+      return Z_STREAM_END;
+    case ERROR:
+      return Z_DATA_ERROR;
+    default:
+      return Z_STREAM_ERROR;
+  }
+}
+
+
+int inflateEnd(z)
+z_stream *z;
+{
+  uLong c;
+  int e;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->mode == BLOCKS)
+    inflate_blocks_free(z->state->sub.blocks, z, &c, &e);
+  ZFREE(z, z->state);
+  z->state = Z_NULL;
+  return Z_OK;
+}
+
+
+/* inflateSync not implemented yet--this just consumes input */
+int inflateSync(z)
+z_stream *z;
+{
+  if (z == Z_NULL) return Z_STREAM_ERROR;
+  if (z->avail_in == 0) return Z_BUF_ERROR;
+  do {
+    z->total_in++;
+  } while (--z->avail_in);
+  return Z_DATA_ERROR;
+}
+
+
+/* inflateReset not fully implemented yet--this frees and reallocates */
+int inflateReset(z)
+z_stream *z;
+{
+  int r;
+
+  if ((r = inflateEnd(z)) != Z_OK)
+    return r;
+  return inflateInit(z);
+}
diff --git a/inflate.c b/inflate.c
index 478f46d..38d70cc 100644
--- a/inflate.c
+++ b/inflate.c
@@ -25,10 +25,6 @@
       ERROR}	/* got an error--stay here */
     mode;		/* current inflate mode */
 
-  int  no_header;
-  uInt w_size;  /* LZ77 window size (32K by default) */
-  uInt w_bits;  /* log2(w_size)  (8..16) */
-
   /* mode dependent information */
   union {
     uInt method;	/* if FLAGS, method byte */
@@ -39,19 +35,26 @@
       uLong need;		/* stream check value */
     } check;		/* if CHECK, check values to compare */
   } sub;	/* submode */
+
+  /* mode independent information */
+  int  nowrap;		/* flag for no wrapper */
+  uInt wbits;  		/* log2(window size)  (8..15, defaults to 15) */
+
 };
 
 
-int inflateInit (strm)
-z_stream *strm;
+int inflateInit(z)
+z_stream *z;
 {
-    return inflateInit2(strm, WBITS);
+    return inflateInit2(z, WBITS);
 }
 
-int inflateInit2(z, windowBits)
+
+int inflateInit2(z, w)
 z_stream *z;
-int windowBits;
+int w;
 {
+  /* initialize state */
   if (z == Z_NULL)
     return Z_STREAM_ERROR;
   if (z->zalloc == Z_NULL) z->zalloc = zcalloc;
@@ -63,19 +66,22 @@
     return Z_MEM_ERROR;
   z->state->mode = METHOD;
 
-  z->state->no_header = 0;
-  if (windowBits < 0) { /* undocumented feature: no zlib header */
-    windowBits = - windowBits;
-    z->state->no_header = 1;
-    z->state->sub.method = DEFLATED;
+  /* handle undocumented nowrap option (no zlib header or check) */
+  z->state->nowrap = 0;
+  if (w < 0)
+  {
+    w = - w;
+    z->state->nowrap = 1;
     z->state->mode = START;
   }
-  if (windowBits < 8 || windowBits > 15) {
+
+  /* set window size */
+  if (w < 8 || w > 15)
+  {
     inflateEnd(z);
     return Z_STREAM_ERROR;
   }
-  z->state->w_bits = windowBits;
-  z->state->w_size = 1<<windowBits;
+  z->state->wbits = w;
   return Z_OK;
 }
 
@@ -103,7 +109,7 @@
 	z->msg = "unknown compression method";
 	return Z_DATA_ERROR;
       }
-      if ((z->state->sub.method >> 4) > z->state->w_bits)
+      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
       {
         z->state->mode = ERROR;
 	z->msg = "invalid window size";
@@ -126,17 +132,21 @@
       }
       z->state->mode = START;
     case START:
-      if ((z->state->sub.blocks = inflate_blocks_new(z,z->state->w_size))
-	  == Z_NULL)
+      if ((z->state->sub.blocks = inflate_blocks_new(z,
+         z->state->nowrap ? Z_NULL : adler32,
+         1<< z->state->wbits)) == Z_NULL)
         return Z_MEM_ERROR;
       z->state->mode = BLOCKS;
     case BLOCKS:
       if ((r = inflate_blocks(z->state->sub.blocks, z, r)) != Z_STREAM_END)
         return r;
       inflate_blocks_free(z->state->sub.blocks, z, &c, &r);
-      if (z->state->no_header) {
-	z->state->mode = DONE;
-	return Z_STREAM_END;
+      if (z->state->nowrap)
+      {
+        if (r != -1)
+	  z->msg = "inflate bug--took one too many bytes";
+	z->state->mode = r == -1 ? DONE : ERROR;
+	break;
       }
       z->state->sub.check.was = c;
       if (r != -1)
diff --git a/inflate.h b/inflate.h
deleted file mode 100644
index 843224f..0000000
--- a/inflate.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/* temporary kludge assuming single pass decompression */
-
-/* $Id: inflate.h,v 1.2 1995/04/11 14:47:32 jloup Exp $ */
-
-#include <stdio.h>
-
-#define NEXTBYTE \
-   (istrm->total_in++, istrm->avail_in-- == 0 ? \
-      (z_error("too small"), 0) : *istrm->next_in++)
-
-#define FLUSH(n) { \
-   if (istrm->avail_out < n) z_error("too big"); \
-   istrm->avail_out -= n; \
-   memcpy(istrm->next_out, slide, n); \
-   istrm->next_out += n; \
-   istrm->total_out += n; \
-}
-#define WSIZE istrm->state->w_size
-#define slide istrm->state->window
-#define memzero(a,s) memset((a),0,(s))
-#define inflate z_inflate
-#define qflag 1
diff --git a/inftrees.c b/inftrees.c
index 4b00e3c..54c7c8e 100644
--- a/inftrees.c
+++ b/inftrees.c
@@ -246,7 +246,7 @@
         {
           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.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 */
diff --git a/infutil.c b/infutil.c
index 92d115f..1adadbf 100644
--- a/infutil.c
+++ b/infutil.c
@@ -40,7 +40,8 @@
   z->total_out += n;
 
   /* update check information */
-  s->check = adler32(s->check, q, n);
+  if (s->checkfn != Z_NULL)
+    s->check = (*s->checkfn)(s->check, q, n);
 
   /* copy as far as end of window */
   while (n--) *p++ = *q++;
@@ -48,8 +49,10 @@
   /* see if more to copy at beginning of window */
   if (q == s->end)
   {
-    /* wrap source pointer */
+    /* wrap pointers */
     q = s->window;
+    if (s->write == s->end)
+      s->write = s->window;
 
     /* compute bytes to copy */
     n = s->write - q;
@@ -61,7 +64,8 @@
     z->total_out += n;
 
     /* update check information */
-    s->check = adler32(s->check, q, n);
+    if (s->checkfn != Z_NULL)
+      s->check = (*s->checkfn)(s->check, q, n);
 
     /* copy */
     while (n--) *p++ = *q++;
diff --git a/infutil.h b/infutil.h
index af07372..30b230d 100644
--- a/infutil.h
+++ b/infutil.h
@@ -47,6 +47,7 @@
   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 */
 
 };
diff --git a/minigzip.c b/minigzip.c
index 688b3a1..4936d64 100644
--- a/minigzip.c
+++ b/minigzip.c
@@ -13,13 +13,15 @@
  * or in pipe mode.
  */
 
-/* $Id: minigzip.c,v 1.1 1995/04/14 13:35:59 jloup Exp $ */
+/* $Id: minigzip.c,v 1.2 1995/04/14 20:03:12 jloup Exp $ */
 
 #include <stdio.h>
 #include "zlib.h"
 
+extern void exit __P((int));
+
 #ifdef MSDOS
-#  include <fcntl.h>
+#  include <fcntl.h> /* ??? find where setmode declared */
 #  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
 #else
 #  define SET_BINARY_MODE(file)
@@ -87,7 +89,7 @@
 	if (len < 0) error (gzerror(in, &err));
 	if (len == 0) break;
 
-	if (fwrite(buf, 1, len, out) != len) error("failed fwrite");
+	if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite");
     }
     if (fclose(out)) error("failed fclose");
 
diff --git a/trees.c b/trees.c
index 79cab9f..62411a7 100644
--- a/trees.c
+++ b/trees.c
@@ -1011,7 +1011,7 @@
     if (s->bi_valid > 8) {
         put_short(s, s->bi_buf);
     } else if (s->bi_valid > 0) {
-        put_byte(s, s->bi_buf);
+        put_byte(s, (Byte)s->bi_buf);
     }
     s->bi_buf = 0;
     s->bi_valid = 0;
diff --git a/zconf.h b/zconf.h
index 29496d7..f08793b 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.7 1995/04/12 20:42:28 jloup Exp $ */
+/* $Id: zconf.h,v 1.8 1995/04/14 20:59:22 jloup Exp $ */
 
 #ifndef _ZCONF_H
 #define _ZCONF_H
diff --git a/zlib.h b/zlib.h
index d1f2ca9..6983fb7 100644
--- a/zlib.h
+++ b/zlib.h
@@ -1,5 +1,5 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 0.7  April 14th, 1995.
+  version 0.79  April 28th, 1995.
 
   Copyright (C) 1995 Jean-loup Gailly and Mark Adler
 
@@ -28,7 +28,7 @@
 
 #include "zconf.h"
 
-#define ZLIB_VERSION "0.7"
+#define ZLIB_VERSION "0.79"
 
 /* 
      The 'zlib' compression library provides in-memory compression and
@@ -88,7 +88,7 @@
 
    zalloc must return Z_NULL if there is not enough memory for the object.
    On 16-bit systems, the functions zalloc and zfree must be able to allocate
-   exactly 65536 bytes, but will not be require to allocate more than this
+   exactly 65536 bytes, but will not be required to allocate more than this
    if the symbol MAXSEG_64K is defined (see zconf.h).
 
    The fields total_in and total_out can be used for statistics or
@@ -152,10 +152,10 @@
    to level 6).
 
      deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the stream state was inconsistent (such
-   as zalloc being NULL). msg is set to null if there is no error message.
-   deflateInit does not perform any compression: this will be done by
-   deflate().  */
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level.
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
 
 
 extern int deflate __P((z_stream *strm, int flush));
@@ -164,8 +164,8 @@
 
   - Compress more input starting at next_in and update next_in and avail_in
     accordingly. If not all input can be processed (because there is not
-    enough room in the output buffer), next_in is updated and processing
-    will resume at this point for the next call of deflate().
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
 
   - Provide more output starting at next_out and update next_out and avail_out
     accordingly. This action is forced if the parameter flush is non zero.
@@ -175,20 +175,21 @@
 
   Before the call of deflate(), the application should ensure that at least
   one of the actions is possible, by providing more input and/or consuming
-  more output, and updating avail_in or avail_out accordingly.
-  The application can consume the compressed output when the output
-  buffer is full (avail_out == 0), or after each call of deflate().
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate().
 
     If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression
-  block is byte aligned and flushed to the output buffer so that the
-  decompressor can get all input data available so far; if the compression
-  method is 8 (deflate without partial flush capability), the current block
-  is terminated. If flush is set to Z_FULL_FLUSH, the compression block is
-  terminated, a special marker is output and the compression dictionary is
-  discarded; this is useful to allow the decompressor to synchronize if one
-  compressed block has been damaged.
-    Flushing degrades compression and so should be used only when necessary.
-  Using Z_FULL_FLUSH too often can seriously degrade the compression.
+  block is terminated and flushed to the output buffer so that the
+  decompressor can get all input data available so far. For method 9, a future
+  variant on method 8, the current block will be flushed but not terminated.
+  If flush is set to Z_FULL_FLUSH, the compression block is terminated, a
+  special marker is output and the compression dictionary is discarded; this
+  is useful to allow the decompressor to synchronize if one compressed block
+  has been damaged (see inflateSync below).  Flushing degrades compression and
+  so should be used only when necessary.  Using Z_FULL_FLUSH too often can
+  seriously degrade the compression.
 
     If the parameter flush is set to Z_FINISH, all pending input is
   processed and all pending output is flushed. The next operation on this
@@ -197,19 +198,18 @@
   or a call of deflateEnd to deallocate the compression state. Z_FINISH can
   be used immediately after deflateInit if all the compression is to be
   done in a single step. In this case, avail_out must be at least 0.1%
-  larger than avail_in plus 8 bytes.
+  larger than avail_in plus 12 bytes.
 
-    deflate() may update strm->data_type if it can make a good guess about
+    deflate() may update data_type if it can make a good guess about
   the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
   binary. This field is only for information purposes and does not affect
   the compression algorithm in any manner.
 
-    deflate() return Z_OK if some progress has been made (more input processed
+    deflate() returns Z_OK if some progress has been made (more input processed
   or more output produced), Z_STREAM_ERROR if the stream state was
   inconsistent (for example if next_in or next_out was NULL), Z_BUF_ERROR if
   no progress is possible or if there was not enough room in the output buffer
-  when Z_FINISH is used.
-*/
+  when Z_FINISH is used. ??? to be changed (use Z_STEAM_END) */
 
 
 extern int deflateEnd __P((z_stream *strm));
@@ -232,8 +232,7 @@
    functions.
 
      inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the stream state was inconsistent (such
-   as zalloc being NULL). msg is set to null if there is no error message.
+   enough memory.  msg is set to null if there is no error message.
    inflateInit does not perform any decompression: this will be done by
    inflate().
 */
@@ -255,8 +254,9 @@
   Before the call of inflate(), the application should ensure that at least
   one of the actions is possible, by providing more input and/or consuming
   more output, and updating the next_* and avail_* values accordingly.
-  The application can consume the uncompressed output when the output
-  buffer is full (avail_out == 0), or after each call of inflate().
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate().
 
     If the parameter flush is set to Z_PARTIAL_FLUSH, inflate flushes as much
   output as possible to the output buffer. The flushing behavior of inflate is
@@ -275,13 +275,13 @@
 
     inflate() returns Z_OK if some progress has been made (more input
   processed or more output produced), Z_STREAM_END if the end of the
-  compressed data has been reached, Z_DATA_ERROR if the input data was
-  corrupted, Z_STREAM_ERROR if the stream structure was inconsistent (for
-  example if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough
-  memory, Z_BUF_ERROR if no progress is possible or if there was not enough
-  room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR case,
-  the application may then call inflateSync to look for a good compression
-  block.
+  compressed data has been reached and all uncompressed output has been
+  produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
+  the stream structure was inconsistent (for example if next_in or next_out
+  was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
+  progress is possible or if there was not enough room in the output buffer
+  when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
+  call inflateSync to look for a good compression block.
 */
 
 
@@ -318,9 +318,9 @@
 
      The windowBits parameter is the base two logarithm of the window size
    (the size of the history buffer).  It should be in the range 8..15 for this
-   version of the library (the value 16 will be allowed soon). Larger values
-   of this parameter result in better compression at the expense of memory
-   usage. The default value is 15 if deflateInit is used instead.
+   version of the library (the value 16 will be allowed for method 9). Larger
+   values of this parameter result in better compression at the expense of
+   memory usage. The default value is 15 if deflateInit is used instead.
 
     The memLevel parameter specifies how much memory should be allocated
    for the internal compression state. memLevel=1 uses minimum memory but
@@ -338,8 +338,8 @@
 
      If next_in is not null, the library will use this buffer to hold also
    some history information; the buffer must either hold the entire input
-   data, or have at least (1<<windowBits) bytes and be writable. If next_in is
-   null, the library will allocate its own history buffer (and leave next_in
+   data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in
+   is null, the library will allocate its own history buffer (and leave next_in
    null). next_out need not be provided here but must be provided by the
    application for the next call of deflate().
 
@@ -350,8 +350,7 @@
    reset by the library in this case.
 
       deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
-   not enough memory, Z_STREAM_ERROR if the stream state was inconsistent
-   (such as zalloc being NULL) or the parameters are invalid (such as
+   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
    an invalid method). msg is set to null if there is no error message.
    deflateInit2 does not perform any compression: this will be done by
    deflate().
@@ -406,7 +405,7 @@
 
      If next_out is not null, the library will use this buffer for the history
    buffer; the buffer must either be large enough to hold the entire output
-   data, or have at least 1<<(windowBits-1) bytes.  If next_out is null, the
+   data, or have at least 1<<windowBits bytes.  If next_out is null, the
    library will allocate its own buffer (and leave next_out null). next_in
    need not be provided here but must be provided by the application for the
    next call of inflate().
@@ -418,9 +417,8 @@
    avail_out is zero and all output has been consumed.
 
       inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
-   not enough memory, Z_STREAM_ERROR if the stream state was inconsistent
-   (such as zalloc being NULL) or the parameters are invalid (such as
-   windowBits < 9). msg is set to null if there is no error message.
+   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
+   windowBits < 8). msg is set to null if there is no error message.
    inflateInit2 does not perform any compression: this will be done by
    inflate().
 */
@@ -585,7 +583,7 @@
 /*
      Update a running crc with the bytes buf[0..len-1] and return the updated
    crc. If buf is NULL, this function returns the required initial value
-   for the crc (0). Pre- and post-conditioning (one's complement) is performed
+   for the crc. Pre- and post-conditioning (one's complement) is performed
    within this function so it shouldn't be done by the application.
    Usage example:
 
diff --git a/zutil.c b/zutil.c
index 1a2e7ef..9fd4ecc 100644
--- a/zutil.c
+++ b/zutil.c
@@ -3,12 +3,14 @@
  * For conditions of distribution and use, see copyright notice in zlib.h 
  */
 
-/* $Id: zutil.c,v 1.3 1995/04/10 09:52:26 jloup Exp $ */
+/* $Id: zutil.c,v 1.5 1995/04/14 21:30:23 jloup Exp $ */
 
 #include <stdio.h>
 
 #include "zutil.h"
 
+extern void exit __P((int));
+
 char *zlib_version = ZLIB_VERSION;
 
 char *z_errmsg[] = {
@@ -136,7 +138,7 @@
 
 void  zcfree (voidp opaque, voidp ptr)
 {
-    return _hfree(ptr);
+    _hfree(ptr);
 }
 
 #  endif /* __TURBOC__ ? */
diff --git a/zutil.h b/zutil.h
index a1108e6..20b20f5 100644
--- a/zutil.h
+++ b/zutil.h
@@ -8,7 +8,7 @@
    subject to change. Applications should only use zlib.h.
  */
 
-/* $Id: zutil.h,v 1.4 1995/04/14 10:22:17 jloup Exp $ */
+/* $Id: zutil.h,v 1.5 1995/04/14 21:22:38 jloup Exp $ */
 
 #ifndef _Z_UTIL_H
 #define _Z_UTIL_H
@@ -20,6 +20,10 @@
 #else
     extern int errno;
 #endif
+#ifdef __STDC__
+#  include <string.h>
+#  include <memory.h>
+#endif
 
 #ifndef local
 #  define local static
@@ -154,13 +158,16 @@
 #endif
 
 
+typedef uLong (*check_func) __P((uLong check, Byte *buf, uInt len));
+
 extern void z_error    __P((char *m));
 
 voidp zcalloc __P((voidp opaque, unsigned items, unsigned size));
 void  zcfree  __P((voidp opaque, voidp ptr));
 
-#define ZALLOC(strm, items, size) (*strm->zalloc)(strm->opaque, items, size)
-#define ZFREE(strm, addr)         (*strm->zfree) (strm->opaque, (voidp)addr)
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidp)(addr))
 #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
 
 #endif /* _Z_UTIL_H */