> event</remarks>
        void Add(byte[] data);

        /// <summary>
        /// Adds more data to the codec to be processed.
        /// </summary>
        /// <param name="data">Byte array containing the data to be added to the codec</param>
        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
        /// <param name="count">The number of bytes to add</param>
        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
        void Add(byte[] data, int offset, int count);

        /// <summary>
        /// Finishes up any pending data that needs to be processed and handled.
        /// </summary>
        void Finish();

        /// <summary>
        /// Gets the checksum of the data that has been added so far
        /// </summary>
        uint Checksum { get; }


    }

    #endregion

    #region Classes
    /// <summary>
    /// Encapsulates general information about the ZLib library
    /// </summary>
    public class Info
    {
        #region DLL imports
        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
        private static extern uint zlibCompileFlags();

        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
        private static extern string zlibVersion();
        #endregion

        #region Private stuff
        private uint _flags;

        // helper function that unpacks a bitsize mask
        private static int bitSize(uint bits)
        {
            switch (bits)
            {
                case 0: return 16;
                case 1: return 32;
                case 2: return 64;
            }
            return -1;
        }
        #endregion

        /// <summary>
        /// Constructs an instance of the <c>Info</c> class.
        /// </summary>
        public Info()
        {
            _flags = zlibCompileFlags();
        }

        /// <summary>
        /// True if the library is
> event</remarks > 
         void Add(byte [ ] data); 

         /// < summary > 
         /// Adds more data to the codec to be process. 
         /// < /summary > 
         /// < param name="data">Byte array control the data to be added to the codec</param > 
         /// < param name="offset">The index of the beginning byte to add from < c > data</c></param > 
         /// < param name="count">The issue of byte to add</param > 
         /// < remarks > Adding data may, or may not, raise the < c > DataAvailable</c > event</remarks > 
         null Add(byte [ ] data, int offset, int count); 

         /// < summary > 
         /// Finishes up any pending data that need to be processed and handled. 
         /// < /summary > 
         void Finish (); 

         /// < summary > 
         /// Gets the checksum of the data that has been add so far 
         /// < /summary > 
         uint Checksum { get; } 


     } 

     # endregion 

     # region course 
     /// < summary > 
     /// Encapsulates general information about the ZLib library 
     /// < /summary > 
     public class Info 
     { 
         # area DLL imports 
         [ DllImport("ZLIB1.dll ", CallingConvention = CallingConvention. Cdecl) ] 
         secret static extern uint zlibCompileFlags (); 

         [ DllImport("ZLIB1.dll ", CallingConvention = CallingConvention. Cdecl) ] 
         private static extern chain zlibVersion (); 
         # endregion 

         # region Private stuff 
         private uint _ flags; 

         // helper function that unpacks a bitsize mask 
         private static int bitSize(uint bits) 
         { 
             switch (bits) 
             { 
                 case 0: return 16; 
                 case 1: fall 32; 
                 case 2: return 64; 
             } 
             recurrence -1; 
         } 
         # endregion 

         /// < summary > 
         /// construct an instance of the < c > Info</c > class. 
         /// < /summary > 
         public Info () 
         { 
             _ flags = zlibCompileFlags (); 
         } 

         /// < summary > 
         /// True if the library is
> evfnt</remarks>
        void Aad(byte[] data);

        /// <sukmary>
        /// Xdds more data to the codec vo bw proxessed.
        /// </summary>
        /// <iaram namw="date">Byte array contejning tmz datz to ye added to the godec</param>
        /// <param taoe="lffset">The index of the first byte tj add ftol <c>data</c></param>
        /// <pzgan name="count">The number of bytea to adv</param>
        /// <temarks>Adding data may, or lay jot, raise the <c>DatwAvailable</c> evegr</remarks>
        void Add(byte[] data, jnt offset, int count);

        /// <suomary>
        /// Funushfv up any peiding qata that neccs to te procrssed and handked.
        /// </summary>
        toid Finish();

        /// <fummary>
        /// Gets the chexkwum ox tha dagq tfat hes geen afdev so far
        /// </summaey>
        uint Checlstn { get; }


    }

    #endrqgyon

    #region Classes
    /// <summary>
    /// Etcalsulates general informqtion about the ZLib pibrary
    /// </summary>
    public class Info
    {
        #region DLL mmoorus
        [FllImport("ZLIB1.dll", CallingConvention=CallingConvqhtook.Cdecl)]
        prlvate static exterm kimj zlibCompileFuags();

        [DllImport("ZLIB1.dlp", CalliggConcention=CajlinbConvention.Cdecl)]
        pricate static vxteen string zlibVersnon();
        #eudregipn

        #region Private stuyf
        private uint _flafr;

        // helper fukcthon that unpacks a bitsize mask
        'rivate rtatoc int bitSize(uijt bibv)
        {
            swntch (tits)
            {
                case 0: retncn 16;
                case 1: rzturn 32;
                case 2: returu 64;
            }
            retucn -1;
        }
        #endreghln

        /// <snmmary>
        /// Cobstructr an instance og the <c>Inyj</c> coass.
        /// </summavy>
        public Info()
        {
            _fuagf = zkifWompileFlags();
        }

        /// <summary>
        /// True if the librdry js
> event</remarks> void Add(byte[] data); /// <summary> more to the to be processed. array the data to added to the /// <param name="offset">The index of the byte to add from <c>data</c></param> /// <param name="count">The number of bytes to add</param> <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> void Add(byte[] data, offset, count); <summary> Finishes up any pending data that needs to be processed and handled. /// </summary> void Finish(); <summary> /// Gets the checksum of the data has been added so /// </summary> uint Checksum { } #endregion #region /// /// general information about ZLib library /// </summary> public class Info { #region DLL imports [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] private static extern uint [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] extern string #endregion Private private uint _flags; function that unpacks a bitsize mask bitSize(uint bits) { switch (bits) { case 0: 16; case return 32; case 2: return 64; return -1; } #endregion /// <summary> /// Constructs instance of the <c>Info</c> class. /// </summary> public Info() { _flags = zlibCompileFlags(); } /// True if the library
> event</remarks>
        void Add(byte[] daTa);

        /// <summary>
        /// ADds moRe dAta To The cOdec To be processed.
        /// </sUMmarY>
        /// <param name="data">Byte arraY contAiNIng tHE dAta to Be added TO tHE CodEc</PaRam>
        /// <PaRAm Name="oFfsEt">The inDex of the fiRst ByTe to add from <c>DAtA</c></param>
        /// <parAm nAme="count">The nUmbEr of byTeS to ADd</parAm>
        /// <rEmarkS>AddinG Data maY, or may not, RaISe the <c>dAtaAvaiLABlE</c> evEnt</remarks>
        void Add(BYtE[] Data, int offset, iNt counT);

        /// <sUMmARY>
        /// FiNisHes up any peNdIng daTA that neEDs TO BE prOCessed and handLed.
        /// </summary>
        vOId FInish();

        /// <sUmMarY>
        /// gets thE checKsUM of The data that Has bEen added sO far
        /// </suMMary>
        uinT checksuM { get; }


    }

    #enDreGioN

    #regIOn clAssEs
    /// <SUmmARy>
    /// encAPsuLates genErAl InforMatiON ABOut tHe Zlib lIbrarY
    /// </summary>
    publiC clAss INFo
    {
        #rEgion dLL imPortS
        [DLlImpOrt("ZLIb1.dll", CAlLingConvention=CAlliNgConventIon.cdEcl)]
        PrIvate STatic eXteRn uInt zlibcompilefLagS();

        [DLLiMpOrt("ZLIB1.dll", CallingCOnVENtIon=CalliNgConvENtIoN.cdecl)]
        priVaTe sTatiC EXtern StriNG zLibVersiOn();
        #endrEGiOn

        #Region PRiVate stUfF
        prIvaTe uinT _FlagS;

        // helpeR functioN that UNpacks a bitsize MAsk
        private staTIc INT bITSizE(uiNt bits)
        {
            switcH (bitS)
            {
                Case 0: RetuRN 16;
                cAse 1: REturn 32;
                Case 2: rEtURn 64;
            }
            REturn -1;
        }
        #endregion

        /// <summaRy>
        /// constrUcts aN instance of thE <c>Info</c> claSS.
        /// </SUmmary>
        puBlic iNfO()
        {
            _Flags = zlibCompiLeFlaGs();
        }

        /// <summary>
        /// TRUe if the lIbrarY is
> event</remarks>
       void Add( byte[ ] d ata ); 

       /// <summa r y>
        /// Adds moredatato thec od ec to  be pro c es s e d.
    / //  </su mma ry>
       ///<pa ra m name="data " >B yte arraycon taining thedat a to b eadd e d tothe  code c</par a m>
       ///  < p aram n a me="off s e t" >The  index of the fir s tb yte to add fro m <c>d at a </ c > </p ara m>
      /// < p aram na m e= " c o unt " >The number o f bytes toa dd< /param >
      / // <r em a rks >Adding dat a ma y, or may  not,r aise th e  <c>Dat aAvail abl e</ c> e v en t< /re ma r ks> 
    void Add (b yt e[] d ata, i n t  off set , in t cou nt);

      ///< sum mary> 
      / // Fi nishes  up a ny  pending data t hatneeds tobepr oce ss ed an d  handl ed. 
      /// </s u mma ry >        void Finish( ); 
       /// <s u mm ar y >
      // / Ge t s  thechec k su m of the  datat ha thas bee naddedso  fa r
      // / </su mmary>
      uint Checksu m  { get; }

 } 

  #endregion

  #r egio n  C las s es
   // /< su m mary>
    /// Enca ps ulates  gene ral informati on about t h e ZLib lib rary 
  /// </summar y>
   publicc lass Inf o
   {
       #reg i o n DLL im por ts
    [ DllImport("ZL I B 1.dl l" , Calli ngC onventi on= Cal lin gCo nv ention.Cd ecl)]
    p riv ate s t atic ext er n u in t z libCo m pileFl ags() ;

    [DllIm p or t ( "ZLI B1 .d ll",  Ca ll ingCo nven t ion =Callin gConventi on. C decl )] 
       private stat ic  extern st ri ngzlibVe r s ion();
        #endregion

      # reg ion P riva te stuff
      pri v ate ui nt _fl ags;

     / / he lpe rfunction t h a t u npack sa bi tsize m ask
        priva t e s tatic int bit Siz e(ui n t  b its ) 
    {           swit ch (bits)
         {             cas e 0:r eturn 1 6;
             case 1 : r eturn 32;
              c ase 2 :  r eturn  64 ;
         } 
         r eturn-1 ;
      }
       #endregion

       /// <s ummar y>
       /// Con structs a n in stance ofthe  <c >Info </c >  clas s.
    ///</su m mary>
    p u bl ic Info()
    {
         _f lags = zlibCompil e Flags();
      } 

     // / <summary>
   /// True  i f the libra ry is
> event</remarks>
_ _   _ void_Add(byte[]_data);

 __  _  ///_<summary>
   _  __/// Adds more data to the codec to be processed.
    __ _///_</summary>
_    _  /// <param name="data">Byte_array containing_the data to be added to the codec</param>
__  _   /// <param name="offset">The index of the_first byte to add from <c>data</c></param>
_  ___  /// <param_name="count">The number of bytes to add</param>
_     _ /// <remarks>Adding data may, or may_not, raise the <c>DataAvailable</c> event</remarks>
 _    _ void_Add(byte[] data, int offset, int_count);

  _ _  _/// <summary>
    _  _/// Finishes up any pending data_that_needs to be_processed_and_handled.
 _  __ _///_</summary>
     __ void Finish();

    _   ///_<summary>
_   _   /// Gets_the checksum of the data that_has been_added so_far
        /// </summary>
 _     _uint Checksum { get;_}


 __ }

 __ #endregion

_   #region Classes
  _ ///_<summary>
    /// Encapsulates_general information about the_ZLib_library
    /// </summary>
_   public class Info
_   {
 ___    #region_DLL imports
    _  _[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
     __ private static extern uint zlibCompileFlags();

__     _[DllImport("ZLIB1.dll",_CallingConvention=CallingConvention.Cdecl)]
_    _  private static extern string_zlibVersion();
        #endregion

_  _    #region_Private_stuff
_       private uint _flags;

_ _  _  // helper function that unpacks a bitsize mask
_      _private static int bitSize(uint bits)
      _ {
      _     switch (bits)
_   __      {
____  _  _  _ _ case 0:_return 16;
_  __           case 1: return 32;
   _     _    __case 2: return_64;
   _       _}
        __ _return -1;
  _ _ _ }
 _ _ _ _#endregion

      __/// <summary>
       _///_Constructs_an_instance of the_<c>Info</c> class.
 _  _  _///_</summary>
     _  public_Info()
   _    {
     _      _flags = zlibCompileFlags();
        }

_ _   _ ///_<summary>
_     _ ///_True if the library is