function gztell (file : gzFile) return Int;   function gzeof (file : gzFile) return Int;   function gzclose (file : gzFile) return Int;   function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;   function adler32     (adler : ULong;      buf   : Byte_Access;      len   : UInt)      return  ULong;   function crc32     (crc  : ULong;      buf  : Byte_Access;      len  : UInt)      return ULong;   function deflateInit     (strm        : Z_Streamp;      level       : Int;      version     : Chars_Ptr;      stream_size : Int)      return        Int;   function deflateInit2     (strm        : Z_Streamp;      level       : Int;      method      : Int;      windowBits  : Int;      memLevel    : Int;      strategy    : Int;      version     : Chars_Ptr;      stream_size : Int)      return        Int;   function Deflate_Init     (strm       : Z_Streamp;      level      : Int;      method     : Int;      windowBits : Int;      memLevel   : Int;      strategy   : Int)      return       Int;   pragma Inline (Deflate_Init);   function inflateInit     (strm        : Z_Streamp;      version     : Chars_Ptr;      stream_size : Int)      return        Int;   function inflateInit2     (strm        : in Z_Streamp;      windowBits  : in Int;      version     : in Chars_Ptr;      stream_size : in Int)      return      Int;   function inflateBackInit     (strm        : in Z_Streamp;      windowBits  : in Int;      window      : in Byte_Access;      version     : in Chars_Ptr;      stream_size : in Int)      return      Int;   --  Size of window have to be 2**windowBits.   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;   pragma Inline (Inflate_Init);   function zError (err : Int) return Chars_Ptr;   function inflateSyncPoint (z : Z_Streamp) return Int;   function get_crc_table return ULong_Access;   --  Interface to the available fields of the z_stream structure.   --  The application must update next_in and avail_in when avail_in has   --  dropped to zero. It must update next_out and avail_out when avail_out   --  has dropped to zero. The application must initialize zalloc, zfree and   --  opaque before calling the init function.   procedure Set_In     (Strm   : in out Z_Stream;      Buffer : in Voidp;      Size   : in UInt);   pragma Inline (Set_In);   procedure Set_Out     (Strm   : in out Z_Stream;      Buffer : in Voidp;      Size   : in UInt);   pragma Inline (Set_Out);   procedure Set_Mem_Func     (Strm   : in out Z_Stream;      Opaque : in Voidp;      Alloc  : in alloc_func;      Free   : in free_func);   pragma Inline (Set_Mem_Func);   function Last_Error_Message (Strm : in Z_Stream) return String;   pragma Inline (Last_Error_Message);   function Avail_Out (Strm : in Z_Stream) return UInt;   pragma Inline (Avail_Out);   function Avail_In (Strm : in Z_Stream) return UInt;   pragma Inline (Avail_In);   function Total_In (Strm : in Z_Stream) return ULong;   pragma Inline (Total_In);   function Total_Out (Strm : in Z_Stream) return ULong;   pragma Inline (Total_Out);   function inflateCopy     (dest   : in Z_Streamp;      Source : in Z_Streamp)      return Int;   function compressBound (Source_Len : in ULong) return ULong;   function deflateBound     (Strm       : in Z_Streamp;      Source_Len : in ULong)      return     ULong;   function gzungetc (C : in Int; File : in  gzFile) return Int;   function zlibCompileFlags return ULong;private   type Z_Stream is record            -- zlib.h:68      Next_In   : Voidp      := Nul;  -- next input byte      Avail_In  : UInt       := 0;    -- number of bytes available at next_in      Total_In  : ULong      := 0;    -- total nb of input bytes read so far      Next_Out  : Voidp      := Nul;  -- next output byte should be put there      Avail_Out : UInt       := 0;    -- remaining free space at next_out      Total_Out : ULong      := 0;    -- total nb of bytes output so far      msg       : Chars_Ptr;          -- last error message, NULL if no error      state     : Voidp;              -- not visible by applications      zalloc    : alloc_func := null; -- used to allocate the internal state      zfree     : free_func  := null; -- used to free the internal state      opaque    : Voidp;              -- private data object passed to                                      --  zalloc and zfree      data_type : Int;                -- best guess about the data type:                                      --  ascii or binary      adler     : ULong;              -- adler32 value of the uncompressed                                      --  data      reserved  : ULong;              -- reserved for future use   end record;   pragma Convention (C, Z_Stream);   pragma Import (C, zlibVersion, "zlibVersion");   pragma Import (C, Deflate, "deflate");   pragma Import (C, DeflateEnd, "deflateEnd");   pragma Import (C, Inflate, "inflate");   pragma Import (C, InflateEnd, "inflateEnd");   pragma Import (C, deflateSetDictionary, "deflateSetDictionary");   pragma Import (C, deflateCopy, "deflateCopy");   pragma Import (C, deflateReset, "deflateReset");   pragma Import (C, deflateParams, "deflateParams");   pragma Import (C, inflateSetDictionary, "inflateSetDictionary");   pragma Import (C, inflateSync, "inflateSync");   pragma Import (C, inflateReset, "inflateReset");   pragma Import (C, compress, "compress");   pragma Import (C, compress2, "compress2");   pragma Import (C, uncompress, "uncompress");   pragma Import (C, gzopen, "gzopen");   pragma Import (C, gzdopen, "gzdopen");   pragma Import (C, gzsetparams, "gzsetparams");   pragma Import (C, gzread, "gzread");   pragma Import (C, gzwrite, "gzwrite");   pragma Import (C, gzprintf, "gzprintf");   pragma Import (C, gzputs, "gzputs");   pragma Import (C, gzgets, "gzgets");   pragma Import (C, gzputc, "gzputc");   pragma Import (C, gzgetc, "gzgetc");   pragma Import (C, gzflush, "gzflush");   pragma Import (C, gzseek, "gzseek");   pragma Import (C, gzrewind, "gzrewind");   pragma Import (C, gztell, "gztell");   pragma Import (C, gzeof, "gzeof");   pragma Import (C, gzclose, "gzclose");   pragma Import (C, gzerror, "gzerror");   pragma Import (C, adler32, "adler32");   pragma Import (C, crc32, "crc32");   pragma Import (C, deflateInit, "deflateInit_");   pragma Import (C, inflateInit, "inflateInit_");   pragma Import (C, deflateInit2, "deflateInit2_");   pragma Import (C, inflateInit2, "inflateInit2_");   pragma Import (C, zError, "zError");   pragma Import (C, inflateSyncPoint, "inflateSyncPoint");   pragma Import (C, get_crc_table, "get_crc_table");   --  since zlib 1.2.0:   pragma Import (C, inflateCopy, "inflateCopy");   pragma Import (C, compressBound, "compressBound");   pragma Import (C, deflateBound, "deflateBound");   pragma Import (C, gzungetc, "gzungetc");   pragma Import (C, zlibCompileFlags, "zlibCompileFlags");   pragma Import (C, inflateBackInit, "inflateBackInit_");   --  I stopped binding the inflateBack routines, becouse realize that   --  it does not support zlib and gzip headers for now, and have no   --  symmetric deflateBack routines.   --  ZLib-Ada is symmetric regarding deflate/inflate data transformation   --  and has a similar generic callback interface for the   --  deflate/inflate transformation based on the regular Deflate/Inflate   --  routines.   --  pragma Import (C, inflateBack, "inflateBack");   --  pragma Import (C, inflateBackEnd, "inflateBackEnd");end ZLib.Thin;