diff --git a/EPPlus/EPPlusSDK.csproj b/EPPlus/EPPlusSDK.csproj
index 9b5f21b..9203ac9 100644
--- a/EPPlus/EPPlusSDK.csproj
+++ b/EPPlus/EPPlusSDK.csproj
@@ -4,7 +4,7 @@
     <RootNamespace>OfficeOpenXml</RootNamespace>
     <AssemblyName>EPPlus</AssemblyName>
     <PackageId>Appsheet.EPPlus</PackageId>
-    <Version>1.0.3</Version>
+    <Version>1.0.4</Version>
     <DefaultItemExcludes>$(DefaultItemExcludes);Properties/AssemblyInfo.cs;FormulaParsing/LexicalAnalysis/TokenSeparatorHandlers/**;FormulaParsing/LexicalAnalysis/TokenHandler.cs;FormulaParsing/Excel/Functions/Math/Rank.cs</DefaultItemExcludes>
     <DefineConstants>Core;STANDARD20</DefineConstants>
     <ImplicitUsings>disable</ImplicitUsings>
diff --git a/EPPlus/ExcelWorkbook.cs b/EPPlus/ExcelWorkbook.cs
index e47b791..ba02560 100644
--- a/EPPlus/ExcelWorkbook.cs
+++ b/EPPlus/ExcelWorkbook.cs
@@ -31,7 +31,6 @@
  * Richard Tallent		Fix escaping of quotes					2012-10-31
  *******************************************************************************/
 using System;
-using System.Linq;
 using System.Xml;
 using System.IO;
 using System.Collections.Generic;
@@ -40,7 +39,6 @@
 using OfficeOpenXml.Utils;
 using OfficeOpenXml.FormulaParsing;
 using OfficeOpenXml.FormulaParsing.LexicalAnalysis;
-using OfficeOpenXml.Packaging.Ionic.Zip;
 using System.Drawing;
 
 namespace OfficeOpenXml
@@ -794,26 +792,9 @@
 			}
 		}
 
-        private void SaveSharedStringHandler(ZipOutputStream stream, CompressionLevel compressionLevel, string fileName)
+        private void SaveSharedStringHandler(StreamWriter sw)
 		{
-            //Packaging.ZipPackagePart stringPart;
-            //if (_package.Package.PartExists(SharedStringsUri))
-            //{
-            //    stringPart=_package.Package.GetPart(SharedStringsUri);
-            //}
-            //else
-            //{
-            //    stringPart = _package.Package.CreatePart(SharedStringsUri, @"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml", _package.Compression);
-                  //Part.CreateRelationship(UriHelper.GetRelativeUri(WorkbookUri, SharedStringsUri), Packaging.TargetMode.Internal, ExcelPackage.schemaRelationships + "/sharedStrings");
-            //}
-
-			//StreamWriter sw = new StreamWriter(stringPart.GetStream(FileMode.Create, FileAccess.Write));
-            //Init Zip
-            stream.CompressionLevel = (OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel)compressionLevel;
-            stream.PutNextEntry(fileName);
-
             var cache = new StringBuilder();            
-            var sw = new StreamWriter(stream);
             cache.AppendFormat("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><sst xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" count=\"{0}\" uniqueCount=\"{0}\">", _sharedStrings.Count);
 			foreach (string t in _sharedStrings.Keys)
 			{
diff --git a/EPPlus/ExcelWorksheet.cs b/EPPlus/ExcelWorksheet.cs
index 6ee3dd1..f8b6aeb 100644
--- a/EPPlus/ExcelWorksheet.cs
+++ b/EPPlus/ExcelWorksheet.cs
@@ -44,10 +44,10 @@
 using OfficeOpenXml.DataValidation;
 using OfficeOpenXml.Table.PivotTable;
 using System.ComponentModel;
+using System.IO.Compression;
 using OfficeOpenXml.ConditionalFormatting;
 using OfficeOpenXml.Utils;
 using OfficeOpenXml.FormulaParsing.LexicalAnalysis;
-using OfficeOpenXml.Packaging.Ionic.Zip;
   
 namespace OfficeOpenXml
 {
@@ -2878,80 +2878,79 @@
                     }
                 }
         }
-        internal void SaveHandler(ZipOutputStream stream, CompressionLevel compressionLevel, string fileName)
+        internal void SaveHandler(StreamWriter streamWriter)
         {
-                    //Init Zip
-                    stream.CodecBufferSize = 8096;
-                    stream.CompressionLevel = (OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel)compressionLevel;
-                    stream.PutNextEntry(fileName);
+            //Create the nodes if they do not exist.
+            if (this is ExcelChartsheet)
+            {
+                streamWriter.Write(_worksheetXml.OuterXml);
+            }
+            else
+            {
+                CreateNode("d:cols");
+                CreateNode("d:sheetData");
+                CreateNode("d:mergeCells");
+                CreateNode("d:hyperlinks");
+                CreateNode("d:rowBreaks");
+                CreateNode("d:colBreaks");
 
-                    
-                    SaveXml(stream);
+                //StreamWriter sw=new StreamWriter(Part.GetStream(FileMode.Create, FileAccess.Write));
+                var xml = _worksheetXml.OuterXml;
+                int colStart = 0, colEnd = 0;
+                GetBlockPos(xml, "cols", ref colStart, ref colEnd);
+
+                streamWriter.Write(xml.Substring(0, colStart));
+                var colBreaks = new List<int>();
+                //if (_columns.Count > 0)
+                //{
+                UpdateColumnData(streamWriter);
+                //}
+
+                int cellStart = colEnd, cellEnd = colEnd;
+                GetBlockPos(xml, "sheetData", ref cellStart, ref cellEnd);
+
+                streamWriter.Write(xml.Substring(colEnd, cellStart - colEnd));
+                var rowBreaks = new List<int>();
+                UpdateRowCellData(streamWriter);
+
+                int mergeStart = cellEnd, mergeEnd = cellEnd;
+
+                GetBlockPos(xml, "mergeCells", ref mergeStart, ref mergeEnd);
+                streamWriter.Write(xml.Substring(cellEnd, mergeStart - cellEnd));
+
+                CleanupMergedCells(_mergedCells);
+                if (_mergedCells.Count > 0)
+                {
+                    UpdateMergedCells(streamWriter);
+                }
+
+                int hyperStart = mergeEnd, hyperEnd = mergeEnd;
+                GetBlockPos(xml, "hyperlinks", ref hyperStart, ref hyperEnd);
+                streamWriter.Write(xml.Substring(mergeEnd, hyperStart - mergeEnd));
+                //if (_hyperLinkCells.Count > 0)
+                //{
+                UpdateHyperLinks(streamWriter);
+                // }
+
+                int rowBreakStart = hyperEnd, rowBreakEnd = hyperEnd;
+                GetBlockPos(xml, "rowBreaks", ref rowBreakStart, ref rowBreakEnd);
+                streamWriter.Write(xml.Substring(hyperEnd, rowBreakStart - hyperEnd));
+                //if (rowBreaks.Count > 0)
+                //{
+                UpdateRowBreaks(streamWriter);
+                //}
+
+                int colBreakStart = rowBreakEnd, colBreakEnd = rowBreakEnd;
+                GetBlockPos(xml, "colBreaks", ref colBreakStart, ref colBreakEnd);
+                streamWriter.Write(xml.Substring(rowBreakEnd, colBreakStart - rowBreakEnd));
+                //if (colBreaks.Count > 0)
+                //{
+                UpdateColBreaks(streamWriter);
+                //}
+                streamWriter.Write(xml.Substring(colBreakEnd, xml.Length - colBreakEnd));
+            }
         }
-
         
-
-        ///// <summary>
-        ///// Saves the worksheet to the package.
-        ///// </summary>
-        //internal void Save()  // Worksheet Save
-        //{
-        //    DeletePrinterSettings();
-
-        //    if (_worksheetXml != null)
-        //    {
-                
-        //        // save the header & footer (if defined)
-        //        if (_headerFooter != null)
-        //            HeaderFooter.Save();
-
-        //        var d = Dimension;
-        //        if (d == null)
-        //        {
-        //            this.DeleteAllNode("d:dimension/@ref");
-        //        }
-        //        else
-        //        {
-        //            this.SetXmlNodeString("d:dimension/@ref", d.Address);
-        //        }
-                
-
-        //        if (_drawings != null && _drawings.Count == 0)
-        //        {
-        //            //Remove node if no drawings exists.
-        //            DeleteNode("d:drawing");
-        //        }
-
-        //        SaveComments();
-        //        HeaderFooter.SaveHeaderFooterImages();
-        //        SaveTables();
-        //        SavePivotTables();
-        //        SaveXml();
-        //    }
-            
-        //    if (Drawings.UriDrawing!=null)
-        //    {
-        //        if (Drawings.Count == 0)
-        //        {                    
-        //            Part.DeleteRelationship(Drawings._drawingRelation.Id);
-        //            _package.Package.DeletePart(Drawings.UriDrawing);                    
-        //        }
-        //        else
-        //        {
-        //            Packaging.ZipPackagePart partPack = Drawings.Part;
-        //            Drawings.DrawingXml.Save(partPack.GetStream(FileMode.Create, FileAccess.Write));
-        //            foreach (ExcelDrawing d in Drawings)
-        //            {
-        //                if (d is ExcelChart)
-        //                {
-        //                    ExcelChart c = (ExcelChart)d;
-        //                    c.ChartXml.Save(c.Part.GetStream(FileMode.Create, FileAccess.Write));
-        //                }
-        //            }
-        //        }
-        //    }
-        //}
-
         /// <summary>
         /// Delete the printersettings relationship and part.
         /// </summary>
@@ -3285,81 +3284,6 @@
         {
             return string.Format("SUBTOTAL({0},{1}[{2}])", FunctionNum, col._tbl.Name, col.Name);
         }
-        private void SaveXml(Stream stream)
-        {
-            //Create the nodes if they do not exist.
-            StreamWriter sw = new StreamWriter(stream, System.Text.Encoding.UTF8, 65536);
-            if (this is ExcelChartsheet)
-            {
-                sw.Write(_worksheetXml.OuterXml);
-            }
-            else
-            {
-                CreateNode("d:cols");
-                CreateNode("d:sheetData");
-                CreateNode("d:mergeCells");
-                CreateNode("d:hyperlinks");
-                CreateNode("d:rowBreaks");
-                CreateNode("d:colBreaks");
-
-                //StreamWriter sw=new StreamWriter(Part.GetStream(FileMode.Create, FileAccess.Write));
-                var xml = _worksheetXml.OuterXml;
-                int colStart = 0, colEnd = 0;
-                GetBlockPos(xml, "cols", ref colStart, ref colEnd);
-
-                sw.Write(xml.Substring(0, colStart));
-                var colBreaks = new List<int>();
-                //if (_columns.Count > 0)
-                //{
-                UpdateColumnData(sw);
-                //}
-
-                int cellStart = colEnd, cellEnd = colEnd;
-                GetBlockPos(xml, "sheetData", ref cellStart, ref cellEnd);
-
-                sw.Write(xml.Substring(colEnd, cellStart - colEnd));
-                var rowBreaks = new List<int>();
-                UpdateRowCellData(sw);
-
-                int mergeStart = cellEnd, mergeEnd = cellEnd;
-
-                GetBlockPos(xml, "mergeCells", ref mergeStart, ref mergeEnd);
-                sw.Write(xml.Substring(cellEnd, mergeStart - cellEnd));
-
-                CleanupMergedCells(_mergedCells);
-                if (_mergedCells.Count > 0)
-                {
-                    UpdateMergedCells(sw);
-                }
-
-                int hyperStart = mergeEnd, hyperEnd = mergeEnd;
-                GetBlockPos(xml, "hyperlinks", ref hyperStart, ref hyperEnd);
-                sw.Write(xml.Substring(mergeEnd, hyperStart - mergeEnd));
-                //if (_hyperLinkCells.Count > 0)
-                //{
-                UpdateHyperLinks(sw);
-                // }
-
-                int rowBreakStart = hyperEnd, rowBreakEnd = hyperEnd;
-                GetBlockPos(xml, "rowBreaks", ref rowBreakStart, ref rowBreakEnd);
-                sw.Write(xml.Substring(hyperEnd, rowBreakStart - hyperEnd));
-                //if (rowBreaks.Count > 0)
-                //{
-                UpdateRowBreaks(sw);
-                //}
-
-                int colBreakStart = rowBreakEnd, colBreakEnd = rowBreakEnd;
-                GetBlockPos(xml, "colBreaks", ref colBreakStart, ref colBreakEnd);
-                sw.Write(xml.Substring(rowBreakEnd, colBreakStart - rowBreakEnd));
-                //if (colBreaks.Count > 0)
-                //{
-                UpdateColBreaks(sw);
-                //}
-                sw.Write(xml.Substring(colBreakEnd, xml.Length - colBreakEnd));
-            }
-            sw.Flush();
-            //sw.Close();
-        }
 
         private void CleanupMergedCells(MergeCellsCollection _mergedCells)
         {
diff --git a/EPPlus/Packaging/DotNetZip/CRC32.cs b/EPPlus/Packaging/DotNetZip/CRC32.cs
deleted file mode 100644
index cf9574d..0000000
--- a/EPPlus/Packaging/DotNetZip/CRC32.cs
+++ /dev/null
@@ -1,814 +0,0 @@
-// CRC32.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// Last Saved: <2011-August-02 18:25:54>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the CRC32 class, which can do the CRC32 algorithm, using
-// arbitrary starting polynomials, and bit reversal. The bit reversal is what
-// distinguishes this CRC-32 used in BZip2 from the CRC-32 that is used in PKZIP
-// files, or GZIP files. This class does both.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using Interop = System.Runtime.InteropServices;
-
-namespace OfficeOpenXml.Packaging.Ionic.Crc
-{
-    /// <summary>
-    ///   Computes a CRC-32. The CRC-32 algorithm is parameterized - you
-    ///   can set the polynomial and enable or disable bit
-    ///   reversal. This can be used for GZIP, BZip2, or ZIP.
-    /// </summary>
-    /// <remarks>
-    ///   This type is used internally by DotNetZip; it is generally not used
-    ///   directly by applications wishing to create, read, or manipulate zip
-    ///   archive files.
-    /// </remarks>
-
-    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000C")]
-    [Interop.ComVisible(true)]
-#if !NETCF
-    [Interop.ClassInterface(Interop.ClassInterfaceType.AutoDispatch)]
-#endif
-    internal class CRC32
-    {
-        /// <summary>
-        ///   Indicates the total number of bytes applied to the CRC.
-        /// </summary>
-        public Int64 TotalBytesRead
-        {
-            get
-            {
-                return _TotalBytesRead;
-            }
-        }
-
-        /// <summary>
-        /// Indicates the current CRC for all blocks slurped in.
-        /// </summary>
-        public Int32 Crc32Result
-        {
-            get
-            {
-                return unchecked((Int32)(~_register));
-            }
-        }
-
-        /// <summary>
-        /// Returns the CRC32 for the specified stream.
-        /// </summary>
-        /// <param name="input">The stream over which to calculate the CRC32</param>
-        /// <returns>the CRC32 calculation</returns>
-        public Int32 GetCrc32(System.IO.Stream input)
-        {
-            return GetCrc32AndCopy(input, null);
-        }
-
-        /// <summary>
-        /// Returns the CRC32 for the specified stream, and writes the input into the
-        /// output stream.
-        /// </summary>
-        /// <param name="input">The stream over which to calculate the CRC32</param>
-        /// <param name="output">The stream into which to deflate the input</param>
-        /// <returns>the CRC32 calculation</returns>
-        public Int32 GetCrc32AndCopy(System.IO.Stream input, System.IO.Stream output)
-        {
-            if (input == null)
-                throw new Exception("The input stream must not be null.");
-
-            unchecked
-            {
-                byte[] buffer = new byte[BUFFER_SIZE];
-                int readSize = BUFFER_SIZE;
-
-                _TotalBytesRead = 0;
-                int count = input.Read(buffer, 0, readSize);
-                if (output != null) output.Write(buffer, 0, count);
-                _TotalBytesRead += count;
-                while (count > 0)
-                {
-                    SlurpBlock(buffer, 0, count);
-                    count = input.Read(buffer, 0, readSize);
-                    if (output != null) output.Write(buffer, 0, count);
-                    _TotalBytesRead += count;
-                }
-
-                return (Int32)(~_register);
-            }
-        }
-
-
-        /// <summary>
-        ///   Get the CRC32 for the given (word,byte) combo.  This is a
-        ///   computation defined by PKzip for PKZIP 2.0 (weak) encryption.
-        /// </summary>
-        /// <param name="W">The word to start with.</param>
-        /// <param name="B">The byte to combine it with.</param>
-        /// <returns>The CRC-ized result.</returns>
-        public Int32 ComputeCrc32(Int32 W, byte B)
-        {
-            return _InternalComputeCrc32((UInt32)W, B);
-        }
-
-        internal Int32 _InternalComputeCrc32(UInt32 W, byte B)
-        {
-            return (Int32)(crc32Table[(W ^ B) & 0xFF] ^ (W >> 8));
-        }
-
-
-        /// <summary>
-        /// Update the value for the running CRC32 using the given block of bytes.
-        /// This is useful when using the CRC32() class in a Stream.
-        /// </summary>
-        /// <param name="block">block of bytes to slurp</param>
-        /// <param name="offset">starting point in the block</param>
-        /// <param name="count">how many bytes within the block to slurp</param>
-        public void SlurpBlock(byte[] block, int offset, int count)
-        {
-            if (block == null)
-                throw new Exception("The data buffer must not be null.");
-
-            // bzip algorithm
-            for (int i = 0; i < count; i++)
-            {
-                int x = offset + i;
-                byte b = block[x];
-                if (this.reverseBits)
-                {
-                    UInt32 temp = (_register >> 24) ^ b;
-                    _register = (_register << 8) ^ crc32Table[temp];
-                }
-                else
-                {
-                    UInt32 temp = (_register & 0x000000FF) ^ b;
-                    _register = (_register >> 8) ^ crc32Table[temp];
-                }
-            }
-            _TotalBytesRead += count;
-        }
-
-
-        /// <summary>
-        ///   Process one byte in the CRC.
-        /// </summary>
-        /// <param name = "b">the byte to include into the CRC .  </param>
-        public void UpdateCRC(byte b)
-        {
-            if (this.reverseBits)
-            {
-                UInt32 temp = (_register >> 24) ^ b;
-                _register = (_register << 8) ^ crc32Table[temp];
-            }
-            else
-            {
-                UInt32 temp = (_register & 0x000000FF) ^ b;
-                _register = (_register >> 8) ^ crc32Table[temp];
-            }
-        }
-
-        /// <summary>
-        ///   Process a run of N identical bytes into the CRC.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This method serves as an optimization for updating the CRC when a
-        ///     run of identical bytes is found. Rather than passing in a buffer of
-        ///     length n, containing all identical bytes b, this method accepts the
-        ///     byte value and the length of the (virtual) buffer - the length of
-        ///     the run.
-        ///   </para>
-        /// </remarks>
-        /// <param name = "b">the byte to include into the CRC.  </param>
-        /// <param name = "n">the number of times that byte should be repeated. </param>
-        public void UpdateCRC(byte b, int n)
-        {
-            while (n-- > 0)
-            {
-                if (this.reverseBits)
-                {
-                    uint temp = (_register >> 24) ^ b;
-                    _register = (_register << 8) ^ crc32Table[(temp >= 0)
-                                                              ? temp
-                                                              : (temp + 256)];
-                }
-                else
-                {
-                    UInt32 temp = (_register & 0x000000FF) ^ b;
-                    _register = (_register >> 8) ^ crc32Table[(temp >= 0)
-                                                              ? temp
-                                                              : (temp + 256)];
-
-                }
-            }
-        }
-
-
-
-        private static uint ReverseBits(uint data)
-        {
-            unchecked
-            {
-                uint ret = data;
-                ret = (ret & 0x55555555) << 1 | (ret >> 1) & 0x55555555;
-                ret = (ret & 0x33333333) << 2 | (ret >> 2) & 0x33333333;
-                ret = (ret & 0x0F0F0F0F) << 4 | (ret >> 4) & 0x0F0F0F0F;
-                ret = (ret << 24) | ((ret & 0xFF00) << 8) | ((ret >> 8) & 0xFF00) | (ret >> 24);
-                return ret;
-            }
-        }
-
-        private static byte ReverseBits(byte data)
-        {
-            unchecked
-            {
-                uint u = (uint)data * 0x00020202;
-                uint m = 0x01044010;
-                uint s = u & m;
-                uint t = (u << 2) & (m << 1);
-                return (byte)((0x01001001 * (s + t)) >> 24);
-            }
-        }
-
-
-
-        private void GenerateLookupTable()
-        {
-            crc32Table = new UInt32[256];
-            unchecked
-            {
-                UInt32 dwCrc;
-                byte i = 0;
-                do
-                {
-                    dwCrc = i;
-                    for (byte j = 8; j > 0; j--)
-                    {
-                        if ((dwCrc & 1) == 1)
-                        {
-                            dwCrc = (dwCrc >> 1) ^ dwPolynomial;
-                        }
-                        else
-                        {
-                            dwCrc >>= 1;
-                        }
-                    }
-                    if (reverseBits)
-                    {
-                        crc32Table[ReverseBits(i)] = ReverseBits(dwCrc);
-                    }
-                    else
-                    {
-                        crc32Table[i] = dwCrc;
-                    }
-                    i++;
-                } while (i!=0);
-            }
-
-#if VERBOSE
-            Console.WriteLine();
-            Console.WriteLine("private static readonly UInt32[] crc32Table = {");
-            for (int i = 0; i < crc32Table.Length; i+=4)
-            {
-                Console.Write("   ");
-                for (int j=0; j < 4; j++)
-                {
-                    Console.Write(" 0x{0:X8}U,", crc32Table[i+j]);
-                }
-                Console.WriteLine();
-            }
-            Console.WriteLine("};");
-            Console.WriteLine();
-#endif
-        }
-
-
-        private uint gf2_matrix_times(uint[] matrix, uint vec)
-        {
-            uint sum = 0;
-            int i=0;
-            while (vec != 0)
-            {
-                if ((vec & 0x01)== 0x01)
-                    sum ^= matrix[i];
-                vec >>= 1;
-                i++;
-            }
-            return sum;
-        }
-
-        private void gf2_matrix_square(uint[] square, uint[] mat)
-        {
-            for (int i = 0; i < 32; i++)
-                square[i] = gf2_matrix_times(mat, mat[i]);
-        }
-
-
-
-        /// <summary>
-        ///   Combines the given CRC32 value with the current running total.
-        /// </summary>
-        /// <remarks>
-        ///   This is useful when using a divide-and-conquer approach to
-        ///   calculating a CRC.  Multiple threads can each calculate a
-        ///   CRC32 on a segment of the data, and then combine the
-        ///   individual CRC32 values at the end.
-        /// </remarks>
-        /// <param name="crc">the crc value to be combined with this one</param>
-        /// <param name="length">the length of data the CRC value was calculated on</param>
-        public void Combine(int crc, int length)
-        {
-            uint[] even = new uint[32];     // even-power-of-two zeros operator
-            uint[] odd = new uint[32];      // odd-power-of-two zeros operator
-
-            if (length == 0)
-                return;
-
-            uint crc1= ~_register;
-            uint crc2= (uint) crc;
-
-            // put operator for one zero bit in odd
-            odd[0] = this.dwPolynomial;  // the CRC-32 polynomial
-            uint row = 1;
-            for (int i = 1; i < 32; i++)
-            {
-                odd[i] = row;
-                row <<= 1;
-            }
-
-            // put operator for two zero bits in even
-            gf2_matrix_square(even, odd);
-
-            // put operator for four zero bits in odd
-            gf2_matrix_square(odd, even);
-
-            uint len2 = (uint) length;
-
-            // apply len2 zeros to crc1 (first square will put the operator for one
-            // zero byte, eight zero bits, in even)
-            do {
-                // apply zeros operator for this bit of len2
-                gf2_matrix_square(even, odd);
-
-                if ((len2 & 1)== 1)
-                    crc1 = gf2_matrix_times(even, crc1);
-                len2 >>= 1;
-
-                if (len2 == 0)
-                    break;
-
-                // another iteration of the loop with odd and even swapped
-                gf2_matrix_square(odd, even);
-                if ((len2 & 1)==1)
-                    crc1 = gf2_matrix_times(odd, crc1);
-                len2 >>= 1;
-
-
-            } while (len2 != 0);
-
-            crc1 ^= crc2;
-
-            _register= ~crc1;
-
-            //return (int) crc1;
-            return;
-        }
-
-
-        /// <summary>
-        ///   Create an instance of the CRC32 class using the default settings: no
-        ///   bit reversal, and a polynomial of 0xEDB88320.
-        /// </summary>
-        public CRC32() : this(false)
-        {
-        }
-
-        /// <summary>
-        ///   Create an instance of the CRC32 class, specifying whether to reverse
-        ///   data bits or not.
-        /// </summary>
-        /// <param name='reverseBits'>
-        ///   specify true if the instance should reverse data bits.
-        /// </param>
-        /// <remarks>
-        ///   <para>
-        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
-        ///     want a CRC32 with compatibility with BZip2, you should pass true
-        ///     here. In the CRC-32 used by GZIP and PKZIP, the bits are not
-        ///     reversed; Therefore if you want a CRC32 with compatibility with
-        ///     those, you should pass false.
-        ///   </para>
-        /// </remarks>
-        public CRC32(bool reverseBits) :
-            this( unchecked((int)0xEDB88320), reverseBits)
-        {
-        }
-
-
-        /// <summary>
-        ///   Create an instance of the CRC32 class, specifying the polynomial and
-        ///   whether to reverse data bits or not.
-        /// </summary>
-        /// <param name='polynomial'>
-        ///   The polynomial to use for the CRC, expressed in the reversed (LSB)
-        ///   format: the highest ordered bit in the polynomial value is the
-        ///   coefficient of the 0th power; the second-highest order bit is the
-        ///   coefficient of the 1 power, and so on. Expressed this way, the
-        ///   polynomial for the CRC-32C used in IEEE 802.3, is 0xEDB88320.
-        /// </param>
-        /// <param name='reverseBits'>
-        ///   specify true if the instance should reverse data bits.
-        /// </param>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
-        ///     want a CRC32 with compatibility with BZip2, you should pass true
-        ///     here for the <c>reverseBits</c> parameter. In the CRC-32 used by
-        ///     GZIP and PKZIP, the bits are not reversed; Therefore if you want a
-        ///     CRC32 with compatibility with those, you should pass false for the
-        ///     <c>reverseBits</c> parameter.
-        ///   </para>
-        /// </remarks>
-        public CRC32(int polynomial, bool reverseBits)
-        {
-            this.reverseBits = reverseBits;
-            this.dwPolynomial = (uint) polynomial;
-            this.GenerateLookupTable();
-        }
-
-        /// <summary>
-        ///   Reset the CRC-32 class - clear the CRC "remainder register."
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Use this when employing a single instance of this class to compute
-        ///     multiple, distinct CRCs on multiple, distinct data blocks.
-        ///   </para>
-        /// </remarks>
-        public void Reset()
-        {
-            _register = 0xFFFFFFFFU;
-        }
-
-        // private member vars
-        private UInt32 dwPolynomial;
-        private Int64 _TotalBytesRead;
-        private bool reverseBits;
-        private UInt32[] crc32Table;
-        private const int BUFFER_SIZE = 8192;
-        private UInt32 _register = 0xFFFFFFFFU;
-    }
-
-
-    /// <summary>
-    /// A Stream that calculates a CRC32 (a checksum) on all bytes read,
-    /// or on all bytes written.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    /// This class can be used to verify the CRC of a ZipEntry when
-    /// reading from a stream, or to calculate a CRC when writing to a
-    /// stream.  The stream should be used to either read, or write, but
-    /// not both.  If you intermix reads and writes, the results are not
-    /// defined.
-    /// </para>
-    ///
-    /// <para>
-    /// This class is intended primarily for use internally by the
-    /// DotNetZip library.
-    /// </para>
-    /// </remarks>
-    internal class CrcCalculatorStream : System.IO.Stream, System.IDisposable
-    {
-        private static readonly Int64 UnsetLengthLimit = -99;
-
-        internal System.IO.Stream _innerStream;
-        private CRC32 _Crc32;
-        private Int64 _lengthLimit = -99;
-        private bool _leaveOpen;
-
-        /// <summary>
-        /// The default constructor.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Instances returned from this constructor will leave the underlying
-        ///     stream open upon Close().  The stream uses the default CRC32
-        ///     algorithm, which implies a polynomial of 0xEDB88320.
-        ///   </para>
-        /// </remarks>
-        /// <param name="stream">The underlying stream</param>
-        public CrcCalculatorStream(System.IO.Stream stream)
-            : this(true, CrcCalculatorStream.UnsetLengthLimit, stream, null)
-        {
-        }
-
-        /// <summary>
-        ///   The constructor allows the caller to specify how to handle the
-        ///   underlying stream at close.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The stream uses the default CRC32 algorithm, which implies a
-        ///     polynomial of 0xEDB88320.
-        ///   </para>
-        /// </remarks>
-        /// <param name="stream">The underlying stream</param>
-        /// <param name="leaveOpen">true to leave the underlying stream
-        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
-        public CrcCalculatorStream(System.IO.Stream stream, bool leaveOpen)
-            : this(leaveOpen, CrcCalculatorStream.UnsetLengthLimit, stream, null)
-        {
-        }
-
-        /// <summary>
-        ///   A constructor allowing the specification of the length of the stream
-        ///   to read.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The stream uses the default CRC32 algorithm, which implies a
-        ///     polynomial of 0xEDB88320.
-        ///   </para>
-        ///   <para>
-        ///     Instances returned from this constructor will leave the underlying
-        ///     stream open upon Close().
-        ///   </para>
-        /// </remarks>
-        /// <param name="stream">The underlying stream</param>
-        /// <param name="length">The length of the stream to slurp</param>
-        public CrcCalculatorStream(System.IO.Stream stream, Int64 length)
-            : this(true, length, stream, null)
-        {
-            if (length < 0)
-                throw new ArgumentException("length");
-        }
-
-        /// <summary>
-        ///   A constructor allowing the specification of the length of the stream
-        ///   to read, as well as whether to keep the underlying stream open upon
-        ///   Close().
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The stream uses the default CRC32 algorithm, which implies a
-        ///     polynomial of 0xEDB88320.
-        ///   </para>
-        /// </remarks>
-        /// <param name="stream">The underlying stream</param>
-        /// <param name="length">The length of the stream to slurp</param>
-        /// <param name="leaveOpen">true to leave the underlying stream
-        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
-        public CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen)
-            : this(leaveOpen, length, stream, null)
-        {
-            if (length < 0)
-                throw new ArgumentException("length");
-        }
-
-        /// <summary>
-        ///   A constructor allowing the specification of the length of the stream
-        ///   to read, as well as whether to keep the underlying stream open upon
-        ///   Close(), and the CRC32 instance to use.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The stream uses the specified CRC32 instance, which allows the
-        ///     application to specify how the CRC gets calculated.
-        ///   </para>
-        /// </remarks>
-        /// <param name="stream">The underlying stream</param>
-        /// <param name="length">The length of the stream to slurp</param>
-        /// <param name="leaveOpen">true to leave the underlying stream
-        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
-        /// <param name="crc32">the CRC32 instance to use to calculate the CRC32</param>
-        public CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen,
-                                   CRC32 crc32)
-            : this(leaveOpen, length, stream, crc32)
-        {
-            if (length < 0)
-                throw new ArgumentException("length");
-        }
-
-
-        // This ctor is private - no validation is done here.  This is to allow the use
-        // of a (specific) negative value for the _lengthLimit, to indicate that there
-        // is no length set.  So we validate the length limit in those ctors that use an
-        // explicit param, otherwise we don't validate, because it could be our special
-        // value.
-        private CrcCalculatorStream
-            (bool leaveOpen, Int64 length, System.IO.Stream stream, CRC32 crc32)
-            : base()
-        {
-            _innerStream = stream;
-            _Crc32 = crc32 ?? new CRC32();
-            _lengthLimit = length;
-            _leaveOpen = leaveOpen;
-        }
-
-
-        /// <summary>
-        ///   Gets the total number of bytes run through the CRC32 calculator.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This is either the total number of bytes read, or the total number of
-        ///   bytes written, depending on the direction of this stream.
-        /// </remarks>
-        public Int64 TotalBytesSlurped
-        {
-            get { return _Crc32.TotalBytesRead; }
-        }
-
-        /// <summary>
-        ///   Provides the current CRC for all blocks slurped in.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The running total of the CRC is kept as data is written or read
-        ///     through the stream.  read this property after all reads or writes to
-        ///     get an accurate CRC for the entire stream.
-        ///   </para>
-        /// </remarks>
-        public Int32 Crc
-        {
-            get { return _Crc32.Crc32Result; }
-        }
-
-        /// <summary>
-        ///   Indicates whether the underlying stream will be left open when the
-        ///   <c>CrcCalculatorStream</c> is Closed.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Set this at any point before calling <see cref="Close()"/>.
-        ///   </para>
-        /// </remarks>
-        public bool LeaveOpen
-        {
-            get { return _leaveOpen; }
-            set { _leaveOpen = value; }
-        }
-
-        /// <summary>
-        /// Read from the stream
-        /// </summary>
-        /// <param name="buffer">the buffer to read</param>
-        /// <param name="offset">the offset at which to start</param>
-        /// <param name="count">the number of bytes to read</param>
-        /// <returns>the number of bytes actually read</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            int bytesToRead = count;
-
-            // Need to limit the # of bytes returned, if the stream is intended to have
-            // a definite length.  This is especially useful when returning a stream for
-            // the uncompressed data directly to the application.  The app won't
-            // necessarily read only the UncompressedSize number of bytes.  For example
-            // wrapping the stream returned from OpenReader() into a StreadReader() and
-            // calling ReadToEnd() on it, We can "over-read" the zip data and get a
-            // corrupt string.  The length limits that, prevents that problem.
-
-            if (_lengthLimit != CrcCalculatorStream.UnsetLengthLimit)
-            {
-                if (_Crc32.TotalBytesRead >= _lengthLimit) return 0; // EOF
-                Int64 bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead;
-                if (bytesRemaining < count) bytesToRead = (int)bytesRemaining;
-            }
-            int n = _innerStream.Read(buffer, offset, bytesToRead);
-            if (n > 0) _Crc32.SlurpBlock(buffer, offset, n);
-            return n;
-        }
-
-        /// <summary>
-        /// Write to the stream.
-        /// </summary>
-        /// <param name="buffer">the buffer from which to write</param>
-        /// <param name="offset">the offset at which to start writing</param>
-        /// <param name="count">the number of bytes to write</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (count > 0) _Crc32.SlurpBlock(buffer, offset, count);
-            _innerStream.Write(buffer, offset, count);
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports reading.
-        /// </summary>
-        public override bool CanRead
-        {
-            get { return _innerStream.CanRead; }
-        }
-
-        /// <summary>
-        ///   Indicates whether the stream supports seeking.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Always returns false.
-        ///   </para>
-        /// </remarks>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports writing.
-        /// </summary>
-        public override bool CanWrite
-        {
-            get { return _innerStream.CanWrite; }
-        }
-
-        /// <summary>
-        /// Flush the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            _innerStream.Flush();
-        }
-
-        /// <summary>
-        ///   Returns the length of the underlying stream.
-        /// </summary>
-        public override long Length
-        {
-            get
-            {
-                if (_lengthLimit == CrcCalculatorStream.UnsetLengthLimit)
-                    return _innerStream.Length;
-                else return _lengthLimit;
-            }
-        }
-
-        /// <summary>
-        ///   The getter for this property returns the total bytes read.
-        ///   If you use the setter, it will throw
-        /// <see cref="NotSupportedException"/>.
-        /// </summary>
-        public override long Position
-        {
-            get { return _Crc32.TotalBytesRead; }
-            set { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        /// Seeking is not supported on this stream. This method always throws
-        /// <see cref="NotSupportedException"/>
-        /// </summary>
-        /// <param name="offset">N/A</param>
-        /// <param name="origin">N/A</param>
-        /// <returns>N/A</returns>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// This method always throws
-        /// <see cref="NotSupportedException"/>
-        /// </summary>
-        /// <param name="value">N/A</param>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-
-        void IDisposable.Dispose()
-        {
-            Close();
-        }
-
-        /// <summary>
-        /// Closes the stream.
-        /// </summary>
-        public override void Close()
-        {
-            base.Close();
-            if (!_leaveOpen)
-                _innerStream.Close();
-        }
-
-    }
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/ComHelper.cs b/EPPlus/Packaging/DotNetZip/ComHelper.cs
deleted file mode 100644
index fe2dfdb..0000000
--- a/EPPlus/Packaging/DotNetZip/ComHelper.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// ComHelper.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-June-13 17:04:06>
-//
-// ------------------------------------------------------------------
-//
-// This module defines a COM Helper class.
-//
-// Created: Tue, 08 Sep 2009  22:03
-//
-
-using Interop=System.Runtime.InteropServices;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// This class exposes a set of COM-accessible wrappers for static
-    /// methods available on the ZipFile class.  You don't need this
-    /// class unless you are using DotNetZip from a COM environment.
-    /// </summary>
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000F")]
-    [System.Runtime.InteropServices.ComVisible(true)]
-#if !NETCF
-    [System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDispatch)]
-#endif
-
-    internal class ComHelper
-    {
-        /// <summary>
-        ///  A wrapper for <see cref="ZipFile.IsZipFile(string)">ZipFile.IsZipFile(string)</see>
-        /// </summary>
-        /// <param name="filename">The filename to of the zip file to check.</param>
-        /// <returns>true if the file contains a valid zip file.</returns>
-        public bool IsZipFile(string filename)
-        {
-            return ZipFile.IsZipFile(filename);
-        }
-
-        /// <summary>
-        ///  A wrapper for <see cref="ZipFile.IsZipFile(string, bool)">ZipFile.IsZipFile(string, bool)</see>
-        /// </summary>
-        /// <remarks>
-        /// We cannot use "overloaded" Method names in COM interop.
-        /// So, here, we use a unique name.
-        /// </remarks>
-        /// <param name="filename">The filename to of the zip file to check.</param>
-        /// <returns>true if the file contains a valid zip file.</returns>
-        public bool IsZipFileWithExtract(string filename)
-        {
-            return ZipFile.IsZipFile(filename, true);
-        }
-
-#if !NETCF
-        /// <summary>
-        ///  A wrapper for <see cref="ZipFile.CheckZip(string)">ZipFile.CheckZip(string)</see>
-        /// </summary>
-        /// <param name="filename">The filename to of the zip file to check.</param>
-        ///
-        /// <returns>true if the named zip file checks OK. Otherwise, false. </returns>
-        public bool CheckZip(string filename)
-        {
-            return ZipFile.CheckZip(filename);
-        }
-
-        /// <summary>
-        ///  A COM-friendly wrapper for the static method <see cref="ZipFile.CheckZipPassword(string,string)"/>.
-        /// </summary>
-        ///
-        /// <param name="filename">The filename to of the zip file to check.</param>
-        ///
-        /// <param name="password">The password to check.</param>
-        ///
-        /// <returns>true if the named zip file checks OK. Otherwise, false. </returns>
-        public bool CheckZipPassword(string filename, string password)
-        {
-            return ZipFile.CheckZipPassword(filename, password);
-        }
-
-        /// <summary>
-        ///  A wrapper for <see cref="ZipFile.FixZipDirectory(string)">ZipFile.FixZipDirectory(string)</see>
-        /// </summary>
-        /// <param name="filename">The filename to of the zip file to fix.</param>
-        public void FixZipDirectory(string filename)
-        {
-            ZipFile.FixZipDirectory(filename);
-        }
-#endif
-
-        /// <summary>
-        ///  A wrapper for <see cref="ZipFile.LibraryVersion">ZipFile.LibraryVersion</see>
-        /// </summary>
-        /// <returns>
-        ///  the version number on the DotNetZip assembly, formatted as a string.
-        /// </returns>
-        public string GetZipLibraryVersion()
-        {
-            return ZipFile.LibraryVersion.ToString();
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/EncryptionAlgorithm.cs b/EPPlus/Packaging/DotNetZip/EncryptionAlgorithm.cs
deleted file mode 100644
index 1247432..0000000
--- a/EPPlus/Packaging/DotNetZip/EncryptionAlgorithm.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// EncryptionAlgorithm.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c)  2009 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-October-21 17:24:45>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the EncryptionAgorithm enum
-//
-// 
-// ------------------------------------------------------------------
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// An enum that provides the various encryption algorithms supported by this
-    /// library.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///
-    /// <para>
-    ///   <c>PkzipWeak</c> implies the use of Zip 2.0 encryption, which is known to be
-    ///   weak and subvertible.
-    /// </para>
-    ///
-    /// <para>
-    ///   A note on interoperability: Values of <c>PkzipWeak</c> and <c>None</c> are
-    ///   specified in <see
-    ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's zip
-    ///   specification</see>, and are considered to be "standard".  Zip archives
-    ///   produced using these options will be interoperable with many other zip tools
-    ///   and libraries, including Windows Explorer.
-    /// </para>
-    ///
-    /// <para>
-    ///   Values of <c>WinZipAes128</c> and <c>WinZipAes256</c> are not part of the Zip
-    ///   specification, but rather imply the use of a vendor-specific extension from
-    ///   WinZip. If you want to produce interoperable Zip archives, do not use these
-    ///   values.  For example, if you produce a zip archive using WinZipAes256, you
-    ///   will be able to open it in Windows Explorer on Windows XP and Vista, but you
-    ///   will not be able to extract entries; trying this will lead to an "unspecified
-    ///   error". For this reason, some people have said that a zip archive that uses
-    ///   WinZip's AES encryption is not actually a zip archive at all.  A zip archive
-    ///   produced this way will be readable with the WinZip tool (Version 11 and
-    ///   beyond).
-    /// </para>
-    ///
-    /// <para>
-    ///   There are other third-party tools and libraries, both commercial and
-    ///   otherwise, that support WinZip's AES encryption. These will be able to read
-    ///   AES-encrypted zip archives produced by DotNetZip, and conversely applications
-    ///   that use DotNetZip to read zip archives will be able to read AES-encrypted
-    ///   archives produced by those tools or libraries.  Consult the documentation for
-    ///   those other tools and libraries to find out if WinZip's AES encryption is
-    ///   supported.
-    /// </para>
-    ///
-    /// <para>
-    ///   In case you care: According to <see
-    ///   href="http://www.winzip.com/aes_info.htm">the WinZip specification</see>, the
-    ///   actual AES key used is derived from the <see cref="ZipEntry.Password"/> via an
-    ///   algorithm that complies with <see
-    ///   href="http://www.ietf.org/rfc/rfc2898.txt">RFC 2898</see>, using an iteration
-    ///   count of 1000.  The algorithm is sometimes referred to as PBKDF2, which stands
-    ///   for "Password Based Key Derivation Function #2".
-    /// </para>
-    ///
-    /// <para>
-    ///   A word about password strength and length: The AES encryption technology is
-    ///   very good, but any system is only as secure as the weakest link.  If you want
-    ///   to secure your data, be sure to use a password that is hard to guess.  To make
-    ///   it harder to guess (increase its "entropy"), you should make it longer.  If
-    ///   you use normal characters from an ASCII keyboard, a password of length 20 will
-    ///   be strong enough that it will be impossible to guess.  For more information on
-    ///   that, I'd encourage you to read <see
-    ///   href="http://www.redkestrel.co.uk/Articles/RandomPasswordStrength.html">this
-    ///   article.</see>
-    /// </para>
-    ///
-    /// <para>
-    ///   The WinZip AES algorithms are not supported with the version of DotNetZip that
-    ///   runs on the .NET Compact Framework.  This is because .NET CF lacks the
-    ///   HMACSHA1 class that is required for producing the archive.
-    /// </para>
-    /// </remarks>
-    internal enum EncryptionAlgorithm
-    {
-        /// <summary>
-        /// No encryption at all.
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// Traditional or Classic pkzip encryption.
-        /// </summary>
-        PkzipWeak,
-
-#if AESCRYPTO
-        /// <summary>
-        /// WinZip AES encryption (128 key bits).
-        /// </summary>
-        WinZipAes128,
-
-        /// <summary>
-        /// WinZip AES encryption (256 key bits).
-        /// </summary>
-        WinZipAes256,
-#endif
-
-        /// <summary>
-        /// An encryption algorithm that is not supported by DotNetZip.
-        /// </summary>
-        Unsupported = 4,
-
-
-        // others... not implemented (yet?)
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/Events.cs b/EPPlus/Packaging/DotNetZip/Events.cs
deleted file mode 100644
index 7ba296c..0000000
--- a/EPPlus/Packaging/DotNetZip/Events.cs
+++ /dev/null
@@ -1,684 +0,0 @@
-// Events.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006, 2007, 2008, 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-06 12:26:24>
-//
-// ------------------------------------------------------------------
-//
-// This module defines events used by the ZipFile class.
-//
-//
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   Delegate in which the application writes the <c>ZipEntry</c> content for the named entry.
-    /// </summary>
-    ///
-    /// <param name="entryName">The name of the entry that must be written.</param>
-    /// <param name="stream">The stream to which the entry data should be written.</param>
-    ///
-    /// <remarks>
-    ///   When you add an entry and specify a <c>WriteDelegate</c>, via <see
-    ///   cref="Ionic.Zip.ZipFile.AddEntry(string, WriteDelegate)"/>, the application
-    ///   code provides the logic that writes the entry data directly into the zip file.
-    /// </remarks>
-    ///
-    /// <example>
-    ///
-    /// This example shows how to define a WriteDelegate that obtains a DataSet, and then
-    /// writes the XML for the DataSet into the zip archive.  There's no need to
-    /// save the XML to a disk file first.
-    ///
-    /// <code lang="C#">
-    /// private void WriteEntry (String filename, Stream output)
-    /// {
-    ///     DataSet ds1 = ObtainDataSet();
-    ///     ds1.WriteXml(output);
-    /// }
-    ///
-    /// private void Run()
-    /// {
-    ///     using (var zip = new ZipFile())
-    ///     {
-    ///         zip.AddEntry(zipEntryName, WriteEntry);
-    ///         zip.Save(zipFileName);
-    ///     }
-    /// }
-    /// </code>
-    ///
-    /// <code lang="vb">
-    /// Private Sub WriteEntry (ByVal filename As String, ByVal output As Stream)
-    ///     DataSet ds1 = ObtainDataSet()
-    ///     ds1.WriteXml(stream)
-    /// End Sub
-    ///
-    /// Public Sub Run()
-    ///     Using zip = New ZipFile
-    ///         zip.AddEntry(zipEntryName, New WriteDelegate(AddressOf WriteEntry))
-    ///         zip.Save(zipFileName)
-    ///     End Using
-    /// End Sub
-    /// </code>
-    /// </example>
-    /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(string, WriteDelegate)"/>
-    public delegate void WriteDelegate(string entryName, System.IO.Stream stream);
-
-
-    /// <summary>
-    ///   Delegate in which the application opens the stream, just-in-time, for the named entry.
-    /// </summary>
-    ///
-    /// <param name="entryName">
-    /// The name of the ZipEntry that the application should open the stream for.
-    /// </param>
-    ///
-    /// <remarks>
-    ///   When you add an entry via <see cref="Ionic.Zip.ZipFile.AddEntry(string,
-    ///   OpenDelegate, CloseDelegate)"/>, the application code provides the logic that
-    ///   opens and closes the stream for the given ZipEntry.
-    /// </remarks>
-    ///
-    /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(string, OpenDelegate, CloseDelegate)"/>
-    public delegate System.IO.Stream OpenDelegate(string entryName);
-
-    /// <summary>
-    ///   Delegate in which the application closes the stream, just-in-time, for the named entry.
-    /// </summary>
-    ///
-    /// <param name="entryName">
-    /// The name of the ZipEntry that the application should close the stream for.
-    /// </param>
-    ///
-    /// <param name="stream">The stream to be closed.</param>
-    ///
-    /// <remarks>
-    ///   When you add an entry via <see cref="Ionic.Zip.ZipFile.AddEntry(string,
-    ///   OpenDelegate, CloseDelegate)"/>, the application code provides the logic that
-    ///   opens and closes the stream for the given ZipEntry.
-    /// </remarks>
-    ///
-    /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(string, OpenDelegate, CloseDelegate)"/>
-    public delegate void CloseDelegate(string entryName, System.IO.Stream stream);
-
-    /// <summary>
-    ///   Delegate for the callback by which the application tells the
-    ///   library the CompressionLevel to use for a file.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    ///   Using this callback, the application can, for example, specify that
-    ///   previously-compressed files (.mp3, .png, .docx, etc) should use a
-    ///   <c>CompressionLevel</c> of <c>None</c>, or can set the compression level based
-    ///   on any other factor.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="Ionic.Zip.ZipFile.SetCompression"/>
-    public delegate OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel SetCompressionCallback(string localFileName, string fileNameInArchive);
-
-    /// <summary>
-    ///   In an EventArgs type, indicates which sort of progress event is being
-    ///   reported.
-    /// </summary>
-    /// <remarks>
-    ///   There are events for reading, events for saving, and events for
-    ///   extracting. This enumeration allows a single EventArgs type to be sued to
-    ///   describe one of multiple subevents. For example, a SaveProgress event is
-    ///   invoked before, after, and during the saving of a single entry.  The value
-    ///   of an enum with this type, specifies which event is being triggered.  The
-    ///   same applies to Extraction, Reading and Adding events.
-    /// </remarks>
-    internal enum ZipProgressEventType
-    {
-        /// <summary>
-        /// Indicates that a Add() operation has started.
-        /// </summary>
-        Adding_Started,
-
-        /// <summary>
-        /// Indicates that an individual entry in the archive has been added.
-        /// </summary>
-        Adding_AfterAddEntry,
-
-        /// <summary>
-        /// Indicates that a Add() operation has completed.
-        /// </summary>
-        Adding_Completed,
-
-        /// <summary>
-        /// Indicates that a Read() operation has started.
-        /// </summary>
-        Reading_Started,
-
-        /// <summary>
-        /// Indicates that an individual entry in the archive is about to be read.
-        /// </summary>
-        Reading_BeforeReadEntry,
-
-        /// <summary>
-        /// Indicates that an individual entry in the archive has just been read.
-        /// </summary>
-        Reading_AfterReadEntry,
-
-        /// <summary>
-        /// Indicates that a Read() operation has completed.
-        /// </summary>
-        Reading_Completed,
-
-        /// <summary>
-        /// The given event reports the number of bytes read so far
-        /// during a Read() operation.
-        /// </summary>
-        Reading_ArchiveBytesRead,
-
-        /// <summary>
-        /// Indicates that a Save() operation has started.
-        /// </summary>
-        Saving_Started,
-
-        /// <summary>
-        /// Indicates that an individual entry in the archive is about to be written.
-        /// </summary>
-        Saving_BeforeWriteEntry,
-
-        /// <summary>
-        /// Indicates that an individual entry in the archive has just been saved.
-        /// </summary>
-        Saving_AfterWriteEntry,
-
-        /// <summary>
-        /// Indicates that a Save() operation has completed.
-        /// </summary>
-        Saving_Completed,
-
-        /// <summary>
-        /// Indicates that the zip archive has been created in a
-        /// temporary location during a Save() operation.
-        /// </summary>
-        Saving_AfterSaveTempArchive,
-
-        /// <summary>
-        /// Indicates that the temporary file is about to be renamed to the final archive
-        /// name during a Save() operation.
-        /// </summary>
-        Saving_BeforeRenameTempArchive,
-
-        /// <summary>
-        /// Indicates that the temporary file is has just been renamed to the final archive
-        /// name during a Save() operation.
-        /// </summary>
-        Saving_AfterRenameTempArchive,
-
-        /// <summary>
-        /// Indicates that the self-extracting archive has been compiled
-        /// during a Save() operation.
-        /// </summary>
-        Saving_AfterCompileSelfExtractor,
-
-        /// <summary>
-        /// The given event is reporting the number of source bytes that have run through the compressor so far
-        /// during a Save() operation.
-        /// </summary>
-        Saving_EntryBytesRead,
-
-        /// <summary>
-        /// Indicates that an entry is about to be extracted.
-        /// </summary>
-        Extracting_BeforeExtractEntry,
-
-        /// <summary>
-        /// Indicates that an entry has just been extracted.
-        /// </summary>
-        Extracting_AfterExtractEntry,
-
-        /// <summary>
-        ///   Indicates that extraction of an entry would overwrite an existing
-        ///   filesystem file. You must use
-        ///   <see cref="ExtractExistingFileAction.InvokeExtractProgressEvent">
-        ///   ExtractExistingFileAction.InvokeExtractProgressEvent</see> in the call
-        ///   to <c>ZipEntry.Extract()</c> in order to receive this event.
-        /// </summary>
-        Extracting_ExtractEntryWouldOverwrite,
-
-        /// <summary>
-        ///   The given event is reporting the number of bytes written so far for
-        ///   the current entry during an Extract() operation.
-        /// </summary>
-        Extracting_EntryBytesWritten,
-
-        /// <summary>
-        /// Indicates that an ExtractAll operation is about to begin.
-        /// </summary>
-        Extracting_BeforeExtractAll,
-
-        /// <summary>
-        /// Indicates that an ExtractAll operation has completed.
-        /// </summary>
-        Extracting_AfterExtractAll,
-
-        /// <summary>
-        /// Indicates that an error has occurred while saving a zip file.
-        /// This generally means the file cannot be opened, because it has been
-        /// removed, or because it is locked by another process.  It can also
-        /// mean that the file cannot be Read, because of a range lock conflict.
-        /// </summary>
-        Error_Saving,
-    }
-
-
-    /// <summary>
-    /// Provides information about the progress of a save, read, or extract operation.
-    /// This is a base class; you will probably use one of the classes derived from this one.
-    /// </summary>
-    internal class ZipProgressEventArgs : EventArgs
-    {
-        private int _entriesTotal;
-        private bool _cancel;
-        private ZipEntry _latestEntry;
-        private ZipProgressEventType _flavor;
-        private String _archiveName;
-        private Int64 _bytesTransferred;
-        private Int64 _totalBytesToTransfer;
-
-
-        internal ZipProgressEventArgs() { }
-
-        internal ZipProgressEventArgs(string archiveName, ZipProgressEventType flavor)
-        {
-            this._archiveName = archiveName;
-            this._flavor = flavor;
-        }
-
-        /// <summary>
-        /// The total number of entries to be saved or extracted.
-        /// </summary>
-        public int EntriesTotal
-        {
-            get { return _entriesTotal; }
-            set { _entriesTotal = value; }
-        }
-
-        /// <summary>
-        /// The name of the last entry saved or extracted.
-        /// </summary>
-        public ZipEntry CurrentEntry
-        {
-            get { return _latestEntry; }
-            set { _latestEntry = value; }
-        }
-
-        /// <summary>
-        /// In an event handler, set this to cancel the save or extract
-        /// operation that is in progress.
-        /// </summary>
-        public bool Cancel
-        {
-            get { return _cancel; }
-            set { _cancel = _cancel || value; }
-        }
-
-        /// <summary>
-        /// The type of event being reported.
-        /// </summary>
-        public ZipProgressEventType EventType
-        {
-            get { return _flavor; }
-            set { _flavor = value; }
-        }
-
-        /// <summary>
-        /// Returns the archive name associated to this event.
-        /// </summary>
-        public String ArchiveName
-        {
-            get { return _archiveName; }
-            set { _archiveName = value; }
-        }
-
-
-        /// <summary>
-        /// The number of bytes read or written so far for this entry.
-        /// </summary>
-        public Int64 BytesTransferred
-        {
-            get { return _bytesTransferred; }
-            set { _bytesTransferred = value; }
-        }
-
-
-
-        /// <summary>
-        /// Total number of bytes that will be read or written for this entry.
-        /// This number will be -1 if the value cannot be determined.
-        /// </summary>
-        public Int64 TotalBytesToTransfer
-        {
-            get { return _totalBytesToTransfer; }
-            set { _totalBytesToTransfer = value; }
-        }
-    }
-
-
-
-    /// <summary>
-    /// Provides information about the progress of a Read operation.
-    /// </summary>
-    internal class ReadProgressEventArgs : ZipProgressEventArgs
-    {
-
-        internal ReadProgressEventArgs() { }
-
-        private ReadProgressEventArgs(string archiveName, ZipProgressEventType flavor)
-            : base(archiveName, flavor)
-        { }
-
-        internal static ReadProgressEventArgs Before(string archiveName, int entriesTotal)
-        {
-            var x = new ReadProgressEventArgs(archiveName, ZipProgressEventType.Reading_BeforeReadEntry);
-            x.EntriesTotal = entriesTotal;
-            return x;
-        }
-
-        internal static ReadProgressEventArgs After(string archiveName, ZipEntry entry, int entriesTotal)
-        {
-            var x = new ReadProgressEventArgs(archiveName, ZipProgressEventType.Reading_AfterReadEntry);
-            x.EntriesTotal = entriesTotal;
-            x.CurrentEntry = entry;
-            return x;
-        }
-
-        internal static ReadProgressEventArgs Started(string archiveName)
-        {
-            var x = new ReadProgressEventArgs(archiveName, ZipProgressEventType.Reading_Started);
-            return x;
-        }
-
-        internal static ReadProgressEventArgs ByteUpdate(string archiveName, ZipEntry entry, Int64 bytesXferred, Int64 totalBytes)
-        {
-            var x = new ReadProgressEventArgs(archiveName, ZipProgressEventType.Reading_ArchiveBytesRead);
-            x.CurrentEntry = entry;
-            x.BytesTransferred = bytesXferred;
-            x.TotalBytesToTransfer = totalBytes;
-            return x;
-        }
-
-        internal static ReadProgressEventArgs Completed(string archiveName)
-        {
-            var x = new ReadProgressEventArgs(archiveName, ZipProgressEventType.Reading_Completed);
-            return x;
-        }
-
-    }
-
-
-    /// <summary>
-    /// Provides information about the progress of a Add operation.
-    /// </summary>
-    internal class AddProgressEventArgs : ZipProgressEventArgs
-    {
-        internal AddProgressEventArgs() { }
-
-        private AddProgressEventArgs(string archiveName, ZipProgressEventType flavor)
-            : base(archiveName, flavor)
-        { }
-
-        internal static AddProgressEventArgs AfterEntry(string archiveName, ZipEntry entry, int entriesTotal)
-        {
-            var x = new AddProgressEventArgs(archiveName, ZipProgressEventType.Adding_AfterAddEntry);
-            x.EntriesTotal = entriesTotal;
-            x.CurrentEntry = entry;
-            return x;
-        }
-
-        internal static AddProgressEventArgs Started(string archiveName)
-        {
-            var x = new AddProgressEventArgs(archiveName, ZipProgressEventType.Adding_Started);
-            return x;
-        }
-
-        internal static AddProgressEventArgs Completed(string archiveName)
-        {
-            var x = new AddProgressEventArgs(archiveName, ZipProgressEventType.Adding_Completed);
-            return x;
-        }
-
-    }
-
-    /// <summary>
-    /// Provides information about the progress of a save operation.
-    /// </summary>
-    internal class SaveProgressEventArgs : ZipProgressEventArgs
-    {
-        private int _entriesSaved;
-
-        /// <summary>
-        /// Constructor for the SaveProgressEventArgs.
-        /// </summary>
-        /// <param name="archiveName">the name of the zip archive.</param>
-        /// <param name="before">whether this is before saving the entry, or after</param>
-        /// <param name="entriesTotal">The total number of entries in the zip archive.</param>
-        /// <param name="entriesSaved">Number of entries that have been saved.</param>
-        /// <param name="entry">The entry involved in the event.</param>
-        internal SaveProgressEventArgs(string archiveName, bool before, int entriesTotal, int entriesSaved, ZipEntry entry)
-            : base(archiveName, (before) ? ZipProgressEventType.Saving_BeforeWriteEntry : ZipProgressEventType.Saving_AfterWriteEntry)
-        {
-            this.EntriesTotal = entriesTotal;
-            this.CurrentEntry = entry;
-            this._entriesSaved = entriesSaved;
-        }
-
-        internal SaveProgressEventArgs() { }
-
-        internal SaveProgressEventArgs(string archiveName, ZipProgressEventType flavor)
-            : base(archiveName, flavor)
-        { }
-
-
-        internal static SaveProgressEventArgs ByteUpdate(string archiveName, ZipEntry entry, Int64 bytesXferred, Int64 totalBytes)
-        {
-            var x = new SaveProgressEventArgs(archiveName, ZipProgressEventType.Saving_EntryBytesRead);
-            x.ArchiveName = archiveName;
-            x.CurrentEntry = entry;
-            x.BytesTransferred = bytesXferred;
-            x.TotalBytesToTransfer = totalBytes;
-            return x;
-        }
-
-        internal static SaveProgressEventArgs Started(string archiveName)
-        {
-            var x = new SaveProgressEventArgs(archiveName, ZipProgressEventType.Saving_Started);
-            return x;
-        }
-
-        internal static SaveProgressEventArgs Completed(string archiveName)
-        {
-            var x = new SaveProgressEventArgs(archiveName, ZipProgressEventType.Saving_Completed);
-            return x;
-        }
-
-        /// <summary>
-        /// Number of entries saved so far.
-        /// </summary>
-        public int EntriesSaved
-        {
-            get { return _entriesSaved; }
-        }
-    }
-
-
-    /// <summary>
-    /// Provides information about the progress of the extract operation.
-    /// </summary>
-    internal class ExtractProgressEventArgs : ZipProgressEventArgs
-    {
-        private int _entriesExtracted;
-        private string _target;
-
-        /// <summary>
-        /// Constructor for the ExtractProgressEventArgs.
-        /// </summary>
-        /// <param name="archiveName">the name of the zip archive.</param>
-        /// <param name="before">whether this is before saving the entry, or after</param>
-        /// <param name="entriesTotal">The total number of entries in the zip archive.</param>
-        /// <param name="entriesExtracted">Number of entries that have been extracted.</param>
-        /// <param name="entry">The entry involved in the event.</param>
-        /// <param name="extractLocation">The location to which entries are extracted.</param>
-        internal ExtractProgressEventArgs(string archiveName, bool before, int entriesTotal, int entriesExtracted, ZipEntry entry, string extractLocation)
-            : base(archiveName, (before) ? ZipProgressEventType.Extracting_BeforeExtractEntry : ZipProgressEventType.Extracting_AfterExtractEntry)
-        {
-            this.EntriesTotal = entriesTotal;
-            this.CurrentEntry = entry;
-            this._entriesExtracted = entriesExtracted;
-            this._target = extractLocation;
-        }
-
-        internal ExtractProgressEventArgs(string archiveName, ZipProgressEventType flavor)
-            : base(archiveName, flavor)
-        { }
-
-        internal ExtractProgressEventArgs()
-        { }
-
-
-        internal static ExtractProgressEventArgs BeforeExtractEntry(string archiveName, ZipEntry entry, string extractLocation)
-        {
-            var x = new ExtractProgressEventArgs
-                {
-                    ArchiveName = archiveName,
-                    EventType = ZipProgressEventType.Extracting_BeforeExtractEntry,
-                    CurrentEntry = entry,
-                    _target = extractLocation,
-                };
-            return x;
-        }
-
-        internal static ExtractProgressEventArgs ExtractExisting(string archiveName, ZipEntry entry, string extractLocation)
-        {
-            var x = new ExtractProgressEventArgs
-                {
-                    ArchiveName = archiveName,
-                    EventType = ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite,
-                    CurrentEntry = entry,
-                    _target = extractLocation,
-                };
-            return x;
-        }
-
-        internal static ExtractProgressEventArgs AfterExtractEntry(string archiveName, ZipEntry entry, string extractLocation)
-        {
-            var x = new ExtractProgressEventArgs
-                {
-                    ArchiveName = archiveName,
-                    EventType = ZipProgressEventType.Extracting_AfterExtractEntry,
-                    CurrentEntry = entry,
-                    _target = extractLocation,
-                };
-            return x;
-        }
-
-        internal static ExtractProgressEventArgs ExtractAllStarted(string archiveName, string extractLocation)
-        {
-            var x = new ExtractProgressEventArgs(archiveName, ZipProgressEventType.Extracting_BeforeExtractAll);
-            x._target = extractLocation;
-            return x;
-        }
-
-        internal static ExtractProgressEventArgs ExtractAllCompleted(string archiveName, string extractLocation)
-        {
-            var x = new ExtractProgressEventArgs(archiveName, ZipProgressEventType.Extracting_AfterExtractAll);
-            x._target = extractLocation;
-            return x;
-        }
-
-
-        internal static ExtractProgressEventArgs ByteUpdate(string archiveName, ZipEntry entry, Int64 bytesWritten, Int64 totalBytes)
-        {
-            var x = new ExtractProgressEventArgs(archiveName, ZipProgressEventType.Extracting_EntryBytesWritten);
-            x.ArchiveName = archiveName;
-            x.CurrentEntry = entry;
-            x.BytesTransferred = bytesWritten;
-            x.TotalBytesToTransfer = totalBytes;
-            return x;
-        }
-
-
-
-        /// <summary>
-        /// Number of entries extracted so far.  This is set only if the
-        /// EventType is Extracting_BeforeExtractEntry or Extracting_AfterExtractEntry, and
-        /// the Extract() is occurring witin the scope of a call to ExtractAll().
-        /// </summary>
-        public int EntriesExtracted
-        {
-            get { return _entriesExtracted; }
-        }
-
-        /// <summary>
-        /// Returns the extraction target location, a filesystem path.
-        /// </summary>
-        public String ExtractLocation
-        {
-            get { return _target; }
-        }
-
-    }
-
-
-
-    /// <summary>
-    /// Provides information about the an error that occurred while zipping.
-    /// </summary>
-    internal class ZipErrorEventArgs : ZipProgressEventArgs
-    {
-        private Exception _exc;
-        private ZipErrorEventArgs() { }
-        internal static ZipErrorEventArgs Saving(string archiveName, ZipEntry entry, Exception exception)
-        {
-            var x = new ZipErrorEventArgs
-                {
-                    EventType = ZipProgressEventType.Error_Saving,
-                    ArchiveName = archiveName,
-                    CurrentEntry = entry,
-                    _exc = exception
-                };
-            return x;
-        }
-
-        /// <summary>
-        /// Returns the exception that occurred, if any.
-        /// </summary>
-        public Exception @Exception
-        {
-            get { return _exc; }
-        }
-
-        /// <summary>
-        /// Returns the name of the file that caused the exception, if any.
-        /// </summary>
-        public String FileName
-        {
-            get { return CurrentEntry.LocalFileName; }
-        }
-    }
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/Exceptions.cs b/EPPlus/Packaging/DotNetZip/Exceptions.cs
deleted file mode 100644
index a5a2c81..0000000
--- a/EPPlus/Packaging/DotNetZip/Exceptions.cs
+++ /dev/null
@@ -1,300 +0,0 @@
-// Exceptions.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2008, 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-12 12:19:10>
-//
-// ------------------------------------------------------------------
-//
-// This module defines exceptions used in the class library.
-//
-
-
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-#if !NETCF
-using System.Runtime.Serialization;
-#endif
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    ///// <summary>
-    ///// Base exception type for all custom exceptions in the Zip library. It acts as a marker class.
-    ///// </summary>
-    //[AttributeUsage(AttributeTargets.Class)]
-    //public class ZipExceptionAttribute : Attribute { }
-
-
-
-    /// <summary>
-    /// Issued when an <c>ZipEntry.ExtractWithPassword()</c> method is invoked
-    /// with an incorrect password.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000B")]
-    public class BadPasswordException : ZipException
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public BadPasswordException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public BadPasswordException(String message)
-            : base(message)
-        { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        /// <param name="innerException">The innerException for this exception.</param>
-        public BadPasswordException(String message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
-
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected BadPasswordException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-          {  }
-#endif
-
-    }
-
-    /// <summary>
-    /// Indicates that a read was attempted on a stream, and bad or incomplete data was
-    /// received.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000A")]
-    public class BadReadException : ZipException
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public BadReadException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public BadReadException(String message)
-            : base(message)
-        { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        /// <param name="innerException">The innerException for this exception.</param>
-        public BadReadException(String message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected BadReadException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-          {  }
-#endif
-
-    }
-
-
-
-    /// <summary>
-    /// Issued when an CRC check fails upon extracting an entry from a zip archive.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00009")]
-    public class BadCrcException : ZipException
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public BadCrcException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public BadCrcException(String message)
-            : base(message)
-        { }
-
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected BadCrcException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-          {  }
-#endif
-
-    }
-
-
-    /// <summary>
-    /// Issued when errors occur saving a self-extracting archive.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00008")]
-    public class SfxGenerationException : ZipException
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public SfxGenerationException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public SfxGenerationException(String message)
-            : base(message)
-        { }
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected SfxGenerationException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-          {  }
-#endif
-
-    }
-
-
-    /// <summary>
-    /// Indicates that an operation was attempted on a ZipFile which was not possible
-    /// given the state of the instance. For example, if you call <c>Save()</c> on a ZipFile
-    /// which has no filename set, you can get this exception.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00007")]
-    public class BadStateException : ZipException
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public BadStateException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public BadStateException(String message)
-            : base(message)
-        { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        /// <param name="innerException">The innerException for this exception.</param>
-        public BadStateException(String message, Exception innerException)
-            : base(message, innerException)
-        {}
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected BadStateException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-          {  }
-#endif
-
-    }
-
-    /// <summary>
-    /// Base class for all exceptions defined by and throw by the Zip library.
-    /// </summary>
-#if !SILVERLIGHT
-    [Serializable]
-#endif
-    [System.Runtime.InteropServices.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00006")]
-    public class ZipException : Exception
-    {
-        /// <summary>
-        /// Default ctor.
-        /// </summary>
-        public ZipException() { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        public ZipException(String message) : base(message) { }
-
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="message">The message in the exception.</param>
-        /// <param name="innerException">The innerException for this exception.</param>
-        public ZipException(String message, Exception innerException)
-            : base(message, innerException)
-        { }
-
-#if ! (NETCF || SILVERLIGHT)
-        /// <summary>
-        /// Come on, you know how exceptions work. Why are you looking at this documentation?
-        /// </summary>
-        /// <param name="info">The serialization info for the exception.</param>
-        /// <param name="context">The streaming context from which to deserialize.</param>
-        protected ZipException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        { }
-#endif
-
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ExtractExistingFileAction.cs b/EPPlus/Packaging/DotNetZip/ExtractExistingFileAction.cs
deleted file mode 100644
index 3b4af1a..0000000
--- a/EPPlus/Packaging/DotNetZip/ExtractExistingFileAction.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-// ExtractExistingFileAction.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c)  2009 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-August-25 08:44:37>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ExtractExistingFileAction enum
-//
-// 
-// ------------------------------------------------------------------
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    /// <summary>
-    /// An enum for the options when extracting an entry would overwrite an existing file. 
-    /// </summary>
-    /// 
-    /// <remarks>
-    ///   <para>
-    ///     This enum describes the actions that the library can take when an
-    ///     <c>Extract()</c> or <c>ExtractWithPassword()</c> method is called to extract an
-    ///     entry to a filesystem, and the extraction would overwrite an existing filesystem
-    ///     file.
-    ///   </para>
-    /// </remarks>
-    ///
-    internal enum ExtractExistingFileAction
-    {
-        /// <summary>
-        /// Throw an exception when extraction would overwrite an existing file. (For
-        /// COM clients, this is a 0 (zero).)
-        /// </summary>
-        Throw,
-
-        /// <summary>
-        /// When extraction would overwrite an existing file, overwrite the file silently.
-        /// The overwrite will happen even if the target file is marked as read-only.
-        /// (For COM clients, this is a 1.)
-        /// </summary>
-        OverwriteSilently,
-
-        /// <summary>
-        /// When extraction would overwrite an existing file, don't overwrite the file, silently. 
-        /// (For COM clients, this is a 2.)
-        /// </summary>
-        DoNotOverwrite,
-
-        /// <summary>
-        /// When extraction would overwrite an existing file, invoke the ExtractProgress
-        /// event, using an event type of <see
-        /// cref="ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite"/>.  In
-        /// this way, the application can decide, just-in-time, whether to overwrite the
-        /// file. For example, a GUI application may wish to pop up a dialog to allow
-        /// the user to choose. You may want to examine the <see
-        /// cref="ExtractProgressEventArgs.ExtractLocation"/> property before making
-        /// the decision. If, after your processing in the Extract progress event, you
-        /// want to NOT extract the file, set <see cref="ZipEntry.ExtractExistingFile"/>
-        /// on the <c>ZipProgressEventArgs.CurrentEntry</c> to <c>DoNotOverwrite</c>.
-        /// If you do want to extract the file, set <c>ZipEntry.ExtractExistingFile</c>
-        /// to <c>OverwriteSilently</c>.  If you want to cancel the Extraction, set
-        /// <c>ZipProgressEventArgs.Cancel</c> to true.  Cancelling differs from using
-        /// DoNotOverwrite in that a cancel will not extract any further entries, if
-        /// there are any.  (For COM clients, the value of this enum is a 3.)
-        /// </summary>
-        InvokeExtractProgressEvent,
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/FileSelector.cs b/EPPlus/Packaging/DotNetZip/FileSelector.cs
deleted file mode 100644
index 85d5fcc..0000000
--- a/EPPlus/Packaging/DotNetZip/FileSelector.cs
+++ /dev/null
@@ -1,1609 +0,0 @@
-//#define SelectorTrace
-
-// FileSelector.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2008-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved: <2011-August-05 11:03:11>
-//
-// ------------------------------------------------------------------
-//
-// This module implements a "file selector" that finds files based on a
-// set of inclusion criteria, including filename, size, file time, and
-// potentially file attributes.  The criteria are given in a string with
-// a simple expression language. Examples:
-//
-// find all .txt files:
-//     name = *.txt
-//
-// shorthand for the above
-//     *.txt
-//
-// all files modified after January 1st, 2009
-//     mtime > 2009-01-01
-//
-// All .txt files modified after the first of the year
-//     name = *.txt  AND  mtime > 2009-01-01
-//
-// All .txt files modified after the first of the year, or any file with the archive bit set
-//     (name = *.txt  AND  mtime > 2009-01-01) or (attribtues = A)
-//
-// All .txt files or any file greater than 1mb in size
-//     (name = *.txt  or  size > 1mb)
-//
-// and so on.
-// ------------------------------------------------------------------
-
-
-using System;
-using System.Globalization;
-using System.IO;
-using System.Text;
-using System.Reflection;
-using System.ComponentModel;
-using System.Text.RegularExpressions;
-using System.Collections.Generic;
-#if SILVERLIGHT
-using System.Linq;
-#endif
-
-namespace OfficeOpenXml.Packaging.Ionic
-{
-
-    /// <summary>
-    /// Enumerates the options for a logical conjunction. This enum is intended for use
-    /// internally by the FileSelector class.
-    /// </summary>
-    internal enum LogicalConjunction
-    {
-        NONE,
-        AND,
-        OR,
-        XOR,
-    }
-
-    internal enum WhichTime
-    {
-        atime,
-        mtime,
-        ctime,
-    }
-
-
-    internal enum ComparisonOperator
-    {
-        [Description(">")]
-        GreaterThan,
-        [Description(">=")]
-        GreaterThanOrEqualTo,
-        [Description("<")]
-        LesserThan,
-        [Description("<=")]
-        LesserThanOrEqualTo,
-        [Description("=")]
-        EqualTo,
-        [Description("!=")]
-        NotEqualTo
-    }
-
-
-    internal abstract partial class SelectionCriterion
-    {
-        internal virtual bool Verbose
-        {
-            get;set;
-        }
-        internal abstract bool Evaluate(string filename);
-
-        [System.Diagnostics.Conditional("SelectorTrace")]
-        protected static void CriterionTrace(string format, params object[] args)
-        {
-            //System.Console.WriteLine("  " + format, args);
-        }
-    }
-
-
-    internal partial class SizeCriterion : SelectionCriterion
-    {
-        internal ComparisonOperator Operator;
-        internal Int64 Size;
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("size ").Append(EnumUtil.GetDescription(Operator)).Append(" ").Append(Size.ToString());
-            return sb.ToString();
-        }
-
-        internal override bool Evaluate(string filename)
-        {
-            System.IO.FileInfo fi = new System.IO.FileInfo(filename);
-            CriterionTrace("SizeCriterion::Evaluate('{0}' [{1}])",
-                           filename, this.ToString());
-            return _Evaluate(fi.Length);
-        }
-
-        private bool _Evaluate(Int64 Length)
-        {
-            bool result = false;
-            switch (Operator)
-            {
-                case ComparisonOperator.GreaterThanOrEqualTo:
-                    result = Length >= Size;
-                    break;
-                case ComparisonOperator.GreaterThan:
-                    result = Length > Size;
-                    break;
-                case ComparisonOperator.LesserThanOrEqualTo:
-                    result = Length <= Size;
-                    break;
-                case ComparisonOperator.LesserThan:
-                    result = Length < Size;
-                    break;
-                case ComparisonOperator.EqualTo:
-                    result = Length == Size;
-                    break;
-                case ComparisonOperator.NotEqualTo:
-                    result = Length != Size;
-                    break;
-                default:
-                    throw new ArgumentException("Operator");
-            }
-            return result;
-        }
-
-    }
-
-
-
-    internal partial class TimeCriterion : SelectionCriterion
-    {
-        internal ComparisonOperator Operator;
-        internal WhichTime Which;
-        internal DateTime Time;
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append(Which.ToString()).Append(" ").Append(EnumUtil.GetDescription(Operator)).Append(" ").Append(Time.ToString("yyyy-MM-dd-HH:mm:ss"));
-            return sb.ToString();
-        }
-
-        internal override bool Evaluate(string filename)
-        {
-            DateTime x;
-            switch (Which)
-            {
-                case WhichTime.atime:
-                    x = System.IO.File.GetLastAccessTime(filename).ToUniversalTime();
-                    break;
-                case WhichTime.mtime:
-                    x = System.IO.File.GetLastWriteTime(filename).ToUniversalTime();
-                    break;
-                case WhichTime.ctime:
-                    x = System.IO.File.GetCreationTime(filename).ToUniversalTime();
-                    break;
-                default:
-                    throw new ArgumentException("Operator");
-            }
-            CriterionTrace("TimeCriterion({0},{1})= {2}", filename, Which.ToString(), x);
-            return _Evaluate(x);
-        }
-
-
-        private bool _Evaluate(DateTime x)
-        {
-            bool result = false;
-            switch (Operator)
-            {
-                case ComparisonOperator.GreaterThanOrEqualTo:
-                    result = (x >= Time);
-                    break;
-                case ComparisonOperator.GreaterThan:
-                    result = (x > Time);
-                    break;
-                case ComparisonOperator.LesserThanOrEqualTo:
-                    result = (x <= Time);
-                    break;
-                case ComparisonOperator.LesserThan:
-                    result = (x < Time);
-                    break;
-                case ComparisonOperator.EqualTo:
-                    result = (x == Time);
-                    break;
-                case ComparisonOperator.NotEqualTo:
-                    result = (x != Time);
-                    break;
-                default:
-                    throw new ArgumentException("Operator");
-            }
-
-            CriterionTrace("TimeCriterion: {0}", result);
-            return result;
-        }
-    }
-
-
-
-    internal partial class NameCriterion : SelectionCriterion
-    {
-        private Regex _re;
-        private String _regexString;
-        internal ComparisonOperator Operator;
-        private string _MatchingFileSpec;
-        internal virtual string MatchingFileSpec
-        {
-            set
-            {
-                // workitem 8245
-                if (Directory.Exists(value))
-                {
-                    _MatchingFileSpec = ".\\" + value + "\\*.*";
-                }
-                else
-                {
-                    _MatchingFileSpec = value;
-                }
-
-                _regexString = "^" +
-                Regex.Escape(_MatchingFileSpec)
-                    .Replace(@"\\\*\.\*", @"\\([^\.]+|.*\.[^\\\.]*)")
-                    .Replace(@"\.\*", @"\.[^\\\.]*")
-                    .Replace(@"\*", @".*")
-                    //.Replace(@"\*", @"[^\\\.]*") // ill-conceived
-                    .Replace(@"\?", @"[^\\\.]")
-                    + "$";
-
-                CriterionTrace("NameCriterion regexString({0})", _regexString);
-
-                _re = new Regex(_regexString, RegexOptions.IgnoreCase);
-            }
-        }
-
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("name ").Append(EnumUtil.GetDescription(Operator))
-                .Append(" '")
-                .Append(_MatchingFileSpec)
-                .Append("'");
-            return sb.ToString();
-        }
-
-
-        internal override bool Evaluate(string filename)
-        {
-            CriterionTrace("NameCriterion::Evaluate('{0}' pattern[{1}])",
-                           filename, _MatchingFileSpec);
-            return _Evaluate(filename);
-        }
-
-        private bool _Evaluate(string fullpath)
-        {
-            CriterionTrace("NameCriterion::Evaluate({0})", fullpath);
-            // No slash in the pattern implicitly means recurse, which means compare to
-            // filename only, not full path.
-            String f = (_MatchingFileSpec.IndexOf('\\') == -1)
-                ? System.IO.Path.GetFileName(fullpath)
-                : fullpath; // compare to fullpath
-
-            bool result = _re.IsMatch(f);
-
-            if (Operator != ComparisonOperator.EqualTo)
-                result = !result;
-            return result;
-        }
-    }
-
-
-    internal partial class TypeCriterion : SelectionCriterion
-    {
-        private char ObjectType;  // 'D' = Directory, 'F' = File
-        internal ComparisonOperator Operator;
-        internal string AttributeString
-        {
-            get
-            {
-                return ObjectType.ToString();
-            }
-            set
-            {
-                if (value.Length != 1 ||
-                    (value[0]!='D' && value[0]!='F'))
-                    throw new ArgumentException("Specify a single character: either D or F");
-                ObjectType = value[0];
-            }
-        }
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("type ").Append(EnumUtil.GetDescription(Operator)).Append(" ").Append(AttributeString);
-            return sb.ToString();
-        }
-
-        internal override bool Evaluate(string filename)
-        {
-            CriterionTrace("TypeCriterion::Evaluate({0})", filename);
-
-            bool result = (ObjectType == 'D')
-                ? Directory.Exists(filename)
-                : File.Exists(filename);
-
-            if (Operator != ComparisonOperator.EqualTo)
-                result = !result;
-            return result;
-        }
-    }
-
-
-#if !SILVERLIGHT
-    internal partial class AttributesCriterion : SelectionCriterion
-    {
-        private FileAttributes _Attributes;
-        internal ComparisonOperator Operator;
-        internal string AttributeString
-        {
-            get
-            {
-                string result = "";
-                if ((_Attributes & FileAttributes.Hidden) != 0)
-                    result += "H";
-                if ((_Attributes & FileAttributes.System) != 0)
-                    result += "S";
-                if ((_Attributes & FileAttributes.ReadOnly) != 0)
-                    result += "R";
-                if ((_Attributes & FileAttributes.Archive) != 0)
-                    result += "A";
-                if ((_Attributes & FileAttributes.ReparsePoint) != 0)
-                    result += "L";
-                if ((_Attributes & FileAttributes.NotContentIndexed) != 0)
-                    result += "I";
-                return result;
-            }
-
-            set
-            {
-                _Attributes = FileAttributes.Normal;
-                foreach (char c in value.ToUpper(CultureInfo.InvariantCulture))
-                {
-                    switch (c)
-                    {
-                        case 'H':
-                            if ((_Attributes & FileAttributes.Hidden) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.Hidden;
-                            break;
-
-                        case 'R':
-                            if ((_Attributes & FileAttributes.ReadOnly) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.ReadOnly;
-                            break;
-
-                        case 'S':
-                            if ((_Attributes & FileAttributes.System) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.System;
-                            break;
-
-                        case 'A':
-                            if ((_Attributes & FileAttributes.Archive) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.Archive;
-                            break;
-
-                        case 'I':
-                            if ((_Attributes & FileAttributes.NotContentIndexed) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.NotContentIndexed;
-                            break;
-
-                        case 'L':
-                            if ((_Attributes & FileAttributes.ReparsePoint) != 0)
-                                throw new ArgumentException(String.Format("Repeated flag. ({0})", c), "value");
-                            _Attributes |= FileAttributes.ReparsePoint;
-                            break;
-
-                        default:
-                            throw new ArgumentException(value);
-                    }
-                }
-            }
-        }
-
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("attributes ").Append(EnumUtil.GetDescription(Operator)).Append(" ").Append(AttributeString);
-            return sb.ToString();
-        }
-
-        private bool _EvaluateOne(FileAttributes fileAttrs, FileAttributes criterionAttrs)
-        {
-            bool result = false;
-            if ((_Attributes & criterionAttrs) == criterionAttrs)
-                result = ((fileAttrs & criterionAttrs) == criterionAttrs);
-            else
-                result = true;
-            return result;
-        }
-
-
-
-        internal override bool Evaluate(string filename)
-        {
-            // workitem 10191
-            if (Directory.Exists(filename))
-            {
-                // Directories don't have file attributes, so the result
-                // of an evaluation is always NO. This gets negated if
-                // the operator is NotEqualTo.
-                return (Operator != ComparisonOperator.EqualTo);
-            }
-#if NETCF
-            FileAttributes fileAttrs = NetCfFile.GetAttributes(filename);
-#else
-            FileAttributes fileAttrs = System.IO.File.GetAttributes(filename);
-#endif
-
-            return _Evaluate(fileAttrs);
-        }
-
-        private bool _Evaluate(FileAttributes fileAttrs)
-        {
-            bool result = _EvaluateOne(fileAttrs, FileAttributes.Hidden);
-            if (result)
-                result = _EvaluateOne(fileAttrs, FileAttributes.System);
-            if (result)
-                result = _EvaluateOne(fileAttrs, FileAttributes.ReadOnly);
-            if (result)
-                result = _EvaluateOne(fileAttrs, FileAttributes.Archive);
-            if (result)
-                result = _EvaluateOne(fileAttrs, FileAttributes.NotContentIndexed);
-            if (result)
-                result = _EvaluateOne(fileAttrs, FileAttributes.ReparsePoint);
-
-            if (Operator != ComparisonOperator.EqualTo)
-                result = !result;
-
-            return result;
-        }
-    }
-#endif
-
-
-    internal partial class CompoundCriterion : SelectionCriterion
-    {
-        internal LogicalConjunction Conjunction;
-        internal SelectionCriterion Left;
-
-        private SelectionCriterion _Right;
-        internal SelectionCriterion Right
-        {
-            get { return _Right; }
-            set
-            {
-                _Right = value;
-                if (value == null)
-                    Conjunction = LogicalConjunction.NONE;
-                else if (Conjunction == LogicalConjunction.NONE)
-                    Conjunction = LogicalConjunction.AND;
-            }
-        }
-
-
-        internal override bool Evaluate(string filename)
-        {
-            bool result = Left.Evaluate(filename);
-            switch (Conjunction)
-            {
-                case LogicalConjunction.AND:
-                    if (result)
-                        result = Right.Evaluate(filename);
-                    break;
-                case LogicalConjunction.OR:
-                    if (!result)
-                        result = Right.Evaluate(filename);
-                    break;
-                case LogicalConjunction.XOR:
-                    result ^= Right.Evaluate(filename);
-                    break;
-                default:
-                    throw new ArgumentException("Conjunction");
-            }
-            return result;
-        }
-
-
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("(")
-            .Append((Left != null) ? Left.ToString() : "null")
-            .Append(" ")
-            .Append(Conjunction.ToString())
-            .Append(" ")
-            .Append((Right != null) ? Right.ToString() : "null")
-            .Append(")");
-            return sb.ToString();
-        }
-    }
-
-
-
-    /// <summary>
-    ///   FileSelector encapsulates logic that selects files from a source - a zip file
-    ///   or the filesystem - based on a set of criteria.  This class is used internally
-    ///   by the DotNetZip library, in particular for the AddSelectedFiles() methods.
-    ///   This class can also be used independently of the zip capability in DotNetZip.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///
-    /// <para>
-    ///   The FileSelector class is used internally by the ZipFile class for selecting
-    ///   files for inclusion into the ZipFile, when the <see
-    ///   cref="Ionic.Zip.ZipFile.AddSelectedFiles(String,String)"/> method, or one of
-    ///   its overloads, is called.  It's also used for the <see
-    ///   cref="Ionic.Zip.ZipFile.ExtractSelectedEntries(String)"/> methods.  Typically, an
-    ///   application that creates or manipulates Zip archives will not directly
-    ///   interact with the FileSelector class.
-    /// </para>
-    ///
-    /// <para>
-    ///   Some applications may wish to use the FileSelector class directly, to
-    ///   select files from disk volumes based on a set of criteria, without creating or
-    ///   querying Zip archives.  The file selection criteria include: a pattern to
-    ///   match the filename; the last modified, created, or last accessed time of the
-    ///   file; the size of the file; and the attributes of the file.
-    /// </para>
-    ///
-    /// <para>
-    ///   Consult the documentation for <see cref="SelectionCriteria"/>
-    ///   for more information on specifying the selection criteria.
-    /// </para>
-    ///
-    /// </remarks>
-    internal partial class FileSelector
-    {
-        internal SelectionCriterion _Criterion;
-
-#if NOTUSED
-        /// <summary>
-        ///   The default constructor.
-        /// </summary>
-        /// <remarks>
-        ///   Typically, applications won't use this constructor.  Instead they'll
-        ///   call the constructor that accepts a selectionCriteria string.  If you
-        ///   use this constructor, you'll want to set the SelectionCriteria
-        ///   property on the instance before calling SelectFiles().
-        /// </remarks>
-        protected FileSelector() { }
-#endif
-        /// <summary>
-        ///   Constructor that allows the caller to specify file selection criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This constructor allows the caller to specify a set of criteria for
-        ///   selection of files.
-        /// </para>
-        ///
-        /// <para>
-        ///   See <see cref="FileSelector.SelectionCriteria"/> for a description of
-        ///   the syntax of the selectionCriteria string.
-        /// </para>
-        ///
-        /// <para>
-        ///   By default the FileSelector will traverse NTFS Reparse Points.  To
-        ///   change this, use <see cref="FileSelector(String,
-        ///   bool)">FileSelector(String, bool)</see>.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection.</param>
-        public FileSelector(String selectionCriteria)
-        : this(selectionCriteria, true)
-        {
-        }
-
-        /// <summary>
-        ///   Constructor that allows the caller to specify file selection criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This constructor allows the caller to specify a set of criteria for
-        ///   selection of files.
-        /// </para>
-        ///
-        /// <para>
-        ///   See <see cref="FileSelector.SelectionCriteria"/> for a description of
-        ///   the syntax of the selectionCriteria string.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection.</param>
-        /// <param name="traverseDirectoryReparsePoints">
-        /// whether to traverse NTFS reparse points (junctions).
-        /// </param>
-        public FileSelector(String selectionCriteria, bool traverseDirectoryReparsePoints)
-        {
-            if (!String.IsNullOrEmpty(selectionCriteria))
-                _Criterion = _ParseCriterion(selectionCriteria);
-            TraverseReparsePoints = traverseDirectoryReparsePoints;
-        }
-
-
-
-        /// <summary>
-        ///   The string specifying which files to include when retrieving.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Specify the criteria in statements of 3 elements: a noun, an operator,
-        ///   and a value.  Consider the string "name != *.doc" .  The noun is
-        ///   "name".  The operator is "!=", implying "Not Equal".  The value is
-        ///   "*.doc".  That criterion, in English, says "all files with a name that
-        ///   does not end in the .doc extension."
-        /// </para>
-        ///
-        /// <para>
-        ///   Supported nouns include "name" (or "filename") for the filename;
-        ///   "atime", "mtime", and "ctime" for last access time, last modfied time,
-        ///   and created time of the file, respectively; "attributes" (or "attrs")
-        ///   for the file attributes; "size" (or "length") for the file length
-        ///   (uncompressed); and "type" for the type of object, either a file or a
-        ///   directory.  The "attributes", "type", and "name" nouns all support =
-        ///   and != as operators.  The "size", "atime", "mtime", and "ctime" nouns
-        ///   support = and !=, and &gt;, &gt;=, &lt;, &lt;= as well.  The times are
-        ///   taken to be expressed in local time.
-        /// </para>
-        ///
-        /// <para>
-        ///   Specify values for the file attributes as a string with one or more of
-        ///   the characters H,R,S,A,I,L in any order, implying file attributes of
-        ///   Hidden, ReadOnly, System, Archive, NotContextIndexed, and ReparsePoint
-        ///   (symbolic link) respectively.
-        /// </para>
-        ///
-        /// <para>
-        ///   To specify a time, use YYYY-MM-DD-HH:mm:ss or YYYY/MM/DD-HH:mm:ss as
-        ///   the format.  If you omit the HH:mm:ss portion, it is assumed to be
-        ///   00:00:00 (midnight).
-        /// </para>
-        ///
-        /// <para>
-        ///   The value for a size criterion is expressed in integer quantities of
-        ///   bytes, kilobytes (use k or kb after the number), megabytes (m or mb),
-        ///   or gigabytes (g or gb).
-        /// </para>
-        ///
-        /// <para>
-        ///   The value for a name is a pattern to match against the filename,
-        ///   potentially including wildcards.  The pattern follows CMD.exe glob
-        ///   rules: * implies one or more of any character, while ?  implies one
-        ///   character.  If the name pattern contains any slashes, it is matched to
-        ///   the entire filename, including the path; otherwise, it is matched
-        ///   against only the filename without the path.  This means a pattern of
-        ///   "*\*.*" matches all files one directory level deep, while a pattern of
-        ///   "*.*" matches all files in all directories.
-        /// </para>
-        ///
-        /// <para>
-        ///   To specify a name pattern that includes spaces, use single quotes
-        ///   around the pattern.  A pattern of "'* *.*'" will match all files that
-        ///   have spaces in the filename.  The full criteria string for that would
-        ///   be "name = '* *.*'" .
-        /// </para>
-        ///
-        /// <para>
-        ///   The value for a type criterion is either F (implying a file) or D
-        ///   (implying a directory).
-        /// </para>
-        ///
-        /// <para>
-        ///   Some examples:
-        /// </para>
-        ///
-        /// <list type="table">
-        ///   <listheader>
-        ///     <term>criteria</term>
-        ///     <description>Files retrieved</description>
-        ///   </listheader>
-        ///
-        ///   <item>
-        ///     <term>name != *.xls </term>
-        ///     <description>any file with an extension that is not .xls
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>name = *.mp3 </term>
-        ///     <description>any file with a .mp3 extension.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>*.mp3</term>
-        ///     <description>(same as above) any file with a .mp3 extension.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>attributes = A </term>
-        ///     <description>all files whose attributes include the Archive bit.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>attributes != H </term>
-        ///     <description>all files whose attributes do not include the Hidden bit.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>mtime > 2009-01-01</term>
-        ///     <description>all files with a last modified time after January 1st, 2009.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>ctime > 2009/01/01-03:00:00</term>
-        ///     <description>all files with a created time after 3am (local time),
-        ///     on January 1st, 2009.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>size > 2gb</term>
-        ///     <description>all files whose uncompressed size is greater than 2gb.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>type = D</term>
-        ///     <description>all directories in the filesystem. </description>
-        ///   </item>
-        ///
-        /// </list>
-        ///
-        /// <para>
-        ///   You can combine criteria with the conjunctions AND, OR, and XOR. Using
-        ///   a string like "name = *.txt AND size &gt;= 100k" for the
-        ///   selectionCriteria retrieves entries whose names end in .txt, and whose
-        ///   uncompressed size is greater than or equal to 100 kilobytes.
-        /// </para>
-        ///
-        /// <para>
-        ///   For more complex combinations of criteria, you can use parenthesis to
-        ///   group clauses in the boolean logic.  Absent parenthesis, the
-        ///   precedence of the criterion atoms is determined by order of
-        ///   appearance.  Unlike the C# language, the AND conjunction does not take
-        ///   precendence over the logical OR.  This is important only in strings
-        ///   that contain 3 or more criterion atoms.  In other words, "name = *.txt
-        ///   and size &gt; 1000 or attributes = H" implies "((name = *.txt AND size
-        ///   &gt; 1000) OR attributes = H)" while "attributes = H OR name = *.txt
-        ///   and size &gt; 1000" evaluates to "((attributes = H OR name = *.txt)
-        ///   AND size &gt; 1000)".  When in doubt, use parenthesis.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using time properties requires some extra care. If you want to
-        ///   retrieve all entries that were last updated on 2009 February 14,
-        ///   specify "mtime &gt;= 2009-02-14 AND mtime &lt; 2009-02-15".  Read this
-        ///   to say: all files updated after 12:00am on February 14th, until
-        ///   12:00am on February 15th.  You can use the same bracketing approach to
-        ///   specify any time period - a year, a month, a week, and so on.
-        /// </para>
-        ///
-        /// <para>
-        ///   The syntax allows one special case: if you provide a string with no
-        ///   spaces, it is treated as a pattern to match for the filename.
-        ///   Therefore a string like "*.xls" will be equivalent to specifying "name
-        ///   = *.xls".  This "shorthand" notation does not work with compound
-        ///   criteria.
-        /// </para>
-        ///
-        /// <para>
-        ///   There is no logic in this class that insures that the inclusion
-        ///   criteria are internally consistent.  For example, it's possible to
-        ///   specify criteria that says the file must have a size of less than 100
-        ///   bytes, as well as a size that is greater than 1000 bytes.  Obviously
-        ///   no file will ever satisfy such criteria, but this class does not check
-        ///   for or detect such inconsistencies.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        ///   Thrown in the setter if the value has an invalid syntax.
-        /// </exception>
-        public String SelectionCriteria
-        {
-            get
-            {
-                if (_Criterion == null) return null;
-                return _Criterion.ToString();
-            }
-            set
-            {
-                if (value == null) _Criterion = null;
-                else if (value.Trim() == "") _Criterion = null;
-                else
-                    _Criterion = _ParseCriterion(value);
-            }
-        }
-
-        /// <summary>
-        ///  Indicates whether searches will traverse NTFS reparse points, like Junctions.
-        /// </summary>
-        public bool TraverseReparsePoints
-        {
-            get; set;
-        }
-
-
-        private enum ParseState
-        {
-            Start,
-            OpenParen,
-            CriterionDone,
-            ConjunctionPending,
-            Whitespace,
-        }
-
-
-        private static class RegexAssertions
-        {
-            public static readonly String PrecededByOddNumberOfSingleQuotes = "(?<=(?:[^']*'[^']*')*'[^']*)";
-            public static readonly String FollowedByOddNumberOfSingleQuotesAndLineEnd = "(?=[^']*'(?:[^']*'[^']*')*[^']*$)";
-
-            public static readonly String PrecededByEvenNumberOfSingleQuotes = "(?<=(?:[^']*'[^']*')*[^']*)";
-            public static readonly String FollowedByEvenNumberOfSingleQuotesAndLineEnd = "(?=(?:[^']*'[^']*')*[^']*$)";
-        }
-
-
-        private static string NormalizeCriteriaExpression(string source)
-        {
-            // The goal here is to normalize the criterion expression. At output, in
-            // the transformed criterion string, every significant syntactic element
-            // - a property element, grouping paren for the boolean logic, operator
-            // ( = < > != ), conjunction, or property value - will be separated from
-            // its neighbors by at least one space. Thus,
-            //
-            // before                         after
-            // -------------------------------------------------------------------
-            // name=*.txt                     name = *.txt
-            // (size>100)AND(name=*.txt)      ( size > 100 ) AND ( name = *.txt )
-            //
-            // This is relatively straightforward using regular expression
-            // replacement. This method applies a distinct regex pattern and
-            // corresponding replacement string for each one of a number of cases:
-            // an open paren followed by a word; a word followed by a close-paren; a
-            // pair of open parens; a close paren followed by a word (which should
-            // then be followed by an open paren). And so on. These patterns and
-            // replacements are all stored in prPairs. By applying each of these
-            // regex replacements in turn, we get the transformed string. Easy.
-            //
-            // The resulting "normalized" criterion string, is then used as the
-            // subject that gets parsed, by splitting the string into tokens that
-            // are separated by spaces.  Here, there's a twist. The spaces within
-            // single-quote delimiters do not delimit distinct tokens.  So, this
-            // normalization method temporarily replaces those spaces with
-            // ASCII 6 (0x06), a control character which is not a legal
-            // character in a filename. The parsing logic that happens later will
-            // revert that change, restoring the original value of the filename
-            // specification.
-            //
-            // To illustrate, for a "before" string of [(size>100)AND(name='Name
-            // (with Parens).txt')] , the "after" string is [( size > 100 ) AND
-            // ( name = 'Name\u0006(with\u0006Parens).txt' )].
-            //
-
-            string[][] prPairs =
-                {
-                    // A. opening double parens - insert a space between them
-                    new string[] { @"([^']*)\(\(([^']+)", "$1( ($2" },
-
-                    // B. closing double parens - insert a space between
-                    new string[] { @"(.)\)\)", "$1) )" },
-
-                    // C. single open paren with a following word - insert a space between
-                    new string[] { @"\((\S)", "( $1" },
-
-                    // D. single close paren with a preceding word - insert a space between the two
-                    new string[] { @"(\S)\)", "$1 )" },
-
-                    // E. close paren at line start?, insert a space before the close paren
-                    // this seems like a degenerate case.  I don't recall why it's here.
-                    new string[] { @"^\)", " )" },
-
-                    // F. a word (likely a conjunction) followed by an open paren - insert a space between
-                    new string[] { @"(\S)\(", "$1 (" },
-
-                    // G. single close paren followed by word - insert a paren after close paren
-                    new string[] { @"\)(\S)", ") $1" },
-
-                    // H. insert space between = and a following single quote
-                    //new string[] { @"(=|!=)('[^']*')", "$1 $2" },
-                    new string[] { @"(=)('[^']*')", "$1 $2" },
-
-                    // I. insert space between property names and the following operator
-                    //new string[] { @"([^ ])([><(?:!=)=])", "$1 $2" },
-                    new string[] { @"([^ !><])(>|<|!=|=)", "$1 $2" },
-
-                    // J. insert spaces between operators and the following values
-                    //new string[] { @"([><(?:!=)=])([^ ])", "$1 $2" },
-                    new string[] { @"(>|<|!=|=)([^ =])", "$1 $2" },
-
-                    // K. replace fwd slash with backslash
-                    new string[] { @"/", "\\" },
-                };
-
-            string interim = source;
-
-            for (int i=0; i < prPairs.Length; i++)
-            {
-                //char caseIdx = (char)('A' + i);
-                string pattern = RegexAssertions.PrecededByEvenNumberOfSingleQuotes +
-                    prPairs[i][0] +
-                    RegexAssertions.FollowedByEvenNumberOfSingleQuotesAndLineEnd;
-
-                interim = Regex.Replace(interim, pattern, prPairs[i][1]);
-            }
-
-            // match a fwd slash, followed by an odd number of single quotes.
-            // This matches fwd slashes only inside a pair of single quote delimiters,
-            // eg, a filename.  This must be done as well as the case above, to handle
-            // filenames specified inside quotes as well as filenames without quotes.
-            var regexPattern = @"/" +
-                                RegexAssertions.FollowedByOddNumberOfSingleQuotesAndLineEnd;
-            // replace with backslash
-            interim = Regex.Replace(interim, regexPattern, "\\");
-
-            // match a space, followed by an odd number of single quotes.
-            // This matches spaces only inside a pair of single quote delimiters.
-            regexPattern = " " +
-                RegexAssertions.FollowedByOddNumberOfSingleQuotesAndLineEnd;
-
-            // Replace all spaces that appear inside single quotes, with
-            // ascii 6.  This allows a split on spaces to get tokens in
-            // the expression. The split will not split any filename or
-            // wildcard that appears within single quotes. After tokenizing, we
-            // need to replace ascii 6 with ascii 32 to revert the
-            // spaces within quotes.
-            return Regex.Replace(interim, regexPattern, "\u0006");
-        }
-
-
-        private static SelectionCriterion _ParseCriterion(String s)
-        {
-            if (s == null) return null;
-
-            // inject spaces after open paren and before close paren, etc
-            s = NormalizeCriteriaExpression(s);
-
-            // no spaces in the criteria is shorthand for filename glob
-            if (s.IndexOf(" ") == -1)
-                s = "name = " + s;
-
-            // split the expression into tokens
-            string[] tokens = s.Trim().Split(' ', '\t');
-
-            if (tokens.Length < 3) throw new ArgumentException(s);
-
-            SelectionCriterion current = null;
-
-            LogicalConjunction pendingConjunction = LogicalConjunction.NONE;
-
-            ParseState state;
-            var stateStack = new System.Collections.Generic.Stack<ParseState>();
-            var critStack = new System.Collections.Generic.Stack<SelectionCriterion>();
-            stateStack.Push(ParseState.Start);
-
-            for (int i = 0; i < tokens.Length; i++)
-            {
-                string tok1 = tokens[i].ToLower(CultureInfo.InvariantCulture);
-                switch (tok1)
-                {
-                    case "and":
-                    case "xor":
-                    case "or":
-                        state = stateStack.Peek();
-                        if (state != ParseState.CriterionDone)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        if (tokens.Length <= i + 3)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        pendingConjunction = (LogicalConjunction)Enum.Parse(typeof(LogicalConjunction), tokens[i].ToUpper(CultureInfo.InvariantCulture), true);
-                        current = new CompoundCriterion { Left = current, Right = null, Conjunction = pendingConjunction };
-                        stateStack.Push(state);
-                        stateStack.Push(ParseState.ConjunctionPending);
-                        critStack.Push(current);
-                        break;
-
-                    case "(":
-                        state = stateStack.Peek();
-                        if (state != ParseState.Start && state != ParseState.ConjunctionPending && state != ParseState.OpenParen)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        if (tokens.Length <= i + 4)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        stateStack.Push(ParseState.OpenParen);
-                        break;
-
-                    case ")":
-                        state = stateStack.Pop();
-                        if (stateStack.Peek() != ParseState.OpenParen)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        stateStack.Pop();
-                        stateStack.Push(ParseState.CriterionDone);
-                        break;
-
-                    case "atime":
-                    case "ctime":
-                    case "mtime":
-                        if (tokens.Length <= i + 2)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        DateTime t;
-                        try
-                        {
-                            t = DateTime.ParseExact(tokens[i + 2], "yyyy-MM-dd-HH:mm:ss", null);
-                        }
-                        catch (FormatException)
-                        {
-                            try
-                            {
-                                t = DateTime.ParseExact(tokens[i + 2], "yyyy/MM/dd-HH:mm:ss", null);
-                            }
-                            catch (FormatException)
-                            {
-                                try
-                                {
-                                    t = DateTime.ParseExact(tokens[i + 2], "yyyy/MM/dd", null);
-                                }
-                                catch (FormatException)
-                                {
-                                    try
-                                    {
-                                        t = DateTime.ParseExact(tokens[i + 2], "MM/dd/yyyy", null);
-                                    }
-                                    catch (FormatException)
-                                    {
-                                        t = DateTime.ParseExact(tokens[i + 2], "yyyy-MM-dd", null);
-                                    }
-                                }
-                            }
-                        }
-                        t= DateTime.SpecifyKind(t, DateTimeKind.Local).ToUniversalTime();
-                        current = new TimeCriterion
-                        {
-                            Which = (WhichTime)Enum.Parse(typeof(WhichTime), tokens[i], true),
-                            Operator = (ComparisonOperator)EnumUtil.Parse(typeof(ComparisonOperator), tokens[i + 1]),
-                            Time = t
-                        };
-                        i += 2;
-                        stateStack.Push(ParseState.CriterionDone);
-                        break;
-
-
-                    case "length":
-                    case "size":
-                        if (tokens.Length <= i + 2)
-                            throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                        Int64 sz = 0;
-                        string v = tokens[i + 2];
-                        if (v.EndsWith("K", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 1)) * 1024;
-                        else if (v.EndsWith("KB", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 2)) * 1024;
-                        else if (v.EndsWith("M", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 1)) * 1024 * 1024;
-                        else if (v.EndsWith("MB", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 2)) * 1024 * 1024;
-                        else if (v.EndsWith("G", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 1)) * 1024 * 1024 * 1024;
-                        else if (v.EndsWith("GB", StringComparison.InvariantCultureIgnoreCase))
-                            sz = Int64.Parse(v.Substring(0, v.Length - 2)) * 1024 * 1024 * 1024;
-                        else sz = Int64.Parse(tokens[i + 2]);
-
-                        current = new SizeCriterion
-                        {
-                            Size = sz,
-                            Operator = (ComparisonOperator)EnumUtil.Parse(typeof(ComparisonOperator), tokens[i + 1])
-                        };
-                        i += 2;
-                        stateStack.Push(ParseState.CriterionDone);
-                        break;
-
-                    case "filename":
-                    case "name":
-                        {
-                            if (tokens.Length <= i + 2)
-                                throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                            ComparisonOperator c =
-                                (ComparisonOperator)EnumUtil.Parse(typeof(ComparisonOperator), tokens[i + 1]);
-
-                            if (c != ComparisonOperator.NotEqualTo && c != ComparisonOperator.EqualTo)
-                                throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                            string m = tokens[i + 2];
-
-                            // handle single-quoted filespecs (used to include
-                            // spaces in filename patterns)
-                            if (m.StartsWith("'") && m.EndsWith("'"))
-                            {
-                                // trim off leading and trailing single quotes and
-                                // revert the control characters to spaces.
-                                m = m.Substring(1, m.Length - 2)
-                                    .Replace("\u0006", " ");
-                            }
-
-                            // if (m.StartsWith("'"))
-                            //     m = m.Replace("\u0006", " ");
-
-                            current = new NameCriterion
-                            {
-                                MatchingFileSpec = m,
-                                Operator = c
-                            };
-                            i += 2;
-                            stateStack.Push(ParseState.CriterionDone);
-                        }
-                        break;
-
-#if !SILVERLIGHT
-                    case "attrs":
-                    case "attributes":
-#endif
-                    case "type":
-                        {
-                            if (tokens.Length <= i + 2)
-                                throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-                            ComparisonOperator c =
-                                (ComparisonOperator)EnumUtil.Parse(typeof(ComparisonOperator), tokens[i + 1]);
-
-                            if (c != ComparisonOperator.NotEqualTo && c != ComparisonOperator.EqualTo)
-                                throw new ArgumentException(String.Join(" ", tokens, i, tokens.Length - i));
-
-#if SILVERLIGHT
-                            current = (SelectionCriterion) new TypeCriterion
-                                    {
-                                        AttributeString = tokens[i + 2],
-                                        Operator = c
-                                    };
-#else
-                            current = (tok1 == "type")
-                                ? (SelectionCriterion) new TypeCriterion
-                                    {
-                                        AttributeString = tokens[i + 2],
-                                        Operator = c
-                                    }
-                                : (SelectionCriterion) new AttributesCriterion
-                                    {
-                                        AttributeString = tokens[i + 2],
-                                        Operator = c
-                                    };
-#endif
-                            i += 2;
-                            stateStack.Push(ParseState.CriterionDone);
-                        }
-                        break;
-
-                    case "":
-                        // NOP
-                        stateStack.Push(ParseState.Whitespace);
-                        break;
-
-                    default:
-                        throw new ArgumentException("'" + tokens[i] + "'");
-                }
-
-                state = stateStack.Peek();
-                if (state == ParseState.CriterionDone)
-                {
-                    stateStack.Pop();
-                    if (stateStack.Peek() == ParseState.ConjunctionPending)
-                    {
-                        while (stateStack.Peek() == ParseState.ConjunctionPending)
-                        {
-                            var cc = critStack.Pop() as CompoundCriterion;
-                            cc.Right = current;
-                            current = cc; // mark the parent as current (walk up the tree)
-                            stateStack.Pop();   // the conjunction is no longer pending
-
-                            state = stateStack.Pop();
-                            if (state != ParseState.CriterionDone)
-                                throw new ArgumentException("??");
-                        }
-                    }
-                    else stateStack.Push(ParseState.CriterionDone);  // not sure?
-                }
-
-                if (state == ParseState.Whitespace)
-                    stateStack.Pop();
-            }
-
-            return current;
-        }
-
-
-        /// <summary>
-        /// Returns a string representation of the FileSelector object.
-        /// </summary>
-        /// <returns>The string representation of the boolean logic statement of the file
-        /// selection criteria for this instance. </returns>
-        public override String ToString()
-        {
-            return "FileSelector("+_Criterion.ToString()+")";
-        }
-
-
-        private bool Evaluate(string filename)
-        {
-            // dinoch - Thu, 11 Feb 2010  18:34
-            SelectorTrace("Evaluate({0})", filename);
-            bool result = _Criterion.Evaluate(filename);
-            return result;
-        }
-
-        [System.Diagnostics.Conditional("SelectorTrace")]
-        private void SelectorTrace(string format, params object[] args)
-        {
-            if (_Criterion != null && _Criterion.Verbose)
-                System.Console.WriteLine(format, args);
-        }
-
-        /// <summary>
-        ///   Returns the names of the files in the specified directory
-        ///   that fit the selection criteria specified in the FileSelector.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This is equivalent to calling <see cref="SelectFiles(String, bool)"/>
-        ///   with recurseDirectories = false.
-        /// </remarks>
-        ///
-        /// <param name="directory">
-        ///   The name of the directory over which to apply the FileSelector
-        ///   criteria.
-        /// </param>
-        ///
-        /// <returns>
-        ///   A collection of strings containing fully-qualified pathnames of files
-        ///   that match the criteria specified in the FileSelector instance.
-        /// </returns>
-        public System.Collections.Generic.ICollection<String> SelectFiles(String directory)
-        {
-            return SelectFiles(directory, false);
-        }
-
-
-        /// <summary>
-        ///   Returns the names of the files in the specified directory that fit the
-        ///   selection criteria specified in the FileSelector, optionally recursing
-        ///   through subdirectories.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This method applies the file selection criteria contained in the
-        ///   FileSelector to the files contained in the given directory, and
-        ///   returns the names of files that conform to the criteria.
-        /// </remarks>
-        ///
-        /// <param name="directory">
-        ///   The name of the directory over which to apply the FileSelector
-        ///   criteria.
-        /// </param>
-        ///
-        /// <param name="recurseDirectories">
-        ///   Whether to recurse through subdirectories when applying the file
-        ///   selection criteria.
-        /// </param>
-        ///
-        /// <returns>
-        ///   A collection of strings containing fully-qualified pathnames of files
-        ///   that match the criteria specified in the FileSelector instance.
-        /// </returns>
-        public System.Collections.ObjectModel.ReadOnlyCollection<String>
-            SelectFiles(String directory,
-                        bool recurseDirectories)
-        {
-            if (_Criterion == null)
-                throw new ArgumentException("SelectionCriteria has not been set");
-
-            var list = new List<String>();
-            try
-            {
-                if (Directory.Exists(directory))
-                {
-                    String[] filenames = Directory.GetFiles(directory);
-
-                    // add the files:
-                    foreach (String filename in filenames)
-                    {
-                        if (Evaluate(filename))
-                            list.Add(filename);
-                    }
-
-                    if (recurseDirectories)
-                    {
-                        // add the subdirectories:
-                        String[] dirnames = Directory.GetDirectories(directory);
-                        foreach (String dir in dirnames)
-                        {
-                            if (this.TraverseReparsePoints
-#if !SILVERLIGHT
-                                || ((File.GetAttributes(dir) & FileAttributes.ReparsePoint) == 0)
-#endif
-                                )
-                            {
-                                // workitem 10191
-                                if (Evaluate(dir)) list.Add(dir);
-                                list.AddRange(this.SelectFiles(dir, recurseDirectories));
-                            }
-                        }
-                    }
-                }
-            }
-            // can get System.UnauthorizedAccessException here
-            catch (System.UnauthorizedAccessException)
-            {
-            }
-            catch (System.IO.IOException)
-            {
-            }
-
-            return list.AsReadOnly();
-        }
-    }
-
-
-
-    /// <summary>
-    /// Summary description for EnumUtil.
-    /// </summary>
-    internal sealed class EnumUtil
-    {
-        private EnumUtil() { }
-        /// <summary>
-        ///   Returns the value of the DescriptionAttribute if the specified Enum
-        ///   value has one.  If not, returns the ToString() representation of the
-        ///   Enum value.
-        /// </summary>
-        /// <param name="value">The Enum to get the description for</param>
-        /// <returns></returns>
-        internal static string GetDescription(System.Enum value)
-        {
-            FieldInfo fi = value.GetType().GetField(value.ToString());
-            var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
-            if (attributes.Length > 0)
-                return attributes[0].Description;
-            else
-                return value.ToString();
-        }
-
-        /// <summary>
-        ///   Converts the string representation of the name or numeric value of one
-        ///   or more enumerated constants to an equivalent enumerated object.
-        ///   Note: use the DescriptionAttribute on enum values to enable this.
-        /// </summary>
-        /// <param name="enumType">The System.Type of the enumeration.</param>
-        /// <param name="stringRepresentation">
-        ///   A string containing the name or value to convert.
-        /// </param>
-        /// <returns></returns>
-        internal static object Parse(Type enumType, string stringRepresentation)
-        {
-            return Parse(enumType, stringRepresentation, false);
-        }
-
-
-#if SILVERLIGHT
-       public static System.Enum[] GetEnumValues(Type type)
-        {
-            if (!type.IsEnum)
-                throw new ArgumentException("not an enum");
-
-            return (
-              from field in type.GetFields(BindingFlags.Public | BindingFlags.Static)
-              where field.IsLiteral
-              select (System.Enum)field.GetValue(null)
-            ).ToArray();
-        }
-
-        public static string[] GetEnumStrings<T>()
-        {
-            var type = typeof(T);
-            if (!type.IsEnum)
-                throw new ArgumentException("not an enum");
-
-            return (
-              from field in type.GetFields(BindingFlags.Public | BindingFlags.Static)
-              where field.IsLiteral
-              select field.Name
-            ).ToArray();
-        }
-#endif
-
-        /// <summary>
-        ///   Converts the string representation of the name or numeric value of one
-        ///   or more enumerated constants to an equivalent enumerated object.  A
-        ///   parameter specified whether the operation is case-sensitive.  Note:
-        ///   use the DescriptionAttribute on enum values to enable this.
-        /// </summary>
-        /// <param name="enumType">The System.Type of the enumeration.</param>
-        /// <param name="stringRepresentation">
-        ///   A string containing the name or value to convert.
-        /// </param>
-        /// <param name="ignoreCase">
-        ///   Whether the operation is case-sensitive or not.</param>
-        /// <returns></returns>
-        internal static object Parse(Type enumType, string stringRepresentation, bool ignoreCase)
-        {
-            if (ignoreCase)
-                stringRepresentation = stringRepresentation.ToLower(CultureInfo.InvariantCulture);
-
-#if SILVERLIGHT
-            foreach (System.Enum enumVal in GetEnumValues(enumType))
-#else
-            foreach (System.Enum enumVal in System.Enum.GetValues(enumType))
-#endif
-            {
-                string description = GetDescription(enumVal);
-                if (ignoreCase)
-                    description = description.ToLower(CultureInfo.InvariantCulture);
-                if (description == stringRepresentation)
-                    return enumVal;
-            }
-
-            return System.Enum.Parse(enumType, stringRepresentation, ignoreCase);
-        }
-    }
-
-
-#if DEMO
-    internal class DemonstrateFileSelector
-    {
-        private string _directory;
-        private bool _recurse;
-        private bool _traverse;
-        private bool _verbose;
-        private string _selectionCriteria;
-        private FileSelector f;
-
-        public DemonstrateFileSelector()
-        {
-            this._directory = ".";
-            this._recurse = true;
-        }
-
-        public DemonstrateFileSelector(string[] args) : this()
-        {
-            for (int i = 0; i < args.Length; i++)
-            {
-                switch(args[i])
-                {
-                case"-?":
-                    Usage();
-                    Environment.Exit(0);
-                    break;
-                case "-d":
-                    i++;
-                    if (args.Length <= i)
-                        throw new ArgumentException("-directory");
-                    this._directory = args[i];
-                    break;
-                case "-norecurse":
-                    this._recurse = false;
-                    break;
-
-                case "-j-":
-                    this._traverse = false;
-                    break;
-
-                case "-j+":
-                    this._traverse = true;
-                    break;
-
-                case "-v":
-                    this._verbose = true;
-                    break;
-
-                default:
-                    if (this._selectionCriteria != null)
-                        throw new ArgumentException(args[i]);
-                    this._selectionCriteria = args[i];
-                    break;
-                }
-
-                if (this._selectionCriteria != null)
-                    this.f = new FileSelector(this._selectionCriteria);
-            }
-        }
-
-
-        public static void Main(string[] args)
-        {
-            try
-            {
-                Console.WriteLine();
-                new DemonstrateFileSelector(args).Run();
-            }
-            catch (Exception exc1)
-            {
-                Console.WriteLine("Exception: {0}", exc1.ToString());
-                Usage();
-            }
-        }
-
-
-        public void Run()
-        {
-            if (this.f == null)
-                this.f = new FileSelector("name = *.jpg AND (size > 1000 OR atime < 2009-02-14-01:00:00)");
-
-            this.f.TraverseReparsePoints = _traverse;
-            this.f.Verbose = this._verbose;
-            Console.WriteLine();
-            Console.WriteLine(new String(':', 88));
-            Console.WriteLine("Selecting files:\n" + this.f.ToString());
-            var files = this.f.SelectFiles(this._directory, this._recurse);
-            if (files.Count == 0)
-            {
-                Console.WriteLine("no files.");
-            }
-            else
-            {
-                Console.WriteLine("files: {0}", files.Count);
-                foreach (string file in files)
-                {
-                    Console.WriteLine("  " + file);
-                }
-            }
-        }
-
-        public static void Usage()
-        {
-            Console.WriteLine("FileSelector: select files based on selection criteria.\n");
-            Console.WriteLine("Usage:\n  FileSelector <selectionCriteria>  [options]\n" +
-                              "\n" +
-                              "  -d <dir>   directory to select from (Default .)\n" +
-                              " -norecurse  don't recurse into subdirs\n" +
-                              " -j-         don't traverse junctions\n" +
-                              " -v          verbose output\n");
-        }
-    }
-
-#endif
-
-
-
-}
-
-
diff --git a/EPPlus/Packaging/DotNetZip/OffsetStream.cs b/EPPlus/Packaging/DotNetZip/OffsetStream.cs
deleted file mode 100644
index c1156d0..0000000
--- a/EPPlus/Packaging/DotNetZip/OffsetStream.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// OffsetStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c)  2009 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-August-27 12:50:35>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for handling reading of zip archives embedded 
-// into larger streams.  The initial position of the stream serves as
-// the base offset for all future Seek() operations.
-// 
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal class OffsetStream : System.IO.Stream, System.IDisposable
-    {
-        private Int64 _originalPosition;
-        private Stream _innerStream;
-
-        public OffsetStream(Stream s)
-            : base()
-        {
-            _originalPosition = s.Position;
-            _innerStream = s;
-        }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            return _innerStream.Read(buffer, offset, count);
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool CanRead
-        {
-            get { return _innerStream.CanRead; }
-        }
-
-        public override bool CanSeek
-        {
-            get { return _innerStream.CanSeek; }
-        }
-
-        public override bool CanWrite
-        {
-            get { return false; }
-        }
-
-        public override void Flush()
-        {
-            _innerStream.Flush();
-        }
-
-        public override long Length
-        {
-            get
-            {
-                return _innerStream.Length;
-            }
-        }
-
-        public override long Position
-        {
-            get { return _innerStream.Position - _originalPosition; }
-            set { _innerStream.Position = _originalPosition + value; }
-        }
-
-
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            return _innerStream.Seek(_originalPosition + offset, origin) - _originalPosition;
-        }
-
-
-        public override void SetLength(long value)
-        {
-            throw new NotImplementedException();
-        }
-
-        void IDisposable.Dispose()
-        {
-            Close();
-        }
-
-        public override void Close()
-        {
-            base.Close();
-        }
-
-    }
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Shared.cs b/EPPlus/Packaging/DotNetZip/Shared.cs
deleted file mode 100644
index ca8f18c..0000000
--- a/EPPlus/Packaging/DotNetZip/Shared.cs
+++ /dev/null
@@ -1,901 +0,0 @@
-// Shared.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// Last Saved: <2011-August-02 19:41:01>
-//
-// ------------------------------------------------------------------
-//
-// This module defines some shared utility classes and methods.
-//
-// Created: Tue, 27 Mar 2007  15:30
-//
-
-using System;
-using System.IO;
-using System.Security.Permissions;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// Collects general purpose utility methods.
-    /// </summary>
-    internal static class SharedUtilities
-    {
-        /// private null constructor
-        //private SharedUtilities() { }
-
-        // workitem 8423
-        public static Int64 GetFileLength(string fileName)
-        {
-            if (!File.Exists(fileName))
-                throw new System.IO.FileNotFoundException(fileName);
-
-            long fileLength = 0L;
-            FileShare fs = FileShare.ReadWrite;
-#if !NETCF
-            // FileShare.Delete is not defined for the Compact Framework
-            fs |= FileShare.Delete;
-#endif
-            using (var s = File.Open(fileName, FileMode.Open, FileAccess.Read, fs))
-            {
-                fileLength = s.Length;
-            }
-            return fileLength;
-        }
-
-
-        [System.Diagnostics.Conditional("NETCF")]
-        public static void Workaround_Ladybug318918(Stream s)
-        {
-            // This is a workaround for this issue:
-            // https://connect.microsoft.com/VisualStudio/feedback/details/318918
-            // It's required only on NETCF.
-            s.Flush();
-        }
-
-
-#if LEGACY
-        /// <summary>
-        /// Round the given DateTime value to an even second value.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// Round up in the case of an odd second value.  The rounding does not consider
-        /// fractional seconds.
-        /// </para>
-        /// <para>
-        /// This is useful because the Zip spec allows storage of time only to the nearest
-        /// even second.  So if you want to compare the time of an entry in the archive with
-        /// it's actual time in the filesystem, you need to round the actual filesystem
-        /// time, or use a 2-second threshold for the comparison.
-        /// </para>
-        /// <para>
-        /// This is most nautrally an extension method for the DateTime class but this
-        /// library is built for .NET 2.0, not for .NET 3.5; This means extension methods
-        /// are a no-no.
-        /// </para>
-        /// </remarks>
-        /// <param name="source">The DateTime value to round</param>
-        /// <returns>The ruonded DateTime value</returns>
-        public static DateTime RoundToEvenSecond(DateTime source)
-        {
-            // round to nearest second:
-            if ((source.Second % 2) == 1)
-                source += new TimeSpan(0, 0, 1);
-
-            DateTime dtRounded = new DateTime(source.Year, source.Month, source.Day, source.Hour, source.Minute, source.Second);
-            //if (source.Millisecond >= 500) dtRounded = dtRounded.AddSeconds(1);
-            return dtRounded;
-        }
-#endif
-
-#if YOU_LIKE_REDUNDANT_CODE
-        internal static string NormalizePath(string path)
-        {
-            // remove leading single dot slash
-            if (path.StartsWith(".\\")) path = path.Substring(2);
-
-            // remove intervening dot-slash
-            path = path.Replace("\\.\\", "\\");
-
-            // remove double dot when preceded by a directory name
-            var re = new System.Text.RegularExpressions.Regex(@"^(.*\\)?([^\\\.]+\\\.\.\\)(.+)$");
-            path = re.Replace(path, "$1$3");
-            return path;
-        }
-#endif
-
-        private static System.Text.RegularExpressions.Regex doubleDotRegex1 =
-            new System.Text.RegularExpressions.Regex(@"^(.*/)?([^/\\.]+/\\.\\./)(.+)$");
-
-        private static string SimplifyFwdSlashPath(string path)
-        {
-            if (path.StartsWith("./")) path = path.Substring(2);
-            path = path.Replace("/./", "/");
-
-            // Replace foo/anything/../bar with foo/bar
-            path = doubleDotRegex1.Replace(path, "$1$3");
-            return path;
-        }
-
-
-        /// <summary>
-        /// Utility routine for transforming path names from filesystem format (on Windows that means backslashes) to
-        /// a format suitable for use within zipfiles. This means trimming the volume letter and colon (if any) And
-        /// swapping backslashes for forward slashes.
-        /// </summary>
-        /// <param name="pathName">source path.</param>
-        /// <returns>transformed path</returns>
-        public static string NormalizePathForUseInZipFile(string pathName)
-        {
-            // boundary case
-            if (String.IsNullOrEmpty(pathName)) return pathName;
-
-            // trim volume if necessary
-            if ((pathName.Length >= 2)  && ((pathName[1] == ':') && (pathName[2] == '\\')))
-                pathName =  pathName.Substring(3);
-
-            // swap slashes
-            pathName = pathName.Replace('\\', '/');
-
-            // trim all leading slashes
-            while (pathName.StartsWith("/")) pathName = pathName.Substring(1);
-
-            return SimplifyFwdSlashPath(pathName);
-        }
-
-
-        static System.Text.Encoding ibm437 = System.Text.Encoding.ASCII;
-        static System.Text.Encoding utf8 = System.Text.Encoding.GetEncoding("UTF-8");
-
-        internal static byte[] StringToByteArray(string value, System.Text.Encoding encoding)
-        {
-            byte[] a = encoding.GetBytes(value);
-            return a;
-        }
-        internal static byte[] StringToByteArray(string value)
-        {
-            return StringToByteArray(value, ibm437);
-        }
-
-        //internal static byte[] Utf8StringToByteArray(string value)
-        //{
-        //    return StringToByteArray(value, utf8);
-        //}
-
-        //internal static string StringFromBuffer(byte[] buf, int maxlength)
-        //{
-        //    return StringFromBuffer(buf, maxlength, ibm437);
-        //}
-
-        internal static string Utf8StringFromBuffer(byte[] buf)
-        {
-            return StringFromBuffer(buf, utf8);
-        }
-
-        internal static string StringFromBuffer(byte[] buf, System.Text.Encoding encoding)
-        {
-            // this form of the GetString() method is required for .NET CF compatibility
-            string s = encoding.GetString(buf, 0, buf.Length);
-            return s;
-        }
-
-
-        internal static int ReadSignature(System.IO.Stream s)
-        {
-            int x = 0;
-            try { x = _ReadFourBytes(s, "n/a"); }
-            catch (BadReadException) { }
-            return x;
-        }
-
-
-        internal static int ReadEntrySignature(System.IO.Stream s)
-        {
-            // handle the case of ill-formatted zip archives - includes a data descriptor
-            // when none is expected.
-            int x = 0;
-            try
-            {
-                x = _ReadFourBytes(s, "n/a");
-                if (x == ZipConstants.ZipEntryDataDescriptorSignature)
-                {
-                    // advance past data descriptor - 12 bytes if not zip64
-                    s.Seek(12, SeekOrigin.Current);
-                    // workitem 10178
-                    Workaround_Ladybug318918(s);
-                    x = _ReadFourBytes(s, "n/a");
-                    if (x != ZipConstants.ZipEntrySignature)
-                    {
-                        // Maybe zip64 was in use for the prior entry.
-                        // Therefore, skip another 8 bytes.
-                        s.Seek(8, SeekOrigin.Current);
-                        // workitem 10178
-                        Workaround_Ladybug318918(s);
-                        x = _ReadFourBytes(s, "n/a");
-                        if (x != ZipConstants.ZipEntrySignature)
-                        {
-                            // seek back to the first spot
-                            s.Seek(-24, SeekOrigin.Current);
-                            // workitem 10178
-                            Workaround_Ladybug318918(s);
-                            x = _ReadFourBytes(s, "n/a");
-                        }
-                    }
-                }
-            }
-            catch (BadReadException) { }
-            return x;
-        }
-
-
-        internal static int ReadInt(System.IO.Stream s)
-        {
-            return _ReadFourBytes(s, "Could not read block - no data!  (position 0x{0:X8})");
-        }
-
-        private static int _ReadFourBytes(System.IO.Stream s, string message)
-        {
-            int n = 0;
-            byte[] block = new byte[4];
-#if NETCF
-            // workitem 9181
-            // Reading here in NETCF sometimes reads "backwards". Seems to happen for
-            // larger files.  Not sure why. Maybe an error in caching.  If the data is:
-            //
-            // 00100210: 9efa 0f00 7072 6f6a 6563 742e 6963 7750  ....project.icwP
-            // 00100220: 4b05 0600 0000 0006 0006 0091 0100 008e  K...............
-            // 00100230: 0010 0000 00                             .....
-            //
-            // ...and the stream Position is 10021F, then a Read of 4 bytes is returning
-            // 50776369, instead of 06054b50. This seems to happen the 2nd time Read()
-            // is called from that Position..
-            //
-            // submitted to connect.microsoft.com
-            // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=318918#tabs
-            //
-            for (int i = 0; i < block.Length; i++)
-            {
-                n+= s.Read(block, i, 1);
-            }
-#else
-            n = s.Read(block, 0, block.Length);
-#endif
-            if (n != block.Length) throw new BadReadException(String.Format(message, s.Position));
-            int data = unchecked((((block[3] * 256 + block[2]) * 256) + block[1]) * 256 + block[0]);
-            return data;
-        }
-
-
-
-        /// <summary>
-        ///   Finds a signature in the zip stream. This is useful for finding
-        ///   the end of a zip entry, for example, or the beginning of the next ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     Scans through 64k at a time.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     If the method fails to find the requested signature, the stream Position
-        ///     after completion of this method is unchanged. If the method succeeds in
-        ///     finding the requested signature, the stream position after completion is
-        ///     direct AFTER the signature found in the stream.
-        ///   </para>
-        /// </remarks>
-        ///
-        /// <param name="stream">The stream to search</param>
-        /// <param name="SignatureToFind">The 4-byte signature to find</param>
-        /// <returns>The number of bytes read</returns>
-        internal static long FindSignature(System.IO.Stream stream, int SignatureToFind)
-        {
-            long startingPosition = stream.Position;
-
-            int BATCH_SIZE = 65536; //  8192;
-            byte[] targetBytes = new byte[4];
-            targetBytes[0] = (byte)(SignatureToFind >> 24);
-            targetBytes[1] = (byte)((SignatureToFind & 0x00FF0000) >> 16);
-            targetBytes[2] = (byte)((SignatureToFind & 0x0000FF00) >> 8);
-            targetBytes[3] = (byte)(SignatureToFind & 0x000000FF);
-            byte[] batch = new byte[BATCH_SIZE];
-            int n = 0;
-            bool success = false;
-            do
-            {
-                n = stream.Read(batch, 0, batch.Length);
-                if (n != 0)
-                {
-                    for (int i = 0; i < n; i++)
-                    {
-                        if (batch[i] == targetBytes[3])
-                        {
-                            long curPosition = stream.Position;
-                            stream.Seek(i - n, System.IO.SeekOrigin.Current);
-                            // workitem 10178
-                            Workaround_Ladybug318918(stream);
-
-                            // workitem 7711
-                            int sig = ReadSignature(stream);
-
-                            success = (sig == SignatureToFind);
-                            if (!success)
-                            {
-                                stream.Seek(curPosition, System.IO.SeekOrigin.Begin);
-                                // workitem 10178
-                                Workaround_Ladybug318918(stream);
-                            }
-                            else
-                                break; // out of for loop
-                        }
-                    }
-                }
-                else break;
-                if (success) break;
-
-            } while (true);
-
-            if (!success)
-            {
-                stream.Seek(startingPosition, System.IO.SeekOrigin.Begin);
-                // workitem 10178
-                Workaround_Ladybug318918(stream);
-                return -1;  // or throw?
-            }
-
-            // subtract 4 for the signature.
-            long bytesRead = (stream.Position - startingPosition) - 4;
-
-            return bytesRead;
-        }
-
-
-        // If I have a time in the .NET environment, and I want to use it for
-        // SetWastWriteTime() etc, then I need to adjust it for Win32.
-        internal static DateTime AdjustTime_Reverse(DateTime time)
-        {
-            if (time.Kind == DateTimeKind.Utc) return time;
-            DateTime adjusted = time;
-            if (DateTime.Now.IsDaylightSavingTime() && !time.IsDaylightSavingTime())
-                adjusted = time - new System.TimeSpan(1, 0, 0);
-
-            else if (!DateTime.Now.IsDaylightSavingTime() && time.IsDaylightSavingTime())
-                adjusted = time + new System.TimeSpan(1, 0, 0);
-
-            return adjusted;
-        }
-
-#if NECESSARY
-        // If I read a time from a file with GetLastWriteTime() (etc), I need
-        // to adjust it for display in the .NET environment.
-        internal static DateTime AdjustTime_Forward(DateTime time)
-        {
-            if (time.Kind == DateTimeKind.Utc) return time;
-            DateTime adjusted = time;
-            if (DateTime.Now.IsDaylightSavingTime() && !time.IsDaylightSavingTime())
-                adjusted = time + new System.TimeSpan(1, 0, 0);
-
-            else if (!DateTime.Now.IsDaylightSavingTime() && time.IsDaylightSavingTime())
-                adjusted = time - new System.TimeSpan(1, 0, 0);
-
-            return adjusted;
-        }
-#endif
-
-
-        internal static DateTime PackedToDateTime(Int32 packedDateTime)
-        {
-            // workitem 7074 & workitem 7170
-            if (packedDateTime == 0xFFFF || packedDateTime == 0)
-                return new System.DateTime(1995, 1, 1, 0, 0, 0, 0);  // return a fixed date when none is supplied.
-
-            Int16 packedTime = unchecked((Int16)(packedDateTime & 0x0000ffff));
-            Int16 packedDate = unchecked((Int16)((packedDateTime & 0xffff0000) >> 16));
-
-            int year = 1980 + ((packedDate & 0xFE00) >> 9);
-            int month = (packedDate & 0x01E0) >> 5;
-            int day = packedDate & 0x001F;
-
-            int hour = (packedTime & 0xF800) >> 11;
-            int minute = (packedTime & 0x07E0) >> 5;
-            //int second = packedTime & 0x001F;
-            int second = (packedTime & 0x001F) * 2;
-
-            // validation and error checking.
-            // this is not foolproof but will catch most errors.
-            if (second >= 60) { minute++; second = 0; }
-            if (minute >= 60) { hour++; minute = 0; }
-            if (hour >= 24) { day++; hour = 0; }
-
-            DateTime d = System.DateTime.Now;
-            bool success= false;
-            try
-            {
-                d = new System.DateTime(year, month, day, hour, minute, second, 0);
-                success= true;
-            }
-            catch (System.ArgumentOutOfRangeException)
-            {
-                if (year == 1980 && (month == 0 || day == 0))
-                {
-                    try
-                    {
-                        d = new System.DateTime(1980, 1, 1, hour, minute, second, 0);
-                success= true;
-                    }
-                    catch (System.ArgumentOutOfRangeException)
-                    {
-                        try
-                        {
-                            d = new System.DateTime(1980, 1, 1, 0, 0, 0, 0);
-                success= true;
-                        }
-                        catch (System.ArgumentOutOfRangeException) { }
-
-                    }
-                }
-                // workitem 8814
-                // my god, I can't believe how many different ways applications
-                // can mess up a simple date format.
-                else
-                {
-                    try
-                    {
-                        while (year < 1980) year++;
-                        while (year > 2030) year--;
-                        while (month < 1) month++;
-                        while (month > 12) month--;
-                        while (day < 1) day++;
-                        while (day > 28) day--;
-                        while (minute < 0) minute++;
-                        while (minute > 59) minute--;
-                        while (second < 0) second++;
-                        while (second > 59) second--;
-                        d = new System.DateTime(year, month, day, hour, minute, second, 0);
-                        success= true;
-                    }
-                    catch (System.ArgumentOutOfRangeException) { }
-                }
-            }
-            if (!success)
-            {
-                string msg = String.Format("y({0}) m({1}) d({2}) h({3}) m({4}) s({5})", year, month, day, hour, minute, second);
-                throw new ZipException(String.Format("Bad date/time format in the zip file. ({0})", msg));
-
-            }
-            // workitem 6191
-            //d = AdjustTime_Reverse(d);
-            d = DateTime.SpecifyKind(d, DateTimeKind.Local);
-            return d;
-        }
-
-
-        internal
-         static Int32 DateTimeToPacked(DateTime time)
-        {
-            // The time is passed in here only for purposes of writing LastModified to the
-            // zip archive. It should always be LocalTime, but we convert anyway.  And,
-            // since the time is being written out, it needs to be adjusted.
-
-            time = time.ToLocalTime();
-            // workitem 7966
-            //time = AdjustTime_Forward(time);
-
-            // see http://www.vsft.com/hal/dostime.htm for the format
-            UInt16 packedDate = (UInt16)((time.Day & 0x0000001F) | ((time.Month << 5) & 0x000001E0) | (((time.Year - 1980) << 9) & 0x0000FE00));
-            UInt16 packedTime = (UInt16)((time.Second / 2 & 0x0000001F) | ((time.Minute << 5) & 0x000007E0) | ((time.Hour << 11) & 0x0000F800));
-
-            Int32 result = (Int32)(((UInt32)(packedDate << 16)) | packedTime);
-            return result;
-        }
-
-
-        /// <summary>
-        ///   Create a pseudo-random filename, suitable for use as a temporary
-        ///   file, and open it.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        ///   The System.IO.Path.GetRandomFileName() method is not available on
-        ///   the Compact Framework, so this library provides its own substitute
-        ///   on NETCF.
-        /// </para>
-        /// <para>
-        ///   This method produces a filename of the form
-        ///   DotNetZip-xxxxxxxx.tmp, where xxxxxxxx is replaced by randomly
-        ///   chosen characters, and creates that file.
-        /// </para>
-        /// </remarks>
-        public static void CreateAndOpenUniqueTempFile(string dir,
-                                                       out Stream fs,
-                                                       out string filename)
-        {
-            // workitem 9763
-            // http://dotnet.org.za/markn/archive/2006/04/15/51594.aspx
-            // try 3 times:
-            for (int i = 0; i < 3; i++)
-            {
-                try
-                {
-                    filename = Path.Combine(dir, InternalGetTempFileName());
-                    fs = new FileStream(filename, FileMode.CreateNew);
-                    return;
-                }
-                catch (IOException)
-                {
-                    if (i == 2) throw;
-                }
-            }
-            throw new IOException();
-        }
-
-#if NETCF || SILVERLIGHT
-        public static string InternalGetTempFileName()
-        {
-            return "DotNetZip-" + GenerateRandomStringImpl(8,0) + ".tmp";
-        }
-
-        internal static string GenerateRandomStringImpl(int length, int delta)
-        {
-            bool WantMixedCase = (delta == 0);
-            System.Random rnd = new System.Random();
-
-            string result = "";
-            char[] a = new char[length];
-
-            for (int i = 0; i < length; i++)
-            {
-               // delta == 65 means uppercase
-               // delta == 97 means lowercase
-                if (WantMixedCase)
-                    delta = (rnd.Next(2) == 0) ? 65 : 97;
-                a[i] = (char)(rnd.Next(26) + delta);
-            }
-
-            result = new System.String(a);
-            return result;
-        }
-#else
-        public static string InternalGetTempFileName()
-        {
-            return "DotNetZip-" + Path.GetRandomFileName().Substring(0, 8) + ".tmp";
-        }
-
-#endif
-
-
-        /// <summary>
-        /// Workitem 7889: handle ERROR_LOCK_VIOLATION during read
-        /// </summary>
-        /// <remarks>
-        /// This could be gracefully handled with an extension attribute, but
-        /// This assembly is built for .NET 2.0, so I cannot use them.
-        /// </remarks>
-        internal static int ReadWithRetry(System.IO.Stream s, byte[] buffer, int offset, int count, string FileName)
-        {
-            int n = 0;
-            bool done = false;
-#if !NETCF && !SILVERLIGHT
-            int retries = 0;
-#endif
-            do
-            {
-                try
-                {
-                    n = s.Read(buffer, offset, count);
-                    done = true;
-                }
-#if NETCF || SILVERLIGHT
-                catch (System.IO.IOException)
-                {
-                    throw;
-                }
-#else
-                catch (System.IO.IOException ioexc1)
-                {
-                    // Check if we can call GetHRForException,
-                    // which makes unmanaged code calls.
-                    var p = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
-                    if (p.IsUnrestricted())
-                    {
-                        uint hresult = _HRForException(ioexc1);
-                        if (hresult != 0x80070021)  // ERROR_LOCK_VIOLATION
-                            throw new System.IO.IOException(String.Format("Cannot read file {0}", FileName), ioexc1);
-                        retries++;
-                        if (retries > 10)
-                            throw new System.IO.IOException(String.Format("Cannot read file {0}, at offset 0x{1:X8} after 10 retries", FileName, offset), ioexc1);
-
-                        // max time waited on last retry = 250 + 10*550 = 5.75s
-                        // aggregate time waited after 10 retries: 250 + 55*550 = 30.5s
-                        System.Threading.Thread.Sleep(250 + retries * 550);
-                    }
-                    else
-                    {
-                        // The permission.Demand() failed. Therefore, we cannot call
-                        // GetHRForException, and cannot do the subtle handling of
-                        // ERROR_LOCK_VIOLATION.  Just bail.
-                        throw;
-                    }
-                }
-#endif
-            }
-            while (!done);
-
-            return n;
-        }
-
-
-#if !NETCF
-        // workitem 8009
-        //
-        // This method must remain separate.
-        //
-        // Marshal.GetHRForException() is needed to do special exception handling for
-        // the read.  But, that method requires UnmanagedCode permissions, and is marked
-        // with LinkDemand for UnmanagedCode.  In an ASP.NET medium trust environment,
-        // where UnmanagedCode is restricted, will generate a SecurityException at the
-        // time of JIT of the method that calls a method that is marked with LinkDemand
-        // for UnmanagedCode. The SecurityException, if it is restricted, will occur
-        // when this method is JITed.
-        //
-        // The Marshal.GetHRForException() is factored out of ReadWithRetry in order to
-        // avoid the SecurityException at JIT compile time. Because _HRForException is
-        // called only when the UnmanagedCode is allowed.  This means .NET never
-        // JIT-compiles this method when UnmanagedCode is disallowed, and thus never
-        // generates the JIT-compile time exception.
-        //
-#endif
-        private static uint _HRForException(System.Exception ex1)
-        {
-            return unchecked((uint)System.Runtime.InteropServices.Marshal.GetHRForException(ex1));
-        }
-
-    }
-
-
-
-    /// <summary>
-    ///   A decorator stream. It wraps another stream, and performs bookkeeping
-    ///   to keep track of the stream Position.
-    /// </summary>
-    /// <remarks>
-    ///   <para>
-    ///     In some cases, it is not possible to get the Position of a stream, let's
-    ///     say, on a write-only output stream like ASP.NET's
-    ///     <c>Response.OutputStream</c>, or on a different write-only stream
-    ///     provided as the destination for the zip by the application.  In this
-    ///     case, programmers can use this counting stream to count the bytes read
-    ///     or written.
-    ///   </para>
-    ///   <para>
-    ///     Consider the scenario of an application that saves a self-extracting
-    ///     archive (SFX), that uses a custom SFX stub.
-    ///   </para>
-    ///   <para>
-    ///     Saving to a filesystem file, the application would open the
-    ///     filesystem file (getting a <c>FileStream</c>), save the custom sfx stub
-    ///     into it, and then call <c>ZipFile.Save()</c>, specifying the same
-    ///     FileStream. <c>ZipFile.Save()</c> does the right thing for the zipentry
-    ///     offsets, by inquiring the Position of the <c>FileStream</c> before writing
-    ///     any data, and then adding that initial offset into any ZipEntry
-    ///     offsets in the zip directory. Everything works fine.
-    ///   </para>
-    ///   <para>
-    ///     Now suppose the application is an ASPNET application and it saves
-    ///     directly to <c>Response.OutputStream</c>. It's not possible for DotNetZip to
-    ///     inquire the <c>Position</c>, so the offsets for the SFX will be wrong.
-    ///   </para>
-    ///   <para>
-    ///     The workaround is for the application to use this class to wrap
-    ///     <c>HttpResponse.OutputStream</c>, then write the SFX stub and the ZipFile
-    ///     into that wrapper stream. Because <c>ZipFile.Save()</c> can inquire the
-    ///     <c>Position</c>, it will then do the right thing with the offsets.
-    ///   </para>
-    /// </remarks>
-    internal class CountingStream : System.IO.Stream
-    {
-        // workitem 12374: this class is now public
-        private System.IO.Stream _s;
-        private Int64 _bytesWritten;
-        private Int64 _bytesRead;
-        private Int64 _initialOffset;
-
-        /// <summary>
-        /// The constructor.
-        /// </summary>
-        /// <param name="stream">The underlying stream</param>
-        public CountingStream(System.IO.Stream stream)
-            : base()
-        {
-            _s = stream;
-            try
-            {
-                _initialOffset = _s.Position;
-            }
-            catch
-            {
-                _initialOffset = 0L;
-            }
-        }
-
-        /// <summary>
-        ///   Gets the wrapped stream.
-        /// </summary>
-        public Stream WrappedStream
-        {
-            get
-            {
-                return _s;
-            }
-        }
-
-        /// <summary>
-        ///   The count of bytes written out to the stream.
-        /// </summary>
-        public Int64 BytesWritten
-        {
-            get { return _bytesWritten; }
-        }
-
-        /// <summary>
-        ///   the count of bytes that have been read from the stream.
-        /// </summary>
-        public Int64 BytesRead
-        {
-            get { return _bytesRead; }
-        }
-
-        /// <summary>
-        ///    Adjust the byte count on the stream.
-        /// </summary>
-        ///
-        /// <param name='delta'>
-        ///   the number of bytes to subtract from the count.
-        /// </param>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     Subtract delta from the count of bytes written to the stream.
-        ///     This is necessary when seeking back, and writing additional data,
-        ///     as happens in some cases when saving Zip files.
-        ///   </para>
-        /// </remarks>
-        public void Adjust(Int64 delta)
-        {
-            _bytesWritten -= delta;
-            if (_bytesWritten < 0)
-                throw new InvalidOperationException();
-            if (_s as CountingStream != null)
-                ((CountingStream)_s).Adjust(delta);
-        }
-
-        /// <summary>
-        ///   The read method.
-        /// </summary>
-        /// <param name="buffer">The buffer to hold the data read from the stream.</param>
-        /// <param name="offset">the offset within the buffer to copy the first byte read.</param>
-        /// <param name="count">the number of bytes to read.</param>
-        /// <returns>the number of bytes read, after decryption and decompression.</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            int n = _s.Read(buffer, offset, count);
-            _bytesRead += n;
-            return n;
-        }
-
-        /// <summary>
-        ///   Write data into the stream.
-        /// </summary>
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (count == 0) return;
-            _s.Write(buffer, offset, count);
-            _bytesWritten += count;
-        }
-
-        /// <summary>
-        ///   Whether the stream can be read.
-        /// </summary>
-        public override bool CanRead
-        {
-            get { return _s.CanRead; }
-        }
-
-        /// <summary>
-        ///   Whether it is possible to call Seek() on the stream.
-        /// </summary>
-        public override bool CanSeek
-        {
-            get { return _s.CanSeek; }
-        }
-
-        /// <summary>
-        ///   Whether it is possible to call Write() on the stream.
-        /// </summary>
-        public override bool CanWrite
-        {
-            get { return _s.CanWrite; }
-        }
-
-        /// <summary>
-        ///   Flushes the underlying stream.
-        /// </summary>
-        public override void Flush()
-        {
-            _s.Flush();
-        }
-
-        /// <summary>
-        ///   The length of the underlying stream.
-        /// </summary>
-        public override long Length
-        {
-            get { return _s.Length; }   // bytesWritten??
-        }
-
-        /// <summary>
-        ///   Returns the sum of number of bytes written, plus the initial
-        ///   offset before writing.
-        /// </summary>
-        public long ComputedPosition
-        {
-            get { return _initialOffset + _bytesWritten; }
-        }
-
-
-        /// <summary>
-        ///   The Position of the stream.
-        /// </summary>
-        public override long Position
-        {
-            get { return _s.Position; }
-            set
-            {
-                _s.Seek(value, System.IO.SeekOrigin.Begin);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_s);
-            }
-        }
-
-        /// <summary>
-        ///   Seek in the stream.
-        /// </summary>
-        /// <param name="offset">the offset point to seek to</param>
-        /// <param name="origin">the reference point from which to seek</param>
-        /// <returns>The new position</returns>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            return _s.Seek(offset, origin);
-        }
-
-        /// <summary>
-        ///   Set the length of the underlying stream.  Be careful with this!
-        /// </summary>
-        ///
-        /// <param name='value'>the length to set on the underlying stream.</param>
-        public override void SetLength(long value)
-        {
-            _s.SetLength(value);
-        }
-    }
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/WinZipAes.cs b/EPPlus/Packaging/DotNetZip/WinZipAes.cs
deleted file mode 100644
index f45eea4..0000000
--- a/EPPlus/Packaging/DotNetZip/WinZipAes.cs
+++ /dev/null
@@ -1,941 +0,0 @@
-//#define Trace
-
-// WinZipAes.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-12 13:42:06>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the classes for dealing with WinZip's AES encryption,
-// according to the specifications for the format available on WinZip's website.
-//
-// Created: January 2009
-//
-// ------------------------------------------------------------------
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-using System.Security.Cryptography;
-
-#if AESCRYPTO
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   This is a helper class supporting WinZip AES encryption.
-    ///   This class is intended for use only by the DotNetZip library.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///   Most uses of the DotNetZip library will not involve direct calls into
-    ///   the WinZipAesCrypto class.  Instead, the WinZipAesCrypto class is
-    ///   instantiated and used by the ZipEntry() class when WinZip AES
-    ///   encryption or decryption on an entry is employed.
-    /// </remarks>
-    internal class WinZipAesCrypto
-    {
-        internal byte[] _Salt;
-        internal byte[] _providedPv;
-        internal byte[] _generatedPv;
-        internal int _KeyStrengthInBits;
-        private byte[] _MacInitializationVector;
-        private byte[] _StoredMac;
-        private byte[] _keyBytes;
-        private Int16 PasswordVerificationStored;
-        private Int16 PasswordVerificationGenerated;
-        private int Rfc2898KeygenIterations = 1000;
-        private string _Password;
-        private bool _cryptoGenerated ;
-
-        private WinZipAesCrypto(string password, int KeyStrengthInBits)
-        {
-            _Password = password;
-            _KeyStrengthInBits = KeyStrengthInBits;
-        }
-
-        public static WinZipAesCrypto Generate(string password, int KeyStrengthInBits)
-        {
-            WinZipAesCrypto c = new WinZipAesCrypto(password, KeyStrengthInBits);
-
-            int saltSizeInBytes = c._KeyStrengthInBytes / 2;
-            c._Salt = new byte[saltSizeInBytes];
-            Random rnd = new Random();
-            rnd.NextBytes(c._Salt);
-            return c;
-        }
-
-
-
-        public static WinZipAesCrypto ReadFromStream(string password, int KeyStrengthInBits, Stream s)
-        {
-            // from http://www.winzip.com/aes_info.htm
-            //
-            // Size(bytes)   Content
-            // -----------------------------------
-            // Variable      Salt value
-            // 2             Password verification value
-            // Variable      Encrypted file data
-            // 10            Authentication code
-            //
-            // ZipEntry.CompressedSize represents the size of all of those elements.
-
-            // salt size varies with key length:
-            //    128 bit key => 8 bytes salt
-            //    192 bits => 12 bytes salt
-            //    256 bits => 16 bytes salt
-
-            WinZipAesCrypto c = new WinZipAesCrypto(password, KeyStrengthInBits);
-
-            int saltSizeInBytes = c._KeyStrengthInBytes / 2;
-            c._Salt = new byte[saltSizeInBytes];
-            c._providedPv = new byte[2];
-
-            s.Read(c._Salt, 0, c._Salt.Length);
-            s.Read(c._providedPv, 0, c._providedPv.Length);
-
-            c.PasswordVerificationStored = (Int16)(c._providedPv[0] + c._providedPv[1] * 256);
-            if (password != null)
-            {
-                c.PasswordVerificationGenerated = (Int16)(c.GeneratedPV[0] + c.GeneratedPV[1] * 256);
-                if (c.PasswordVerificationGenerated != c.PasswordVerificationStored)
-                    throw new BadPasswordException("bad password");
-            }
-
-            return c;
-        }
-
-        public byte[] GeneratedPV
-        {
-            get
-            {
-                if (!_cryptoGenerated) _GenerateCryptoBytes();
-                return _generatedPv;
-            }
-        }
-
-
-        public byte[] Salt
-        {
-            get
-            {
-                return _Salt;
-            }
-        }
-
-
-        private int _KeyStrengthInBytes
-        {
-            get
-            {
-                return _KeyStrengthInBits / 8;
-
-            }
-        }
-
-        public int SizeOfEncryptionMetadata
-        {
-            get
-            {
-                // 10 bytes after, (n-10) before the compressed data
-                return _KeyStrengthInBytes / 2 + 10 + 2;
-            }
-        }
-
-        public string Password
-        {
-            set
-            {
-                _Password = value;
-                if (_Password != null)
-                {
-                    PasswordVerificationGenerated = (Int16)(GeneratedPV[0] + GeneratedPV[1] * 256);
-                    if (PasswordVerificationGenerated != PasswordVerificationStored)
-                        throw new Ionic.Zip.BadPasswordException();
-                }
-            }
-            private get
-            {
-                return _Password;
-            }
-        }
-
-
-        private void _GenerateCryptoBytes()
-        {
-            //Console.WriteLine(" provided password: '{0}'", _Password);
-
-            System.Security.Cryptography.Rfc2898DeriveBytes rfc2898 =
-                new System.Security.Cryptography.Rfc2898DeriveBytes(_Password, Salt, Rfc2898KeygenIterations);
-
-            _keyBytes = rfc2898.GetBytes(_KeyStrengthInBytes); // 16 or 24 or 32 ???
-            _MacInitializationVector = rfc2898.GetBytes(_KeyStrengthInBytes);
-            _generatedPv = rfc2898.GetBytes(2);
-
-            _cryptoGenerated = true;
-        }
-
-
-        public byte[] KeyBytes
-        {
-            get
-            {
-                if (!_cryptoGenerated) _GenerateCryptoBytes();
-                return _keyBytes;
-            }
-        }
-
-
-        public byte[] MacIv
-        {
-            get
-            {
-                if (!_cryptoGenerated) _GenerateCryptoBytes();
-                return _MacInitializationVector;
-            }
-        }
-
-        public byte[] CalculatedMac;
-
-
-        public void ReadAndVerifyMac(System.IO.Stream s)
-        {
-            bool invalid = false;
-
-            // read integrityCheckVector.
-            // caller must ensure that the file pointer is in the right spot!
-            _StoredMac = new byte[10];  // aka "authentication code"
-            s.Read(_StoredMac, 0, _StoredMac.Length);
-
-            if (_StoredMac.Length != CalculatedMac.Length)
-                invalid = true;
-
-            if (!invalid)
-            {
-                for (int i = 0; i < _StoredMac.Length; i++)
-                {
-                    if (_StoredMac[i] != CalculatedMac[i])
-                        invalid = true;
-                }
-            }
-
-            if (invalid)
-                throw new Ionic.Zip.BadStateException("The MAC does not match.");
-        }
-
-    }
-
-
-    #region DONT_COMPILE_BUT_KEEP_FOR_POTENTIAL_FUTURE_USE
-#if NO
-    internal class Util
-    {
-        private static void _Format(System.Text.StringBuilder sb1,
-                                    byte[] b,
-                                    int offset,
-                                    int length)
-        {
-
-            System.Text.StringBuilder sb2 = new System.Text.StringBuilder();
-            sb1.Append("0000    ");
-            int i;
-            for (i = 0; i < length; i++)
-            {
-                int x = offset+i;
-                if (i != 0 && i % 16 == 0)
-                {
-                    sb1.Append("    ")
-                        .Append(sb2)
-                        .Append("\n")
-                        .Append(String.Format("{0:X4}    ", i));
-                    sb2.Remove(0,sb2.Length);
-                }
-                sb1.Append(System.String.Format("{0:X2} ", b[x]));
-                if (b[x] >=32 && b[x] <= 126)
-                    sb2.Append((char)b[x]);
-                else
-                    sb2.Append(".");
-            }
-            if (sb2.Length > 0)
-            {
-                sb1.Append(new String(' ', ((16 - i%16) * 3) + 4))
-                    .Append(sb2);
-            }
-        }
-
-
-
-        internal static string FormatByteArray(byte[] b, int limit)
-        {
-            System.Text.StringBuilder sb1 = new System.Text.StringBuilder();
-
-            if ((limit * 2 > b.Length) || limit == 0)
-            {
-                _Format(sb1, b, 0, b.Length);
-            }
-            else
-            {
-                // first N bytes of the buffer
-                _Format(sb1, b, 0, limit);
-
-                if (b.Length > limit * 2)
-                    sb1.Append(String.Format("\n   ...({0} other bytes here)....\n", b.Length - limit * 2));
-
-                // last N bytes of the buffer
-                _Format(sb1, b, b.Length - limit, limit);
-            }
-
-            return sb1.ToString();
-        }
-
-
-        internal static string FormatByteArray(byte[] b)
-        {
-            return FormatByteArray(b, 0);
-        }
-    }
-
-#endif
-    #endregion
-
-
-
-
-    /// <summary>
-    ///   A stream that encrypts as it writes, or decrypts as it reads.  The
-    ///   Crypto is AES in CTR (counter) mode, which is compatible with the AES
-    ///   encryption employed by WinZip 12.0.
-    /// </summary>
-    /// <remarks>
-    ///   <para>
-    ///     The AES/CTR encryption protocol used by WinZip works like this:
-    ///
-    ///       - start with a counter, initialized to zero.
-    ///
-    ///       - to encrypt, take the data by 16-byte blocks. For each block:
-    ///         - apply the transform to the counter
-    ///         - increement the counter
-    ///         - XOR the result of the transform with the plaintext to
-    ///           get the ciphertext.
-    ///         - compute the mac on the encrypted bytes
-    ///       - when finished with all blocks, store the computed MAC.
-    ///
-    ///       - to decrypt, take the data by 16-byte blocks. For each block:
-    ///         - compute the mac on the encrypted bytes,
-    ///         - apply the transform to the counter
-    ///         - increement the counter
-    ///         - XOR the result of the transform with the ciphertext to
-    ///           get the plaintext.
-    ///       - when finished with all blocks, compare the computed MAC against
-    ///         the stored MAC
-    ///
-    ///   </para>
-    /// </remarks>
-    //
-    internal class WinZipAesCipherStream : Stream
-    {
-        private WinZipAesCrypto _params;
-        private System.IO.Stream _s;
-        private CryptoMode _mode;
-        private int _nonce;
-        private bool _finalBlock;
-
-        internal HMACSHA1 _mac;
-
-        // Use RijndaelManaged from .NET 2.0.
-        // AesManaged came in .NET 3.5, but we want to limit
-        // dependency to .NET 2.0.  AES is just a restricted form
-        // of Rijndael (fixed block size of 128, some crypto modes not supported).
-
-        internal RijndaelManaged _aesCipher;
-        internal ICryptoTransform _xform;
-
-        private const int BLOCK_SIZE_IN_BYTES = 16;
-
-        private byte[] counter = new byte[BLOCK_SIZE_IN_BYTES];
-        private byte[] counterOut = new byte[BLOCK_SIZE_IN_BYTES];
-
-        // I've had a problem when wrapping a WinZipAesCipherStream inside
-        // a DeflateStream. Calling Read() on the DeflateStream results in
-        // a Read() on the WinZipAesCipherStream, but the buffer is larger
-        // than the total size of the encrypted data, and larger than the
-        // initial Read() on the DeflateStream!  When the encrypted
-        // bytestream is embedded within a larger stream (As in a zip
-        // archive), the Read() doesn't fail with EOF.  This causes bad
-        // data to be returned, and it messes up the MAC.
-
-        // This field is used to provide a hard-stop to the size of
-        // data that can be read from the stream.  In Read(), if the buffer or
-        // read request goes beyond the stop, we truncate it.
-
-        private long _length;
-        private long _totalBytesXferred;
-        private byte[] _PendingWriteBlock;
-        private int _pendingCount;
-        private byte[] _iobuf;
-
-        /// <summary>
-        /// The constructor.
-        /// </summary>
-        /// <param name="s">The underlying stream</param>
-        /// <param name="mode">To either encrypt or decrypt.</param>
-        /// <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>
-        /// <param name="length">The maximum number of bytes to read from the stream.</param>
-        internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, long length, CryptoMode mode)
-            : this(s, cryptoParams, mode)
-        {
-            // don't read beyond this limit!
-            _length = length;
-            //Console.WriteLine("max length of AES stream: {0}", _length);
-        }
-
-
-#if WANT_TRACE
-            Stream untransformed;
-        String traceFileUntransformed;
-        Stream transformed;
-        String traceFileTransformed;
-#endif
-
-
-        internal WinZipAesCipherStream(System.IO.Stream s, WinZipAesCrypto cryptoParams, CryptoMode mode)
-            : base()
-        {
-            TraceOutput("-------------------------------------------------------");
-            TraceOutput("Create {0:X8}", this.GetHashCode());
-
-            _params = cryptoParams;
-            _s = s;
-            _mode = mode;
-            _nonce = 1;
-
-            if (_params == null)
-                throw new BadPasswordException("Supply a password to use AES encryption.");
-
-            int keySizeInBits = _params.KeyBytes.Length * 8;
-            if (keySizeInBits != 256 && keySizeInBits != 128 && keySizeInBits != 192)
-                throw new ArgumentOutOfRangeException("keysize",
-                                                      "size of key must be 128, 192, or 256");
-
-            _mac = new HMACSHA1(_params.MacIv);
-
-            _aesCipher = new System.Security.Cryptography.RijndaelManaged();
-            _aesCipher.BlockSize = 128;
-            _aesCipher.KeySize = keySizeInBits;  // 128, 192, 256
-            _aesCipher.Mode = CipherMode.ECB;
-            _aesCipher.Padding = PaddingMode.None;
-
-            byte[] iv = new byte[BLOCK_SIZE_IN_BYTES]; // all zeroes
-
-            // Create an ENCRYPTOR, regardless whether doing decryption or encryption.
-            // It is reflexive.
-            _xform = _aesCipher.CreateEncryptor(_params.KeyBytes, iv);
-
-            if (_mode == CryptoMode.Encrypt)
-            {
-                _iobuf = new byte[2048];
-                _PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES];
-            }
-
-
-#if WANT_TRACE
-                traceFileUntransformed = "unpack\\WinZipAesCipherStream.trace.untransformed.out";
-            traceFileTransformed = "unpack\\WinZipAesCipherStream.trace.transformed.out";
-
-            untransformed = System.IO.File.Create(traceFileUntransformed);
-            transformed = System.IO.File.Create(traceFileTransformed);
-#endif
-        }
-
-        private void XorInPlace(byte[] buffer, int offset, int count)
-        {
-            for (int i = 0; i < count; i++)
-            {
-                buffer[offset + i] = (byte)(counterOut[i] ^ buffer[offset + i]);
-            }
-        }
-
-        private void WriteTransformOneBlock(byte[] buffer, int offset)
-        {
-            System.Array.Copy(BitConverter.GetBytes(_nonce++), 0, counter, 0, 4);
-            _xform.TransformBlock(counter,
-                                  0,
-                                  BLOCK_SIZE_IN_BYTES,
-                                  counterOut,
-                                  0);
-            XorInPlace(buffer, offset, BLOCK_SIZE_IN_BYTES);
-            _mac.TransformBlock(buffer, offset, BLOCK_SIZE_IN_BYTES, null, 0);
-        }
-
-
-        private void WriteTransformBlocks(byte[] buffer, int offset, int count)
-        {
-            int posn = offset;
-            int last = count + offset;
-
-            while (posn < buffer.Length && posn < last)
-            {
-                WriteTransformOneBlock (buffer, posn);
-                posn += BLOCK_SIZE_IN_BYTES;
-            }
-        }
-
-
-        private void WriteTransformFinalBlock()
-        {
-            if (_pendingCount == 0)
-                throw new InvalidOperationException("No bytes available.");
-
-            if (_finalBlock)
-                throw new InvalidOperationException("The final block has already been transformed.");
-
-            System.Array.Copy(BitConverter.GetBytes(_nonce++), 0, counter, 0, 4);
-            counterOut = _xform.TransformFinalBlock(counter,
-                                                    0,
-                                                    BLOCK_SIZE_IN_BYTES);
-            XorInPlace(_PendingWriteBlock, 0, _pendingCount);
-            _mac.TransformFinalBlock(_PendingWriteBlock, 0, _pendingCount);
-            _finalBlock = true;
-        }
-
-
-
-
-
-        private int ReadTransformOneBlock(byte[] buffer, int offset, int last)
-        {
-            if (_finalBlock)
-                throw new NotSupportedException();
-
-            int bytesRemaining = last - offset;
-            int bytesToRead = (bytesRemaining > BLOCK_SIZE_IN_BYTES)
-                ? BLOCK_SIZE_IN_BYTES
-                : bytesRemaining;
-
-            // update the counter
-            System.Array.Copy(BitConverter.GetBytes(_nonce++), 0, counter, 0, 4);
-
-            // Determine if this is the final block
-            if ((bytesToRead == bytesRemaining) &&
-                (_length > 0) &&
-                (_totalBytesXferred + last == _length))
-            {
-                _mac.TransformFinalBlock(buffer, offset, bytesToRead);
-                counterOut = _xform.TransformFinalBlock(counter,
-                                                        0,
-                                                        BLOCK_SIZE_IN_BYTES);
-                _finalBlock = true;
-            }
-            else
-            {
-                _mac.TransformBlock(buffer, offset, bytesToRead, null, 0);
-                _xform.TransformBlock(counter,
-                                      0, // offset
-                                      BLOCK_SIZE_IN_BYTES,
-                                      counterOut,
-                                      0);  // offset
-            }
-
-            XorInPlace(buffer, offset, bytesToRead);
-            return bytesToRead;
-        }
-
-
-
-        private void ReadTransformBlocks(byte[] buffer, int offset, int count)
-        {
-            int posn = offset;
-            int last = count + offset;
-
-            while (posn < buffer.Length && posn < last )
-            {
-                int n = ReadTransformOneBlock (buffer, posn, last);
-                posn += n;
-            }
-        }
-
-
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_mode == CryptoMode.Encrypt)
-                throw new NotSupportedException();
-
-            if (buffer == null)
-                throw new ArgumentNullException("buffer");
-
-            if (offset < 0)
-                throw new ArgumentOutOfRangeException("offset",
-                                                      "Must not be less than zero.");
-            if (count < 0)
-                throw new ArgumentOutOfRangeException("count",
-                                                      "Must not be less than zero.");
-
-            if (buffer.Length < offset + count)
-                throw new ArgumentException("The buffer is too small");
-
-            // When I wrap a WinZipAesStream in a DeflateStream, the
-            // DeflateStream asks its captive to read 4k blocks, even if the
-            // encrypted bytestream is smaller than that.  This is a way to
-            // limit the number of bytes read.
-
-            int bytesToRead = count;
-
-            if (_totalBytesXferred >= _length)
-            {
-                return 0; // EOF
-            }
-
-            long bytesRemaining = _length - _totalBytesXferred;
-            if (bytesRemaining < count) bytesToRead = (int)bytesRemaining;
-
-            int n = _s.Read(buffer, offset, bytesToRead);
-
-
-#if WANT_TRACE
-                untransformed.Write(buffer, offset, bytesToRead);
-#endif
-
-            ReadTransformBlocks(buffer, offset, bytesToRead);
-
-#if WANT_TRACE
-                transformed.Write(buffer, offset, bytesToRead);
-#endif
-            _totalBytesXferred += n;
-            return n;
-        }
-
-
-
-        /// <summary>
-        /// Returns the final HMAC-SHA1-80 for the data that was encrypted.
-        /// </summary>
-        public byte[] FinalAuthentication
-        {
-            get
-            {
-                if (!_finalBlock)
-                {
-                    // special-case zero-byte files
-                    if ( _totalBytesXferred != 0)
-                        throw new BadStateException("The final hash has not been computed.");
-
-                    // Must call ComputeHash on an empty byte array when no data
-                    // has run through the MAC.
-
-                    byte[] b = {  };
-                    _mac.ComputeHash(b);
-                    // fall through
-                }
-                byte[] macBytes10 = new byte[10];
-                System.Array.Copy(_mac.Hash, 0, macBytes10, 0, 10);
-                return macBytes10;
-            }
-        }
-
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (_finalBlock)
-                throw new InvalidOperationException("The final block has already been transformed.");
-
-            if (_mode == CryptoMode.Decrypt)
-                throw new NotSupportedException();
-
-            if (buffer == null)
-                throw new ArgumentNullException("buffer");
-
-            if (offset < 0)
-                throw new ArgumentOutOfRangeException("offset",
-                                                      "Must not be less than zero.");
-            if (count < 0)
-                throw new ArgumentOutOfRangeException("count",
-                                                      "Must not be less than zero.");
-            if (buffer.Length < offset + count)
-                throw new ArgumentException("The offset and count are too large");
-
-            if (count == 0)
-                return;
-
-            TraceOutput("Write off({0}) count({1})", offset, count);
-
-#if WANT_TRACE
-            untransformed.Write(buffer, offset, count);
-#endif
-
-            // For proper AES encryption, an AES encryptor application calls
-            // TransformBlock repeatedly for all 16-byte blocks except the
-            // last. For the last block, it then calls TransformFinalBlock().
-            //
-            // This class is a stream that encrypts via Write().  But, it's not
-            // possible to recognize which are the "last" bytes from within the call
-            // to Write(). The caller can call Write() several times in succession,
-            // with varying buffers. This class only "knows" that the last bytes
-            // have been written when the app calls Close().
-            //
-            // Therefore, this class buffers writes: After completion every Write(),
-            // a 16-byte "pending" block (_PendingWriteBlock) must hold between 1
-            // and 16 bytes, which will be used in TransformFinalBlock if the app
-            // calls Close() immediately thereafter. Also, every write must
-            // transform any pending bytes, before transforming the data passed in
-            // to the current call.
-            //
-            // In operation, after the first call to Write() and before the call to
-            // Close(), one full or partial block of bytes is always available,
-            // pending.  At time of Close(), this class calls
-            // WriteTransformFinalBlock() to flush the pending bytes.
-            //
-            // This approach works whether the caller writes in odd-sized batches,
-            // for example 5000 bytes, or in batches that are neat multiples of the
-            // blocksize (16).
-            //
-            // Logicaly, what we do is this:
-            //
-            //  1. if there are fewer than 16 bytes (pending + current), then
-            //     just copy them into th pending buffer and return.
-            //
-            //  2. there are more than 16 bytes to write. So, take the leading slice
-            //     of bytes from the current buffer, enough to fill the pending
-            //     buffer. Transform the pending block, and write it out.
-            //
-            //  3. Take the trailing slice of bytes (a full block or a partial block),
-            //     and copy it to the pending block for next time.
-            //
-            //  4. transform and write all the other blocks, the middle slice.
-            //
-
-            // There are 16 or fewer bytes, so just buffer the bytes.
-            if (count + _pendingCount <= BLOCK_SIZE_IN_BYTES)
-            {
-                Buffer.BlockCopy(buffer,
-                                 offset,
-                                 _PendingWriteBlock,
-                                 _pendingCount,
-                                 count);
-                _pendingCount += count;
-
-                // At this point, _PendingWriteBlock contains up to
-                // BLOCK_SIZE_IN_BYTES bytes, and _pendingCount ranges from 0 to
-                // BLOCK_SIZE_IN_BYTES. We don't want to xform+write them yet,
-                // because this may have been the last block.  The last block gets
-                // written at Close().
-                return;
-            }
-
-            // We know there are at least 17 bytes, counting those in the current
-            // buffer, along with the (possibly empty) pending block.
-
-            int bytesRemaining = count;
-            int curOffset = offset;
-
-            // workitem 12815
-            //
-            // xform chunkwise ... Cannot transform in place using the original
-            // buffer because that is user-maintained.
-
-            if (_pendingCount != 0)
-            {
-                // We have more than one block of data to write, therefore it is safe
-                // to xform+write.
-                int fillCount = BLOCK_SIZE_IN_BYTES - _pendingCount;
-
-                // fillCount is possibly zero here. That happens when the pending
-                // buffer held 16 bytes (one complete block) before this call to
-                // Write.
-                if (fillCount > 0)
-                {
-                    Buffer.BlockCopy(buffer,
-                                     offset,
-                                     _PendingWriteBlock,
-                                     _pendingCount,
-                                     fillCount);
-
-                    // adjust counts:
-                    bytesRemaining -= fillCount;
-                    curOffset += fillCount;
-                }
-
-                // xform and write:
-                WriteTransformOneBlock(_PendingWriteBlock, 0);
-                _s.Write(_PendingWriteBlock, 0, BLOCK_SIZE_IN_BYTES);
-                _totalBytesXferred += BLOCK_SIZE_IN_BYTES;
-                _pendingCount = 0;
-            }
-
-            // At this point _PendingWriteBlock is empty, and bytesRemaining is
-            // always greater than 0.
-
-            // Now, xform N blocks, where N = floor((bytesRemaining-1)/16).  If
-            // writing 32 bytes, then xform 1 block, and stage the remaining 16.  If
-            // writing 10037 bytes, xform 627 blocks of 16 bytes, then stage the
-            // remaining 5 bytes.
-
-            int blocksToXform = (bytesRemaining-1)/BLOCK_SIZE_IN_BYTES;
-            _pendingCount = bytesRemaining - (blocksToXform * BLOCK_SIZE_IN_BYTES);
-
-            // _pendingCount is ALWAYS between 1 and 16.
-            // Put the last _pendingCount bytes into the pending block.
-            Buffer.BlockCopy(buffer,
-                             curOffset + bytesRemaining - _pendingCount,
-                             _PendingWriteBlock,
-                             0,
-                             _pendingCount);
-            bytesRemaining -= _pendingCount;
-            _totalBytesXferred += bytesRemaining; // will be true after the loop
-
-            // now, transform all the full blocks preceding that.
-            // bytesRemaining is always a multiple of 16 .
-            if (blocksToXform > 0)
-            {
-                do
-                {
-                    int c = _iobuf.Length;
-                    if (c > bytesRemaining) c = bytesRemaining;
-                    Buffer.BlockCopy(buffer,
-                                     curOffset,
-                                     _iobuf,
-                                     0,
-                                     c);
-
-                    WriteTransformBlocks(_iobuf, 0, c);
-                    _s.Write(_iobuf, 0, c);
-                    bytesRemaining -= c;
-                    curOffset += c;
-                } while(bytesRemaining > 0);
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Close the stream.
-        /// </summary>
-        public override void Close()
-        {
-            TraceOutput("Close {0:X8}", this.GetHashCode());
-
-            // In the degenerate case, no bytes have been written to the
-            // stream at all.  Need to check here, and NOT emit the
-            // final block if Write has not been called.
-            if (_pendingCount > 0)
-            {
-                WriteTransformFinalBlock();
-                _s.Write(_PendingWriteBlock, 0, _pendingCount);
-                _totalBytesXferred += _pendingCount;
-                _pendingCount = 0;
-            }
-            _s.Close();
-
-#if WANT_TRACE
-            untransformed.Close();
-            transformed.Close();
-            Console.WriteLine("\nuntransformed bytestream is in  {0}", traceFileUntransformed);
-            Console.WriteLine("\ntransformed bytestream is in  {0}", traceFileTransformed);
-#endif
-            TraceOutput("-------------------------------------------------------");
-        }
-
-
-        /// <summary>
-        /// Returns true if the stream can be read.
-        /// </summary>
-        public override bool CanRead
-        {
-            get
-            {
-                if (_mode != CryptoMode.Decrypt) return false;
-                return true;
-            }
-        }
-
-
-        /// <summary>
-        /// Always returns false.
-        /// </summary>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-        /// <summary>
-        /// Returns true if the CryptoMode is Encrypt.
-        /// </summary>
-        public override bool CanWrite
-        {
-            get { return (_mode == CryptoMode.Encrypt); }
-        }
-
-        /// <summary>
-        /// Flush the content in the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            _s.Flush();
-        }
-
-        /// <summary>
-        /// Getting this property throws a NotImplementedException.
-        /// </summary>
-        public override long Length
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        /// Getting or Setting this property throws a NotImplementedException.
-        /// </summary>
-        public override long Position
-        {
-            get { throw new NotImplementedException(); }
-            set { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        /// This method throws a NotImplementedException.
-        /// </summary>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        /// This method throws a NotImplementedException.
-        /// </summary>
-        public override void SetLength(long value)
-        {
-            throw new NotImplementedException();
-        }
-
-
-
-        [System.Diagnostics.ConditionalAttribute("Trace")]
-        private void TraceOutput(string format, params object[] varParams)
-        {
-            lock(_outputLock)
-            {
-                int tid = System.Threading.Thread.CurrentThread.GetHashCode();
-                Console.ForegroundColor = (ConsoleColor) (tid % 8 + 8);
-                Console.Write("{0:000} WZACS ", tid);
-                Console.WriteLine(format, varParams);
-                Console.ResetColor();
-            }
-        }
-
-        private object _outputLock = new Object();
-    }
-}
-#endif
diff --git a/EPPlus/Packaging/DotNetZip/ZipConstants.cs b/EPPlus/Packaging/DotNetZip/ZipConstants.cs
deleted file mode 100644
index 5852a29..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipConstants.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// ZipConstants.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006, 2007, 2008, 2009 Dino Chiesa and Microsoft Corporation.  
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-August-27 23:22:32>
-//
-// ------------------------------------------------------------------
-//
-// This module defines a few constants that are used in the project. 
-//
-// ------------------------------------------------------------------
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-  static class ZipConstants
-  {      
-    public const UInt32 PackedToRemovableMedia = 0x30304b50;
-    public const UInt32 Zip64EndOfCentralDirectoryRecordSignature = 0x06064b50;
-    public const UInt32 Zip64EndOfCentralDirectoryLocatorSignature = 0x07064b50;
-    public const UInt32 EndOfCentralDirectorySignature = 0x06054b50;
-    public const int ZipEntrySignature                 = 0x04034b50;
-    public const int ZipEntryDataDescriptorSignature   = 0x08074b50;
-    public const int SplitArchiveSignature             = 0x08074b50;
-    public const int ZipDirEntrySignature              = 0x02014b50;
-
-      
-    // These are dictated by the Zip Spec.See APPNOTE.txt
-    public const int AesKeySize = 192;  // 128, 192, 256
-    public const int AesBlockSize = 128;  // ???
-
-    public const UInt16 AesAlgId128 = 0x660E; 
-    public const UInt16 AesAlgId192 = 0x660F; 
-    public const UInt16 AesAlgId256 = 0x6610; 
-
-  }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipCrypto.cs b/EPPlus/Packaging/DotNetZip/ZipCrypto.cs
deleted file mode 100644
index 6e7f625..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipCrypto.cs
+++ /dev/null
@@ -1,455 +0,0 @@
-// ZipCrypto.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2008, 2009, 2011 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-28 06:30:59>
-//
-// ------------------------------------------------------------------
-//
-// This module provides the implementation for "traditional" Zip encryption.
-//
-// Created Tue Apr 15 17:39:56 2008
-//
-// ------------------------------------------------------------------
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   This class implements the "traditional" or "classic" PKZip encryption,
-    ///   which today is considered to be weak. On the other hand it is
-    ///   ubiquitous. This class is intended for use only by the DotNetZip
-    ///   library.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///   Most uses of the DotNetZip library will not involve direct calls into
-    ///   the ZipCrypto class.  Instead, the ZipCrypto class is instantiated and
-    ///   used by the ZipEntry() class when encryption or decryption on an entry
-    ///   is employed.  If for some reason you really wanted to use a weak
-    ///   encryption algorithm in some other application, you might use this
-    ///   library.  But you would be much better off using one of the built-in
-    ///   strong encryption libraries in the .NET Framework, like the AES
-    ///   algorithm or SHA.
-    /// </remarks>
-    internal class ZipCrypto
-    {
-        /// <summary>
-        ///   The default constructor for ZipCrypto.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This class is intended for internal use by the library only. It's
-        ///   probably not useful to you. Seriously.  Stop reading this
-        ///   documentation.  It's a waste of your time.  Go do something else.
-        ///   Check the football scores. Go get an ice cream with a friend.
-        ///   Seriously.
-        /// </remarks>
-        ///
-        private ZipCrypto() { }
-
-        public static ZipCrypto ForWrite(string password)
-        {
-            ZipCrypto z = new ZipCrypto();
-            if (password == null)
-                throw new BadPasswordException("This entry requires a password.");
-            z.InitCipher(password);
-            return z;
-        }
-
-
-        public static ZipCrypto ForRead(string password, ZipEntry e)
-        {
-            System.IO.Stream s = e._archiveStream;
-            e._WeakEncryptionHeader = new byte[12];
-            byte[] eh = e._WeakEncryptionHeader;
-            ZipCrypto z = new ZipCrypto();
-
-            if (password == null)
-                throw new BadPasswordException("This entry requires a password.");
-
-            z.InitCipher(password);
-
-            ZipEntry.ReadWeakEncryptionHeader(s, eh);
-
-            // Decrypt the header.  This has a side effect of "further initializing the
-            // encryption keys" in the traditional zip encryption.
-            byte[] DecryptedHeader = z.DecryptMessage(eh, eh.Length);
-
-            // CRC check
-            // According to the pkzip spec, the final byte in the decrypted header
-            // is the highest-order byte in the CRC. We check it here.
-            if (DecryptedHeader[11] != (byte)((e._Crc32 >> 24) & 0xff))
-            {
-                // In the case that bit 3 of the general purpose bit flag is set to
-                // indicate the presence of an 'Extended File Header' or a 'data
-                // descriptor' (signature 0x08074b50), the last byte of the decrypted
-                // header is sometimes compared with the high-order byte of the
-                // lastmodified time, rather than the high-order byte of the CRC, to
-                // verify the password.
-                //
-                // This is not documented in the PKWare Appnote.txt.  It was
-                // discovered this by analysis of the Crypt.c source file in the
-                // InfoZip library http://www.info-zip.org/pub/infozip/
-                //
-                // The reason for this is that the CRC for a file cannot be known
-                // until the entire contents of the file have been streamed. This
-                // means a tool would have to read the file content TWICE in its
-                // entirety in order to perform PKZIP encryption - once to compute
-                // the CRC, and again to actually encrypt.
-                //
-                // This is so important for performance that using the timeblob as
-                // the verification should be the standard practice for DotNetZip
-                // when using PKZIP encryption. This implies that bit 3 must be
-                // set. The downside is that some tools still cannot cope with ZIP
-                // files that use bit 3.  Therefore, DotNetZip DOES NOT force bit 3
-                // when PKZIP encryption is in use, and instead, reads the stream
-                // twice.
-                //
-
-                if ((e._BitField & 0x0008) != 0x0008)
-                {
-                    throw new BadPasswordException("The password did not match.");
-                }
-                else if (DecryptedHeader[11] != (byte)((e._TimeBlob >> 8) & 0xff))
-                {
-                    throw new BadPasswordException("The password did not match.");
-                }
-
-                // We have a good password.
-            }
-            else
-            {
-                // A-OK
-            }
-            return z;
-        }
-
-
-
-
-        /// <summary>
-        /// From AppNote.txt:
-        /// unsigned char decrypt_byte()
-        ///     local unsigned short temp
-        ///     temp :=- Key(2) | 2
-        ///     decrypt_byte := (temp * (temp ^ 1)) bitshift-right 8
-        /// end decrypt_byte
-        /// </summary>
-        private byte MagicByte
-        {
-            get
-            {
-                UInt16 t = (UInt16)((UInt16)(_Keys[2] & 0xFFFF) | 2);
-                return (byte)((t * (t ^ 1)) >> 8);
-            }
-        }
-
-        // Decrypting:
-        // From AppNote.txt:
-        // loop for i from 0 to 11
-        //     C := buffer(i) ^ decrypt_byte()
-        //     update_keys(C)
-        //     buffer(i) := C
-        // end loop
-
-
-        /// <summary>
-        ///   Call this method on a cipher text to render the plaintext. You must
-        ///   first initialize the cipher with a call to InitCipher.
-        /// </summary>
-        ///
-        /// <example>
-        ///   <code>
-        ///     var cipher = new ZipCrypto();
-        ///     cipher.InitCipher(Password);
-        ///     // Decrypt the header.  This has a side effect of "further initializing the
-        ///     // encryption keys" in the traditional zip encryption.
-        ///     byte[] DecryptedMessage = cipher.DecryptMessage(EncryptedMessage);
-        ///   </code>
-        /// </example>
-        ///
-        /// <param name="cipherText">The encrypted buffer.</param>
-        /// <param name="length">
-        ///   The number of bytes to encrypt.
-        ///   Should be less than or equal to CipherText.Length.
-        /// </param>
-        ///
-        /// <returns>The plaintext.</returns>
-        public byte[] DecryptMessage(byte[] cipherText, int length)
-        {
-            if (cipherText == null)
-                throw new ArgumentNullException("cipherText");
-
-            if (length > cipherText.Length)
-                throw new ArgumentOutOfRangeException("length",
-                                                      "Bad length during Decryption: the length parameter must be smaller than or equal to the size of the destination array.");
-
-            byte[] plainText = new byte[length];
-            for (int i = 0; i < length; i++)
-            {
-                byte C = (byte)(cipherText[i] ^ MagicByte);
-                UpdateKeys(C);
-                plainText[i] = C;
-            }
-            return plainText;
-        }
-
-        /// <summary>
-        ///   This is the converse of DecryptMessage.  It encrypts the plaintext
-        ///   and produces a ciphertext.
-        /// </summary>
-        ///
-        /// <param name="plainText">The plain text buffer.</param>
-        ///
-        /// <param name="length">
-        ///   The number of bytes to encrypt.
-        ///   Should be less than or equal to plainText.Length.
-        /// </param>
-        ///
-        /// <returns>The ciphertext.</returns>
-        public byte[] EncryptMessage(byte[] plainText, int length)
-        {
-            if (plainText == null)
-                throw new ArgumentNullException("plaintext");
-
-            if (length > plainText.Length)
-                throw new ArgumentOutOfRangeException("length",
-                                                      "Bad length during Encryption: The length parameter must be smaller than or equal to the size of the destination array.");
-
-            byte[] cipherText = new byte[length];
-            for (int i = 0; i < length; i++)
-            {
-                byte C = plainText[i];
-                cipherText[i] = (byte)(plainText[i] ^ MagicByte);
-                UpdateKeys(C);
-            }
-            return cipherText;
-        }
-
-
-        /// <summary>
-        ///   This initializes the cipher with the given password.
-        ///   See AppNote.txt for details.
-        /// </summary>
-        ///
-        /// <param name="passphrase">
-        ///   The passphrase for encrypting or decrypting with this cipher.
-        /// </param>
-        ///
-        /// <remarks>
-        /// <code>
-        /// Step 1 - Initializing the encryption keys
-        /// -----------------------------------------
-        /// Start with these keys:
-        /// Key(0) := 305419896 (0x12345678)
-        /// Key(1) := 591751049 (0x23456789)
-        /// Key(2) := 878082192 (0x34567890)
-        ///
-        /// Then, initialize the keys with a password:
-        ///
-        /// loop for i from 0 to length(password)-1
-        ///     update_keys(password(i))
-        /// end loop
-        ///
-        /// Where update_keys() is defined as:
-        ///
-        /// update_keys(char):
-        ///   Key(0) := crc32(key(0),char)
-        ///   Key(1) := Key(1) + (Key(0) bitwiseAND 000000ffH)
-        ///   Key(1) := Key(1) * 134775813 + 1
-        ///   Key(2) := crc32(key(2),key(1) rightshift 24)
-        /// end update_keys
-        ///
-        /// Where crc32(old_crc,char) is a routine that given a CRC value and a
-        /// character, returns an updated CRC value after applying the CRC-32
-        /// algorithm described elsewhere in this document.
-        ///
-        /// </code>
-        ///
-        /// <para>
-        ///   After the keys are initialized, then you can use the cipher to
-        ///   encrypt the plaintext.
-        /// </para>
-        ///
-        /// <para>
-        ///   Essentially we encrypt the password with the keys, then discard the
-        ///   ciphertext for the password. This initializes the keys for later use.
-        /// </para>
-        ///
-        /// </remarks>
-        public void InitCipher(string passphrase)
-        {
-            byte[] p = SharedUtilities.StringToByteArray(passphrase);
-            for (int i = 0; i < passphrase.Length; i++)
-                UpdateKeys(p[i]);
-        }
-
-
-        private void UpdateKeys(byte byteValue)
-        {
-            _Keys[0] = (UInt32)crc32.ComputeCrc32((int)_Keys[0], byteValue);
-            _Keys[1] = _Keys[1] + (byte)_Keys[0];
-            _Keys[1] = _Keys[1] * 0x08088405 + 1;
-            _Keys[2] = (UInt32)crc32.ComputeCrc32((int)_Keys[2], (byte)(_Keys[1] >> 24));
-        }
-
-        ///// <summary>
-        ///// The byte array representing the seed keys used.
-        ///// Get this after calling InitCipher.  The 12 bytes represents
-        ///// what the zip spec calls the "EncryptionHeader".
-        ///// </summary>
-        //public byte[] KeyHeader
-        //{
-        //    get
-        //    {
-        //        byte[] result = new byte[12];
-        //        result[0] = (byte)(_Keys[0] & 0xff);
-        //        result[1] = (byte)((_Keys[0] >> 8) & 0xff);
-        //        result[2] = (byte)((_Keys[0] >> 16) & 0xff);
-        //        result[3] = (byte)((_Keys[0] >> 24) & 0xff);
-        //        result[4] = (byte)(_Keys[1] & 0xff);
-        //        result[5] = (byte)((_Keys[1] >> 8) & 0xff);
-        //        result[6] = (byte)((_Keys[1] >> 16) & 0xff);
-        //        result[7] = (byte)((_Keys[1] >> 24) & 0xff);
-        //        result[8] = (byte)(_Keys[2] & 0xff);
-        //        result[9] = (byte)((_Keys[2] >> 8) & 0xff);
-        //        result[10] = (byte)((_Keys[2] >> 16) & 0xff);
-        //        result[11] = (byte)((_Keys[2] >> 24) & 0xff);
-        //        return result;
-        //    }
-        //}
-
-        // private fields for the crypto stuff:
-        private UInt32[] _Keys = { 0x12345678, 0x23456789, 0x34567890 };
-        private Ionic.Crc.CRC32 crc32 = new Ionic.Crc.CRC32();
-
-    }
-
-    internal enum CryptoMode
-    {
-        Encrypt,
-        Decrypt
-    }
-
-    /// <summary>
-    ///   A Stream for reading and concurrently decrypting data from a zip file,
-    ///   or for writing and concurrently encrypting data to a zip file.
-    /// </summary>
-    internal class ZipCipherStream : System.IO.Stream
-    {
-        private ZipCrypto _cipher;
-        private System.IO.Stream _s;
-        private CryptoMode _mode;
-
-        /// <summary>  The constructor. </summary>
-        /// <param name="s">The underlying stream</param>
-        /// <param name="mode">To either encrypt or decrypt.</param>
-        /// <param name="cipher">The pre-initialized ZipCrypto object.</param>
-        public ZipCipherStream(System.IO.Stream s, ZipCrypto cipher, CryptoMode mode)
-            : base()
-        {
-            _cipher = cipher;
-            _s = s;
-            _mode = mode;
-        }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_mode == CryptoMode.Encrypt)
-                throw new NotSupportedException("This stream does not encrypt via Read()");
-
-            if (buffer == null)
-                throw new ArgumentNullException("buffer");
-
-            byte[] db = new byte[count];
-            int n = _s.Read(db, 0, count);
-            byte[] decrypted = _cipher.DecryptMessage(db, n);
-            for (int i = 0; i < n; i++)
-            {
-                buffer[offset + i] = decrypted[i];
-            }
-            return n;
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (_mode == CryptoMode.Decrypt)
-                throw new NotSupportedException("This stream does not Decrypt via Write()");
-
-            if (buffer == null)
-                throw new ArgumentNullException("buffer");
-
-            // workitem 7696
-            if (count == 0) return;
-
-            byte[] plaintext = null;
-            if (offset != 0)
-            {
-                plaintext = new byte[count];
-                for (int i = 0; i < count; i++)
-                {
-                    plaintext[i] = buffer[offset + i];
-                }
-            }
-            else plaintext = buffer;
-
-            byte[] encrypted = _cipher.EncryptMessage(plaintext, count);
-            _s.Write(encrypted, 0, encrypted.Length);
-        }
-
-
-        public override bool CanRead
-        {
-            get { return (_mode == CryptoMode.Decrypt); }
-        }
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-        public override bool CanWrite
-        {
-            get { return (_mode == CryptoMode.Encrypt); }
-        }
-
-        public override void Flush()
-        {
-            //throw new NotSupportedException();
-        }
-
-        public override long Length
-        {
-            get { throw new NotSupportedException(); }
-        }
-
-        public override long Position
-        {
-            get { throw new NotSupportedException(); }
-            set { throw new NotSupportedException(); }
-        }
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipDirEntry.cs b/EPPlus/Packaging/DotNetZip/ZipDirEntry.cs
deleted file mode 100644
index ddc2447..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipDirEntry.cs
+++ /dev/null
@@ -1,381 +0,0 @@
-// ZipDirEntry.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006-2011 Dino Chiesa .
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-11 12:03:03>
-//
-// ------------------------------------------------------------------
-//
-// This module defines members of the ZipEntry class for reading the
-// Zip file central directory.
-//
-// Created: Tue, 27 Mar 2007  15:30
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    partial class ZipEntry
-    {
-        /// <summary>
-        /// True if the referenced entry is a directory.
-        /// </summary>
-        internal bool AttributesIndicateDirectory
-        {
-            get { return ((_InternalFileAttrs == 0) && ((_ExternalFileAttrs & 0x0010) == 0x0010)); }
-        }
-
-
-        internal void ResetDirEntry()
-        {
-            // __FileDataPosition is the position of the file data for an entry.
-            // It is _RelativeOffsetOfLocalHeader + size of local header.
-
-            // We cannot know the __FileDataPosition until we read the local
-            // header.
-
-            // The local header is not necessarily the same length as the record
-            // in the central directory.
-
-            // Set to -1, to indicate we need to read this later.
-            this.__FileDataPosition = -1;
-
-            // set _LengthOfHeader to 0, to indicate we need to read later.
-            this._LengthOfHeader = 0;
-        }
-
-        /// <summary>
-        /// Provides a human-readable string with information about the ZipEntry.
-        /// </summary>
-        public string Info
-        {
-            get
-            {
-                var builder = new System.Text.StringBuilder();
-                builder
-                    .Append(string.Format("          ZipEntry: {0}\n", this.FileName))
-                    .Append(string.Format("   Version Made By: {0}\n", this._VersionMadeBy))
-                    .Append(string.Format(" Needed to extract: {0}\n", this.VersionNeeded));
-
-                if (this._IsDirectory)
-                    builder.Append("        Entry type: directory\n");
-                else
-                {
-                    builder.Append(string.Format("         File type: {0}\n", this._IsText? "text":"binary"))
-                        .Append(string.Format("       Compression: {0}\n", this.CompressionMethod))
-                        .Append(string.Format("        Compressed: 0x{0:X}\n", this.CompressedSize))
-                        .Append(string.Format("      Uncompressed: 0x{0:X}\n", this.UncompressedSize))
-                        .Append(string.Format("             CRC32: 0x{0:X8}\n", this._Crc32));
-                }
-                builder.Append(string.Format("       Disk Number: {0}\n", this._diskNumber));
-                if (this._RelativeOffsetOfLocalHeader > 0xFFFFFFFF)
-                    builder
-                        .Append(string.Format("   Relative Offset: 0x{0:X16}\n", this._RelativeOffsetOfLocalHeader));
-                        else
-                    builder
-                        .Append(string.Format("   Relative Offset: 0x{0:X8}\n", this._RelativeOffsetOfLocalHeader));
-
-                    builder
-                    .Append(string.Format("         Bit Field: 0x{0:X4}\n", this._BitField))
-                    .Append(string.Format("        Encrypted?: {0}\n", this._sourceIsEncrypted))
-                    .Append(string.Format("          Timeblob: 0x{0:X8}\n", this._TimeBlob))
-                        .Append(string.Format("              Time: {0}\n", Ionic.Zip.SharedUtilities.PackedToDateTime(this._TimeBlob)));
-
-                builder.Append(string.Format("         Is Zip64?: {0}\n", this._InputUsesZip64));
-                if (!string.IsNullOrEmpty(this._Comment))
-                {
-                    builder.Append(string.Format("           Comment: {0}\n", this._Comment));
-                }
-                builder.Append("\n");
-                return builder.ToString();
-            }
-        }
-
-
-        // workitem 10330
-        private class CopyHelper
-        {
-            private static System.Text.RegularExpressions.Regex re =
-                new System.Text.RegularExpressions.Regex(" \\(copy (\\d+)\\)$");
-
-            private static int callCount = 0;
-
-            internal static string AppendCopyToFileName(string f)
-            {
-                callCount++;
-                if (callCount > 25)
-                    throw new OverflowException("overflow while creating filename");
-
-                int n = 1;
-                int r = f.LastIndexOf(".");
-
-                if (r == -1)
-                {
-                    // there is no extension
-                    System.Text.RegularExpressions.Match m = re.Match(f);
-                    if (m.Success)
-                    {
-                        n = Int32.Parse(m.Groups[1].Value) + 1;
-                        string copy = String.Format(" (copy {0})", n);
-                        f = f.Substring(0, m.Index) + copy;
-                    }
-                    else
-                    {
-                        string copy = String.Format(" (copy {0})", n);
-                        f = f + copy;
-                    }
-                }
-                else
-                {
-                    //System.Console.WriteLine("HasExtension");
-                    System.Text.RegularExpressions.Match m = re.Match(f.Substring(0, r));
-                    if (m.Success)
-                    {
-                        n = Int32.Parse(m.Groups[1].Value) + 1;
-                        string copy = String.Format(" (copy {0})", n);
-                        f = f.Substring(0, m.Index) + copy + f.Substring(r);
-                    }
-                    else
-                    {
-                        string copy = String.Format(" (copy {0})", n);
-                        f = f.Substring(0, r) + copy + f.Substring(r);
-                    }
-
-                    //System.Console.WriteLine("returning f({0})", f);
-                }
-                return f;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Reads one entry from the zip directory structure in the zip file.
-        /// </summary>
-        ///
-        /// <param name="zf">
-        ///   The zipfile for which a directory entry will be read.  From this param, the
-        ///   method gets the ReadStream and the expected text encoding
-        ///   (ProvisionalAlternateEncoding) which is used if the entry is not marked
-        ///   UTF-8.
-        /// </param>
-        ///
-        /// <param name="previouslySeen">
-        ///   a list of previously seen entry names; used to prevent duplicates.
-        /// </param>
-        ///
-        /// <returns>the entry read from the archive.</returns>
-        internal static ZipEntry ReadDirEntry(ZipFile zf,
-                                              Dictionary<String,Object> previouslySeen)
-        {
-            System.IO.Stream s = zf.ReadStream;
-            System.Text.Encoding expectedEncoding = (zf.AlternateEncodingUsage == ZipOption.Always)
-                ? zf.AlternateEncoding
-                : ZipFile.DefaultEncoding;
-
-            int signature = Ionic.Zip.SharedUtilities.ReadSignature(s);
-            // return null if this is not a local file header signature
-            if (IsNotValidZipDirEntrySig(signature))
-            {
-                s.Seek(-4, System.IO.SeekOrigin.Current);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-
-                // Getting "not a ZipDirEntry signature" here is not always wrong or an
-                // error.  This can happen when walking through a zipfile.  After the
-                // last ZipDirEntry, we expect to read an
-                // EndOfCentralDirectorySignature.  When we get this is how we know
-                // we've reached the end of the central directory.
-                if (signature != ZipConstants.EndOfCentralDirectorySignature &&
-                    signature != ZipConstants.Zip64EndOfCentralDirectoryRecordSignature &&
-                    signature != ZipConstants.ZipEntrySignature  // workitem 8299
-                    )
-                {
-                    throw new BadReadException(String.Format("  Bad signature (0x{0:X8}) at position 0x{1:X8}", signature, s.Position));
-                }
-                return null;
-            }
-
-            int bytesRead = 42 + 4;
-            byte[] block = new byte[42];
-            int n = s.Read(block, 0, block.Length);
-            if (n != block.Length) return null;
-
-            int i = 0;
-            ZipEntry zde = new ZipEntry();
-            zde.AlternateEncoding = expectedEncoding;
-            zde._Source = ZipEntrySource.ZipFile;
-            zde._container = new ZipContainer(zf);
-
-            unchecked
-            {
-                zde._VersionMadeBy = (short)(block[i++] + block[i++] * 256);
-                zde._VersionNeeded = (short)(block[i++] + block[i++] * 256);
-                zde._BitField = (short)(block[i++] + block[i++] * 256);
-                zde._CompressionMethod = (Int16)(block[i++] + block[i++] * 256);
-                zde._TimeBlob = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
-                zde._LastModified = Ionic.Zip.SharedUtilities.PackedToDateTime(zde._TimeBlob);
-                zde._timestamp |= ZipEntryTimestamp.DOS;
-
-                zde._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
-                zde._CompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                zde._UncompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-            }
-
-            // preserve
-            zde._CompressionMethod_FromZipFile = zde._CompressionMethod;
-
-            zde._filenameLength = (short)(block[i++] + block[i++] * 256);
-            zde._extraFieldLength = (short)(block[i++] + block[i++] * 256);
-            zde._commentLength = (short)(block[i++] + block[i++] * 256);
-            zde._diskNumber = (UInt32)(block[i++] + block[i++] * 256);
-
-            zde._InternalFileAttrs = (short)(block[i++] + block[i++] * 256);
-            zde._ExternalFileAttrs = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
-
-            zde._RelativeOffsetOfLocalHeader = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-
-            // workitem 7801
-            zde.IsText = ((zde._InternalFileAttrs & 0x01) == 0x01);
-
-            block = new byte[zde._filenameLength];
-            n = s.Read(block, 0, block.Length);
-            bytesRead += n;
-            if ((zde._BitField & 0x0800) == 0x0800)
-            {
-                // UTF-8 is in use
-                zde._FileNameInArchive = Ionic.Zip.SharedUtilities.Utf8StringFromBuffer(block);
-            }
-            else
-            {
-                zde._FileNameInArchive = Ionic.Zip.SharedUtilities.StringFromBuffer(block, expectedEncoding);
-            }
-
-            // workitem 10330
-            // insure unique entry names
-            while (previouslySeen.ContainsKey(zde._FileNameInArchive))
-            {
-                zde._FileNameInArchive = CopyHelper.AppendCopyToFileName(zde._FileNameInArchive);
-                zde._metadataChanged = true;
-            }
-
-            if (zde.AttributesIndicateDirectory)
-                zde.MarkAsDirectory();  // may append a slash to filename if nec.
-            // workitem 6898
-            else if (zde._FileNameInArchive.EndsWith("/")) zde.MarkAsDirectory();
-
-            zde._CompressedFileDataSize = zde._CompressedSize;
-            if ((zde._BitField & 0x01) == 0x01)
-            {
-                // this may change after processing the Extra field
-                zde._Encryption_FromZipFile = zde._Encryption =
-                    EncryptionAlgorithm.PkzipWeak;
-                zde._sourceIsEncrypted = true;
-            }
-
-            if (zde._extraFieldLength > 0)
-            {
-                zde._InputUsesZip64 = (zde._CompressedSize == 0xFFFFFFFF ||
-                      zde._UncompressedSize == 0xFFFFFFFF ||
-                      zde._RelativeOffsetOfLocalHeader == 0xFFFFFFFF);
-
-                // Console.WriteLine("  Input uses Z64?:      {0}", zde._InputUsesZip64);
-
-                bytesRead += zde.ProcessExtraField(s, zde._extraFieldLength);
-                zde._CompressedFileDataSize = zde._CompressedSize;
-            }
-
-            // we've processed the extra field, so we know the encryption method is set now.
-            if (zde._Encryption == EncryptionAlgorithm.PkzipWeak)
-            {
-                // the "encryption header" of 12 bytes precedes the file data
-                zde._CompressedFileDataSize -= 12;
-            }
-#if AESCRYPTO
-            else if (zde.Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                        zde.Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                zde._CompressedFileDataSize = zde.CompressedSize -
-                    (ZipEntry.GetLengthOfCryptoHeaderBytes(zde.Encryption) + 10);
-                zde._LengthOfTrailer = 10;
-            }
-#endif
-
-            // tally the trailing descriptor
-            if ((zde._BitField & 0x0008) == 0x0008)
-            {
-                // sig, CRC, Comp and Uncomp sizes
-                if (zde._InputUsesZip64)
-                    zde._LengthOfTrailer += 24;
-                else
-                    zde._LengthOfTrailer += 16;
-            }
-
-            // workitem 12744
-            zde.AlternateEncoding = ((zde._BitField & 0x0800) == 0x0800)
-                ? System.Text.Encoding.UTF8
-                :expectedEncoding;
-
-            zde.AlternateEncodingUsage = ZipOption.Always;
-
-            if (zde._commentLength > 0)
-            {
-                block = new byte[zde._commentLength];
-                n = s.Read(block, 0, block.Length);
-                bytesRead += n;
-                if ((zde._BitField & 0x0800) == 0x0800)
-                {
-                    // UTF-8 is in use
-                    zde._Comment = Ionic.Zip.SharedUtilities.Utf8StringFromBuffer(block);
-                }
-                else
-                {
-                    zde._Comment = Ionic.Zip.SharedUtilities.StringFromBuffer(block, expectedEncoding);
-                }
-            }
-            //zde._LengthOfDirEntry = bytesRead;
-            return zde;
-        }
-
-
-        /// <summary>
-        /// Returns true if the passed-in value is a valid signature for a ZipDirEntry.
-        /// </summary>
-        /// <param name="signature">the candidate 4-byte signature value.</param>
-        /// <returns>true, if the signature is valid according to the PKWare spec.</returns>
-        internal static bool IsNotValidZipDirEntrySig(int signature)
-        {
-            return (signature != ZipConstants.ZipDirEntrySignature);
-        }
-
-
-        private Int16 _VersionMadeBy;
-        private Int16 _InternalFileAttrs;
-        private Int32 _ExternalFileAttrs;
-
-        //private Int32 _LengthOfDirEntry;
-        private Int16 _filenameLength;
-        private Int16 _extraFieldLength;
-        private Int16 _commentLength;
-    }
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipEntry.Extract.cs b/EPPlus/Packaging/DotNetZip/ZipEntry.Extract.cs
deleted file mode 100644
index eb92b4c..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipEntry.Extract.cs
+++ /dev/null
@@ -1,1455 +0,0 @@
-// ZipEntry.Extract.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-06 18:08:21>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for Extract methods on the ZipEntry class.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    internal partial class ZipEntry
-    {
-        /// <summary>
-        ///   Extract the entry to the filesystem, starting at the current
-        ///   working directory.
-        /// </summary>
-        ///
-        /// <overloads>
-        ///   This method has a bunch of overloads! One of them is sure to
-        ///   be the right one for you... If you don't like these, check
-        ///   out the <c>ExtractWithPassword()</c> methods.
-        /// </overloads>
-        ///
-        /// <seealso cref="ZipEntry.ExtractExistingFile"/>
-        /// <seealso cref="ZipEntry.Extract(ExtractExistingFileAction)"/>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This method extracts an entry from a zip file into the current
-        ///   working directory.  The path of the entry as extracted is the full
-        ///   path as specified in the zip archive, relative to the current
-        ///   working directory.  After the file is extracted successfully, the
-        ///   file attributes and timestamps are set.
-        /// </para>
-        ///
-        /// <para>
-        ///   The action taken when extraction an entry would overwrite an
-        ///   existing file is determined by the <see cref="ExtractExistingFile"
-        ///   /> property.
-        /// </para>
-        ///
-        /// <para>
-        ///   Within the call to <c>Extract()</c>, the content for the entry is
-        ///   written into a filesystem file, and then the last modified time of the
-        ///   file is set according to the <see cref="LastModified"/> property on
-        ///   the entry. See the remarks the <see cref="LastModified"/> property for
-        ///   some details about the last modified time.
-        /// </para>
-        ///
-        /// </remarks>
-        internal void Extract()
-        {
-            InternalExtract(".", null, null);
-        }
-
-
-        /// <summary>
-        ///   Extract the entry to a file in the filesystem, using the specified
-        ///   behavior when extraction would overwrite an existing file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the file is set after
-        ///   extraction.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="extractExistingFile">
-        ///   The action to take if extraction would overwrite an existing file.
-        /// </param>
-        internal void Extract(ExtractExistingFileAction extractExistingFile)
-        {
-            ExtractExistingFile = extractExistingFile;
-            InternalExtract(".", null, null);
-        }
-
-        /// <summary>
-        ///   Extracts the entry to the specified stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The caller can specify any write-able stream, for example a <see
-        ///   cref="System.IO.FileStream"/>, a <see
-        ///   cref="System.IO.MemoryStream"/>, or ASP.NET's
-        ///   <c>Response.OutputStream</c>.  The content will be decrypted and
-        ///   decompressed as necessary. If the entry is encrypted and no password
-        ///   is provided, this method will throw.
-        /// </para>
-        /// <para>
-        ///   The position on the stream is not reset by this method before it extracts.
-        ///   You may want to call stream.Seek() before calling ZipEntry.Extract().
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   the stream to which the entry should be extracted.
-        /// </param>
-        ///
-        public void Extract(Stream stream)
-        {
-            InternalExtract(null, stream, null);
-        }
-
-        /// <summary>
-        ///   Extract the entry to the filesystem, starting at the specified base
-        ///   directory.
-        /// </summary>
-        ///
-        /// <param name="baseDirectory">the pathname of the base directory</param>
-        ///
-        /// <seealso cref="ZipEntry.ExtractExistingFile"/>
-        /// <seealso cref="ZipEntry.Extract(string, ExtractExistingFileAction)"/>
-        ///
-        /// <example>
-        /// This example extracts only the entries in a zip file that are .txt files,
-        /// into a directory called "textfiles".
-        /// <code lang="C#">
-        /// using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))
-        /// {
-        ///   foreach (string s1 in zip.EntryFilenames)
-        ///   {
-        ///     if (s1.EndsWith(".txt"))
-        ///     {
-        ///       zip[s1].Extract("textfiles");
-        ///     }
-        ///   }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        ///   Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")
-        ///       Dim s1 As String
-        ///       For Each s1 In zip.EntryFilenames
-        ///           If s1.EndsWith(".txt") Then
-        ///               zip(s1).Extract("textfiles")
-        ///           End If
-        ///       Next
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Using this method, existing entries in the filesystem will not be
-        ///   overwritten. If you would like to force the overwrite of existing
-        ///   files, see the <see cref="ExtractExistingFile"/> property, or call
-        ///   <see cref="Extract(string, ExtractExistingFileAction)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the created file is set.
-        /// </para>
-        /// </remarks>
-        public void Extract(string baseDirectory)
-        {
-            InternalExtract(baseDirectory, null, null);
-        }
-
-
-
-
-
-        /// <summary>
-        ///   Extract the entry to the filesystem, starting at the specified base
-        ///   directory, and using the specified behavior when extraction would
-        ///   overwrite an existing file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the created file is set.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code lang="C#">
-        /// String sZipPath = "Airborne.zip";
-        /// String sFilePath = "Readme.txt";
-        /// String sRootFolder = "Digado";
-        /// using (ZipFile zip = ZipFile.Read(sZipPath))
-        /// {
-        ///   if (zip.EntryFileNames.Contains(sFilePath))
-        ///   {
-        ///     // use the string indexer on the zip file
-        ///     zip[sFileName].Extract(sRootFolder,
-        ///                            ExtractExistingFileAction.OverwriteSilently);
-        ///   }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim sZipPath as String = "Airborne.zip"
-        /// Dim sFilePath As String = "Readme.txt"
-        /// Dim sRootFolder As String = "Digado"
-        /// Using zip As ZipFile = ZipFile.Read(sZipPath)
-        ///   If zip.EntryFileNames.Contains(sFilePath)
-        ///     ' use the string indexer on the zip file
-        ///     zip(sFilePath).Extract(sRootFolder, _
-        ///                            ExtractExistingFileAction.OverwriteSilently)
-        ///   End If
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="baseDirectory">the pathname of the base directory</param>
-        /// <param name="extractExistingFile">
-        /// The action to take if extraction would overwrite an existing file.
-        /// </param>
-        internal void Extract(string baseDirectory, ExtractExistingFileAction extractExistingFile)
-        {
-            ExtractExistingFile = extractExistingFile;
-            InternalExtract(baseDirectory, null, null);
-        }
-
-
-        /// <summary>
-        ///   Extract the entry to the filesystem, using the current working directory
-        ///   and the specified password.
-        /// </summary>
-        ///
-        /// <overloads>
-        ///   This method has a bunch of overloads! One of them is sure to be
-        ///   the right one for you...
-        /// </overloads>
-        ///
-        /// <seealso cref="ZipEntry.ExtractExistingFile"/>
-        /// <seealso cref="ZipEntry.ExtractWithPassword(ExtractExistingFileAction, string)"/>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Existing entries in the filesystem will not be overwritten. If you
-        ///   would like to force the overwrite of existing files, see the <see
-        ///   cref="ZipEntry.ExtractExistingFile"/>property, or call
-        ///   <see
-        ///   cref="ExtractWithPassword(ExtractExistingFileAction,string)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property for some
-        ///   details about how the "last modified" time of the created file is
-        ///   set.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///   In this example, entries that use encryption are extracted using a
-        ///   particular password.
-        /// <code>
-        /// using (var zip = ZipFile.Read(FilePath))
-        /// {
-        ///     foreach (ZipEntry e in zip)
-        ///     {
-        ///         if (e.UsesEncryption)
-        ///             e.ExtractWithPassword("Secret!");
-        ///         else
-        ///             e.Extract();
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(FilePath)
-        ///     Dim e As ZipEntry
-        ///     For Each e In zip
-        ///         If (e.UsesEncryption)
-        ///           e.ExtractWithPassword("Secret!")
-        ///         Else
-        ///           e.Extract
-        ///         End If
-        ///     Next
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="password">The Password to use for decrypting the entry.</param>
-        public void ExtractWithPassword(string password)
-        {
-            InternalExtract(".", null, password);
-        }
-
-        /// <summary>
-        ///   Extract the entry to the filesystem, starting at the specified base
-        ///   directory, and using the specified password.
-        /// </summary>
-        ///
-        /// <seealso cref="ZipEntry.ExtractExistingFile"/>
-        /// <seealso cref="ZipEntry.ExtractWithPassword(string, ExtractExistingFileAction, string)"/>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Existing entries in the filesystem will not be overwritten. If you
-        ///   would like to force the overwrite of existing files, see the <see
-        ///   cref="ZipEntry.ExtractExistingFile"/>property, or call
-        ///   <see
-        ///   cref="ExtractWithPassword(ExtractExistingFileAction,string)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the created file is set.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="baseDirectory">The pathname of the base directory.</param>
-        /// <param name="password">The Password to use for decrypting the entry.</param>
-        public void ExtractWithPassword(string baseDirectory, string password)
-        {
-            InternalExtract(baseDirectory, null, password);
-        }
-
-
-
-
-        /// <summary>
-        ///   Extract the entry to a file in the filesystem, relative to the
-        ///   current directory, using the specified behavior when extraction
-        ///   would overwrite an existing file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the created file is set.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="password">The Password to use for decrypting the entry.</param>
-        ///
-        /// <param name="extractExistingFile">
-        /// The action to take if extraction would overwrite an existing file.
-        /// </param>
-        internal void ExtractWithPassword(ExtractExistingFileAction extractExistingFile, string password)
-        {
-            ExtractExistingFile = extractExistingFile;
-            InternalExtract(".", null, password);
-        }
-
-
-
-        /// <summary>
-        ///   Extract the entry to the filesystem, starting at the specified base
-        ///   directory, and using the specified behavior when extraction would
-        ///   overwrite an existing file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   See the remarks on the <see cref="LastModified"/> property, for some
-        ///   details about how the last modified time of the created file is set.
-        /// </remarks>
-        ///
-        /// <param name="baseDirectory">the pathname of the base directory</param>
-        ///
-        /// <param name="extractExistingFile">The action to take if extraction would
-        /// overwrite an existing file.</param>
-        ///
-        /// <param name="password">The Password to use for decrypting the entry.</param>
-        internal void ExtractWithPassword(string baseDirectory, ExtractExistingFileAction extractExistingFile, string password)
-        {
-            ExtractExistingFile = extractExistingFile;
-            InternalExtract(baseDirectory, null, password);
-        }
-
-        /// <summary>
-        ///   Extracts the entry to the specified stream, using the specified
-        ///   Password.  For example, the caller could extract to Console.Out, or
-        ///   to a MemoryStream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The caller can specify any write-able stream, for example a <see
-        ///   cref="System.IO.FileStream"/>, a <see
-        ///   cref="System.IO.MemoryStream"/>, or ASP.NET's
-        ///   <c>Response.OutputStream</c>.  The content will be decrypted and
-        ///   decompressed as necessary. If the entry is encrypted and no password
-        ///   is provided, this method will throw.
-        /// </para>
-        /// <para>
-        ///   The position on the stream is not reset by this method before it extracts.
-        ///   You may want to call stream.Seek() before calling ZipEntry.Extract().
-        /// </para>
-        /// </remarks>
-        ///
-        ///
-        /// <param name="stream">
-        ///   the stream to which the entry should be extracted.
-        /// </param>
-        /// <param name="password">
-        ///   The password to use for decrypting the entry.
-        /// </param>
-        public void ExtractWithPassword(Stream stream, string password)
-        {
-            InternalExtract(null, stream, password);
-        }
-
-
-        /// <summary>
-        ///   Opens a readable stream corresponding to the zip entry in the
-        ///   archive.  The stream decompresses and decrypts as necessary, as it
-        ///   is read.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   DotNetZip offers a variety of ways to extract entries from a zip
-        ///   file.  This method allows an application to extract an entry by
-        ///   reading a <see cref="System.IO.Stream"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   The return value is of type <see
-        ///   cref="Ionic.Crc.CrcCalculatorStream"/>.  Use it as you would any
-        ///   stream for reading.  When an application calls <see
-        ///   cref="Stream.Read(byte[], int, int)"/> on that stream, it will
-        ///   receive data from the zip entry that is decrypted and decompressed
-        ///   as necessary.
-        /// </para>
-        ///
-        /// <para>
-        ///   <c>CrcCalculatorStream</c> adds one additional feature: it keeps a
-        ///   CRC32 checksum on the bytes of the stream as it is read.  The CRC
-        ///   value is available in the <see
-        ///   cref="Ionic.Crc.CrcCalculatorStream.Crc"/> property on the
-        ///   <c>CrcCalculatorStream</c>.  When the read is complete, your
-        ///   application
-        ///   <em>should</em> check this CRC against the <see cref="ZipEntry.Crc"/>
-        ///   property on the <c>ZipEntry</c> to validate the content of the
-        ///   ZipEntry. You don't have to validate the entry using the CRC, but
-        ///   you should, to verify integrity. Check the example for how to do
-        ///   this.
-        /// </para>
-        ///
-        /// <para>
-        ///   If the entry is protected with a password, then you need to provide
-        ///   a password prior to calling <see cref="OpenReader()"/>, either by
-        ///   setting the <see cref="Password"/> property on the entry, or the
-        ///   <see cref="ZipFile.Password"/> property on the <c>ZipFile</c>
-        ///   itself. Or, you can use <see cref="OpenReader(String)" />, the
-        ///   overload of OpenReader that accepts a password parameter.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you want to extract entry data into a write-able stream that is
-        ///   already opened, like a <see cref="System.IO.FileStream"/>, do not
-        ///   use this method. Instead, use <see cref="Extract(Stream)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Your application may use only one stream created by OpenReader() at
-        ///   a time, and you should not call other Extract methods before
-        ///   completing your reads on a stream obtained from OpenReader().  This
-        ///   is because there is really only one source stream for the compressed
-        ///   content.  A call to OpenReader() seeks in the source stream, to the
-        ///   beginning of the compressed content.  A subsequent call to
-        ///   OpenReader() on a different entry will seek to a different position
-        ///   in the source stream, as will a call to Extract() or one of its
-        ///   overloads.  This will corrupt the state for the decompressing stream
-        ///   from the original call to OpenReader().
-        /// </para>
-        ///
-        /// <para>
-        ///    The <c>OpenReader()</c> method works only when the ZipEntry is
-        ///    obtained from an instance of <c>ZipFile</c>. This method will throw
-        ///    an exception if the ZipEntry is obtained from a ZipInputStream.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example shows how to open a zip archive, then read in a named
-        ///   entry via a stream. After the read loop is complete, the code
-        ///   compares the calculated during the read loop with the expected CRC
-        ///   on the <c>ZipEntry</c>, to verify the extraction.
-        /// <code>
-        /// using (ZipFile zip = new ZipFile(ZipFileToRead))
-        /// {
-        ///   ZipEntry e1= zip["Elevation.mp3"];
-        ///   using (Ionic.Zlib.CrcCalculatorStream s = e1.OpenReader())
-        ///   {
-        ///     byte[] buffer = new byte[4096];
-        ///     int n, totalBytesRead= 0;
-        ///     do {
-        ///       n = s.Read(buffer,0, buffer.Length);
-        ///       totalBytesRead+=n;
-        ///     } while (n&gt;0);
-        ///      if (s.Crc32 != e1.Crc32)
-        ///       throw new Exception(string.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32));
-        ///      if (totalBytesRead != e1.UncompressedSize)
-        ///       throw new Exception(string.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize));
-        ///   }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        ///   Using zip As New ZipFile(ZipFileToRead)
-        ///       Dim e1 As ZipEntry = zip.Item("Elevation.mp3")
-        ///       Using s As Ionic.Zlib.CrcCalculatorStream = e1.OpenReader
-        ///           Dim n As Integer
-        ///           Dim buffer As Byte() = New Byte(4096) {}
-        ///           Dim totalBytesRead As Integer = 0
-        ///           Do
-        ///               n = s.Read(buffer, 0, buffer.Length)
-        ///               totalBytesRead = (totalBytesRead + n)
-        ///           Loop While (n &gt; 0)
-        ///           If (s.Crc32 &lt;&gt; e1.Crc32) Then
-        ///               Throw New Exception(String.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32))
-        ///           End If
-        ///           If (totalBytesRead &lt;&gt; e1.UncompressedSize) Then
-        ///               Throw New Exception(String.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize))
-        ///           End If
-        ///       End Using
-        ///   End Using
-        /// </code>
-        /// </example>
-        /// <seealso cref="ZipEntry.Extract(System.IO.Stream)"/>
-        /// <returns>The Stream for reading.</returns>
-        internal Ionic.Crc.CrcCalculatorStream OpenReader()
-        {
-            // workitem 10923
-            if (_container.ZipFile == null)
-                throw new InvalidOperationException("Use OpenReader() only with ZipFile.");
-
-            // use the entry password if it is non-null,
-            // else use the zipfile password, which is possibly null
-            return InternalOpenReader(this._Password ?? this._container.Password);
-        }
-
-        /// <summary>
-        ///   Opens a readable stream for an encrypted zip entry in the archive.
-        ///   The stream decompresses and decrypts as necessary, as it is read.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the documentation on the <see cref="OpenReader()"/> method for
-        ///   full details. This overload allows the application to specify a
-        ///   password for the <c>ZipEntry</c> to be read.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="password">The password to use for decrypting the entry.</param>
-        /// <returns>The Stream for reading.</returns>
-        internal Ionic.Crc.CrcCalculatorStream OpenReader(string password)
-        {
-            // workitem 10923
-            if (_container.ZipFile == null)
-                throw new InvalidOperationException("Use OpenReader() only with ZipFile.");
-
-            return InternalOpenReader(password);
-        }
-
-
-
-        internal Ionic.Crc.CrcCalculatorStream InternalOpenReader(string password)
-        {
-            ValidateCompression();
-            ValidateEncryption();
-            SetupCryptoForExtract(password);
-
-            // workitem 7958
-            if (this._Source != ZipEntrySource.ZipFile)
-                throw new BadStateException("You must call ZipFile.Save before calling OpenReader");
-
-            // LeftToRead is a count of bytes remaining to be read (out)
-            // from the stream AFTER decompression and decryption.
-            // It is the uncompressed size, unless ... there is no compression in which
-            // case ...?  :< I'm not sure why it's not always UncompressedSize
-            Int64 LeftToRead = (_CompressionMethod_FromZipFile == (short)CompressionMethod.None)
-                ? this._CompressedFileDataSize
-                : this.UncompressedSize;
-
-            Stream input = this.ArchiveStream;
-
-            this.ArchiveStream.Seek(this.FileDataPosition, SeekOrigin.Begin);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-
-            _inputDecryptorStream = GetExtractDecryptor(input);
-            Stream input3 = GetExtractDecompressor(_inputDecryptorStream);
-
-            return new Ionic.Crc.CrcCalculatorStream(input3, LeftToRead);
-        }
-
-
-
-        private void OnExtractProgress(Int64 bytesWritten, Int64 totalBytesToWrite)
-        {
-            if (_container.ZipFile != null)
-            _ioOperationCanceled = _container.ZipFile.OnExtractBlock(this, bytesWritten, totalBytesToWrite);
-        }
-
-
-        private void OnBeforeExtract(string path)
-        {
-            // When in the context of a ZipFile.ExtractAll, the events are generated from
-            // the ZipFile method, not from within the ZipEntry instance. (why?)
-            // Therefore we suppress the events originating from the ZipEntry method.
-            if (_container.ZipFile != null)
-            {
-                if (!_container.ZipFile._inExtractAll)
-                {
-                    _ioOperationCanceled = _container.ZipFile.OnSingleEntryExtract(this, path, true);
-                }
-            }
-        }
-
-        private void OnAfterExtract(string path)
-        {
-            // When in the context of a ZipFile.ExtractAll, the events are generated from
-            // the ZipFile method, not from within the ZipEntry instance. (why?)
-            // Therefore we suppress the events originating from the ZipEntry method.
-            if (_container.ZipFile != null)
-            {
-                if (!_container.ZipFile._inExtractAll)
-                {
-                    _container.ZipFile.OnSingleEntryExtract(this, path, false);
-                }
-            }
-        }
-
-        private void OnExtractExisting(string path)
-        {
-            if (_container.ZipFile != null)
-                _ioOperationCanceled = _container.ZipFile.OnExtractExisting(this, path);
-        }
-
-        private static void ReallyDelete(string fileName)
-        {
-            // workitem 7881
-            // reset ReadOnly bit if necessary
-#if NETCF
-            if ( (NetCfFile.GetAttributes(fileName) & (uint)FileAttributes.ReadOnly) == (uint)FileAttributes.ReadOnly)
-                NetCfFile.SetAttributes(fileName, (uint)FileAttributes.Normal);
-#elif SILVERLIGHT
-#else
-            if ((File.GetAttributes(fileName) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
-                File.SetAttributes(fileName, FileAttributes.Normal);
-#endif
-            File.Delete(fileName);
-        }
-
-
-        private void WriteStatus(string format, params Object[] args)
-        {
-            if (_container.ZipFile != null && _container.ZipFile.Verbose) _container.ZipFile.StatusMessageTextWriter.WriteLine(format, args);
-        }
-
-
-        // Pass in either basedir or s, but not both.
-        // In other words, you can extract to a stream or to a directory (filesystem), but not both!
-        // The Password param is required for encrypted entries.
-        private void InternalExtract(string baseDir, Stream outstream, string password)
-        {
-            // workitem 7958
-            if (_container == null)
-                throw new BadStateException("This entry is an orphan");
-
-            // workitem 10355
-            if (_container.ZipFile == null)
-                throw new InvalidOperationException("Use Extract() only with ZipFile.");
-
-            _container.ZipFile.Reset(false);
-
-            if (this._Source != ZipEntrySource.ZipFile)
-                throw new BadStateException("You must call ZipFile.Save before calling any Extract method");
-
-            OnBeforeExtract(baseDir);
-            _ioOperationCanceled = false;
-            string targetFileName = null;
-            Stream output = null;
-            bool fileExistsBeforeExtraction = false;
-            bool checkLaterForResetDirTimes = false;
-            try
-            {
-                ValidateCompression();
-                ValidateEncryption();
-
-                if (ValidateOutput(baseDir, outstream, out targetFileName))
-                {
-                    WriteStatus("extract dir {0}...", targetFileName);
-                    // if true, then the entry was a directory and has been created.
-                    // We need to fire the Extract Event.
-                    OnAfterExtract(baseDir);
-                    return;
-                }
-
-                // workitem 10639
-                // do we want to extract to a regular filesystem file?
-                if (targetFileName != null)
-                {
-                    // Check for extracting to a previously extant file. The user
-                    // can specify bejavior for that case: overwrite, don't
-                    // overwrite, and throw.  Also, if the file exists prior to
-                    // extraction, it affects exception handling: whether to delete
-                    // the target of extraction or not.  This check needs to be done
-                    // before the password check is done, because password check may
-                    // throw a BadPasswordException, which triggers the catch,
-                    // wherein the extant file may be deleted if not flagged as
-                    // pre-existing.
-                    if (File.Exists(targetFileName))
-                    {
-                        fileExistsBeforeExtraction = true;
-                        int rc = CheckExtractExistingFile(baseDir, targetFileName);
-                        if (rc == 2) goto ExitTry; // cancel
-                        if (rc == 1) return; // do not overwrite
-                    }
-                }
-
-                // If no password explicitly specified, use the password on the entry itself,
-                // or on the zipfile itself.
-                string p = password ?? this._Password ?? this._container.Password;
-                if (_Encryption_FromZipFile != EncryptionAlgorithm.None)
-                {
-                    if (p == null)
-                        throw new BadPasswordException();
-                    SetupCryptoForExtract(p);
-                }
-
-
-                // set up the output stream
-                if (targetFileName != null)
-                {
-                    WriteStatus("extract file {0}...", targetFileName);
-                    targetFileName += ".tmp";
-                    var dirName = Path.GetDirectoryName(targetFileName);
-                    // ensure the target path exists
-                    if (!Directory.Exists(dirName))
-                    {
-                        // we create the directory here, but we do not set the
-                        // create/modified/accessed times on it because it is being
-                        // created implicitly, not explcitly. There's no entry in the
-                        // zip archive for the directory.
-                        Directory.CreateDirectory(dirName);
-                    }
-                    else
-                    {
-                        // workitem 8264
-                        if (_container.ZipFile != null)
-                            checkLaterForResetDirTimes = _container.ZipFile._inExtractAll;
-                    }
-
-                    // File.Create(CreateNew) will overwrite any existing file.
-                    output = new FileStream(targetFileName, FileMode.CreateNew);
-                }
-                else
-                {
-                    WriteStatus("extract entry {0} to stream...", FileName);
-                    output = outstream;
-                }
-
-
-                if (_ioOperationCanceled)
-                    goto ExitTry;
-
-                Int32 ActualCrc32 = ExtractOne(output);
-
-                if (_ioOperationCanceled)
-                    goto ExitTry;
-
-                VerifyCrcAfterExtract(ActualCrc32);
-
-                if (targetFileName != null)
-                {
-                    output.Close();
-                    output = null;
-
-                    // workitem 10639
-                    // move file to permanent home
-                    string tmpName = targetFileName;
-                    string zombie = null;
-                    targetFileName = tmpName.Substring(0,tmpName.Length-4);
-
-                    if (fileExistsBeforeExtraction)
-                    {
-                        // An AV program may hold the target file open, which means
-                        // File.Delete() will succeed, though the actual deletion
-                        // remains pending. This will prevent a subsequent
-                        // File.Move() from succeeding. To avoid this, when the file
-                        // already exists, we need to replace it in 3 steps:
-                        //
-                        //     1. rename the existing file to a zombie name;
-                        //     2. rename the extracted file from the temp name to
-                        //        the target file name;
-                        //     3. delete the zombie.
-                        //
-                        zombie = targetFileName + ".PendingOverwrite";
-                        File.Move(targetFileName, zombie);
-                    }
-
-                    File.Move(tmpName, targetFileName);
-                    _SetTimes(targetFileName, true);
-
-                    if (zombie != null && File.Exists(zombie))
-                        ReallyDelete(zombie);
-
-                    // workitem 8264
-                    if (checkLaterForResetDirTimes)
-                    {
-                        // This is sort of a hack.  What I do here is set the time on
-                        // the parent directory, every time a file is extracted into
-                        // it.  If there is a directory with 1000 files, then I set
-                        // the time on the dir, 1000 times. This allows the directory
-                        // to have times that reflect the actual time on the entry in
-                        // the zip archive.
-
-                        // String.Contains is not available on .NET CF 2.0
-                        if (this.FileName.IndexOf('/') != -1)
-                        {
-                            string dirname = Path.GetDirectoryName(this.FileName);
-                            if (this._container.ZipFile[dirname] == null)
-                            {
-                                _SetTimes(Path.GetDirectoryName(targetFileName), false);
-                            }
-                        }
-                    }
-
-#if NETCF
-                    // workitem 7926 - version made by OS can be zero or 10
-                    if ((_VersionMadeBy & 0xFF00) == 0x0a00 || (_VersionMadeBy & 0xFF00) == 0x0000)
-                        NetCfFile.SetAttributes(targetFileName, (uint)_ExternalFileAttrs);
-
-#else
-                    // workitem 7071
-                    //
-                    // We can only apply attributes if they are relevant to the NTFS
-                    // OS.  Must do this LAST because it may involve a ReadOnly bit,
-                    // which would prevent us from setting the time, etc.
-                    //
-                    // workitem 7926 - version made by OS can be zero (FAT) or 10
-                    // (NTFS)
-                    if ((_VersionMadeBy & 0xFF00) == 0x0a00 || (_VersionMadeBy & 0xFF00) == 0x0000)
-                        File.SetAttributes(targetFileName, (FileAttributes)_ExternalFileAttrs);
-#endif
-                }
-
-                OnAfterExtract(baseDir);
-
-                ExitTry: ;
-            }
-            catch (Exception)
-            {
-                _ioOperationCanceled = true;
-                throw;
-            }
-            finally
-            {
-                if (_ioOperationCanceled)
-                {
-                    if (targetFileName != null)
-                    {
-                        try
-                        {
-                            if (output != null) output.Close();
-                            // An exception has occurred. If the file exists, check
-                            // to see if it existed before we tried extracting.  If
-                            // it did not, attempt to remove the target file. There
-                            // is a small possibility that the existing file has
-                            // been extracted successfully, overwriting a previously
-                            // existing file, and an exception was thrown after that
-                            // but before final completion (setting times, etc). In
-                            // that case the file will remain, even though some
-                            // error occurred.  Nothing to be done about it.
-                            if (File.Exists(targetFileName) && !fileExistsBeforeExtraction)
-                                File.Delete(targetFileName);
-
-                        }
-                        finally { }
-                    }
-                }
-            }
-        }
-
-
-#if NOT
-        internal void CalcWinZipAesMac(Stream input)
-        {
-            if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                if (input is WinZipAesCipherStream)
-                    wzs = input as WinZipAesCipherStream;
-
-                else if (input is Ionic.Zlib.CrcCalculatorStream)
-                {
-                    xxx;
-                }
-
-            }
-        }
-#endif
-
-
-        internal void VerifyCrcAfterExtract(Int32 actualCrc32)
-        {
-
-#if AESCRYPTO
-                // After extracting, Validate the CRC32
-                if (actualCrc32 != _Crc32)
-                {
-                    // CRC is not meaningful with WinZipAES and AES method 2 (AE-2)
-                    if ((Encryption != EncryptionAlgorithm.WinZipAes128 &&
-                         Encryption != EncryptionAlgorithm.WinZipAes256)
-                        || _WinZipAesMethod != 0x02)
-                        throw new BadCrcException("CRC error: the file being extracted appears to be corrupted. " +
-                                                  String.Format("Expected 0x{0:X8}, Actual 0x{1:X8}", _Crc32, actualCrc32));
-                }
-
-                // ignore MAC if the size of the file is zero
-                if (this.UncompressedSize == 0)
-                    return;
-
-                // calculate the MAC
-                if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                    Encryption == EncryptionAlgorithm.WinZipAes256)
-                {
-                    WinZipAesCipherStream wzs = _inputDecryptorStream as WinZipAesCipherStream;
-                    _aesCrypto_forExtract.CalculatedMac = wzs.FinalAuthentication;
-
-                    _aesCrypto_forExtract.ReadAndVerifyMac(this.ArchiveStream); // throws if MAC is bad
-                    // side effect: advances file position.
-                }
-
-
-
-
-#else
-            if (actualCrc32 != _Crc32)
-                throw new BadCrcException("CRC error: the file being extracted appears to be corrupted. " +
-                                          String.Format("Expected 0x{0:X8}, Actual 0x{1:X8}", _Crc32, actualCrc32));
-#endif
-        }
-
-
-
-
-        private int CheckExtractExistingFile(string baseDir, string targetFileName)
-        {
-            int loop = 0;
-            // returns: 0 == extract, 1 = don't, 2 = cancel
-            do
-            {
-                switch (ExtractExistingFile)
-                {
-                    case ExtractExistingFileAction.OverwriteSilently:
-                        WriteStatus("the file {0} exists; will overwrite it...", targetFileName);
-                        return 0;
-
-                    case ExtractExistingFileAction.DoNotOverwrite:
-                        WriteStatus("the file {0} exists; not extracting entry...", FileName);
-                        OnAfterExtract(baseDir);
-                        return 1;
-
-                    case ExtractExistingFileAction.InvokeExtractProgressEvent:
-                        if (loop>0)
-                            throw new ZipException(String.Format("The file {0} already exists.", targetFileName));
-                        OnExtractExisting(baseDir);
-                        if (_ioOperationCanceled)
-                            return 2;
-
-                        // loop around
-                        break;
-
-                    case ExtractExistingFileAction.Throw:
-                    default:
-                        throw new ZipException(String.Format("The file {0} already exists.", targetFileName));
-                }
-                loop++;
-            }
-            while (true);
-        }
-
-
-
-
-        private void _CheckRead(int nbytes)
-        {
-            if (nbytes == 0)
-                throw new BadReadException(String.Format("bad read of entry {0} from compressed archive.",
-                             this.FileName));
-        }
-
-
-        private Stream _inputDecryptorStream;
-
-        private Int32 ExtractOne(Stream output)
-        {
-            Int32 CrcResult = 0;
-            Stream input = this.ArchiveStream;
-
-            try
-            {
-                // change for workitem 8098
-                input.Seek(this.FileDataPosition, SeekOrigin.Begin);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(input);
-
-                byte[] bytes = new byte[BufferSize];
-
-                // The extraction process varies depending on how the entry was
-                // stored.  It could have been encrypted, and it coould have
-                // been compressed, or both, or neither. So we need to check
-                // both the encryption flag and the compression flag, and take
-                // the proper action in all cases.
-
-                Int64 LeftToRead = (_CompressionMethod_FromZipFile != (short)CompressionMethod.None)
-                    ? this.UncompressedSize
-                    : this._CompressedFileDataSize;
-
-                // Get a stream that either decrypts or not.
-                _inputDecryptorStream = GetExtractDecryptor(input);
-
-                Stream input3 = GetExtractDecompressor( _inputDecryptorStream );
-
-                Int64 bytesWritten = 0;
-                // As we read, we maybe decrypt, and then we maybe decompress. Then we write.
-                using (var s1 = new Ionic.Crc.CrcCalculatorStream(input3))
-                {
-                    while (LeftToRead > 0)
-                    {
-                        //Console.WriteLine("ExtractOne: LeftToRead {0}", LeftToRead);
-
-                        // Casting LeftToRead down to an int is ok here in the else clause,
-                        // because that only happens when it is less than bytes.Length,
-                        // which is much less than MAX_INT.
-                        int len = (LeftToRead > bytes.Length) ? bytes.Length : (int)LeftToRead;
-                        int n = s1.Read(bytes, 0, len);
-
-                        // must check data read - essential for detecting corrupt zip files
-                        _CheckRead(n);
-
-                        output.Write(bytes, 0, n);
-                        LeftToRead -= n;
-                        bytesWritten += n;
-
-                        // fire the progress event, check for cancels
-                        OnExtractProgress(bytesWritten, UncompressedSize);
-                        if (_ioOperationCanceled)
-                        {
-                            break;
-                        }
-                    }
-
-                    CrcResult = s1.Crc;
-                }
-            }
-            finally
-            {
-                var zss = input as ZipSegmentedStream;
-                if (zss != null)
-                {
-#if NETCF
-                    zss.Close();
-#else
-                    // need to dispose it
-                    zss.Dispose();
-#endif
-                    _archiveStream = null;
-                }
-            }
-
-            return CrcResult;
-        }
-
-
-
-        internal Stream GetExtractDecompressor(Stream input2)
-        {
-            // get a stream that either decompresses or not.
-            switch (_CompressionMethod_FromZipFile)
-            {
-                case (short)CompressionMethod.None:
-                    return input2;
-                case (short)CompressionMethod.Deflate:
-                    return new Ionic.Zlib.DeflateStream(input2, Ionic.Zlib.CompressionMode.Decompress, true);
-#if BZIP
-                case (short)CompressionMethod.BZip2:
-                    return new Ionic.BZip2.BZip2InputStream(input2, true);
-#endif
-            }
-
-            return null;
-        }
-
-
-
-        internal Stream GetExtractDecryptor(Stream input)
-        {
-            Stream input2 = null;
-            if (_Encryption_FromZipFile == EncryptionAlgorithm.PkzipWeak)
-                input2 = new ZipCipherStream(input, _zipCrypto_forExtract, CryptoMode.Decrypt);
-
-#if AESCRYPTO
-            else if (_Encryption_FromZipFile == EncryptionAlgorithm.WinZipAes128 ||
-                 _Encryption_FromZipFile == EncryptionAlgorithm.WinZipAes256)
-                input2 = new WinZipAesCipherStream(input, _aesCrypto_forExtract, _CompressedFileDataSize, CryptoMode.Decrypt);
-#endif
-
-            else
-                input2 = input;
-
-            return input2;
-        }
-
-
-
-
-        internal void _SetTimes(string fileOrDirectory, bool isFile)
-        {
-#if SILVERLIGHT
-                    // punt on setting file times
-#else
-            // workitem 8807:
-            // Because setting the time is not considered to be a fatal error,
-            // and because other applications can interfere with the setting
-            // of a time on a directory, we're going to swallow IO exceptions
-            // in this method.
-
-            try
-            {
-                if (_ntfsTimesAreSet)
-                {
-#if NETCF
-                    // workitem 7944: set time should not be a fatal error on CF
-                    int rc = NetCfFile.SetTimes(fileOrDirectory, _Ctime, _Atime, _Mtime);
-                    if ( rc != 0)
-                    {
-                        WriteStatus("Warning: SetTimes failed.  entry({0})  file({1})  rc({2})",
-                                    FileName, fileOrDirectory, rc);
-                    }
-#else
-                    if (isFile)
-                    {
-                        // It's possible that the extract was cancelled, in which case,
-                        // the file does not exist.
-                        if (File.Exists(fileOrDirectory))
-                        {
-                            File.SetCreationTimeUtc(fileOrDirectory, _Ctime);
-                            File.SetLastAccessTimeUtc(fileOrDirectory, _Atime);
-                            File.SetLastWriteTimeUtc(fileOrDirectory, _Mtime);
-                        }
-                    }
-                    else
-                    {
-                        // It's possible that the extract was cancelled, in which case,
-                        // the directory does not exist.
-                        if (Directory.Exists(fileOrDirectory))
-                        {
-                            Directory.SetCreationTimeUtc(fileOrDirectory, _Ctime);
-                            Directory.SetLastAccessTimeUtc(fileOrDirectory, _Atime);
-                            Directory.SetLastWriteTimeUtc(fileOrDirectory, _Mtime);
-                        }
-                    }
-#endif
-                }
-                else
-                {
-                    // workitem 6191
-                    DateTime AdjustedLastModified = Ionic.Zip.SharedUtilities.AdjustTime_Reverse(LastModified);
-
-#if NETCF
-                    int rc = NetCfFile.SetLastWriteTime(fileOrDirectory, AdjustedLastModified);
-
-                    if ( rc != 0)
-                    {
-                        WriteStatus("Warning: SetLastWriteTime failed.  entry({0})  file({1})  rc({2})",
-                                    FileName, fileOrDirectory, rc);
-                    }
-#else
-                    if (isFile)
-                        File.SetLastWriteTime(fileOrDirectory, AdjustedLastModified);
-                    else
-                        Directory.SetLastWriteTime(fileOrDirectory, AdjustedLastModified);
-#endif
-                }
-            }
-            catch (System.IO.IOException ioexc1)
-            {
-                WriteStatus("failed to set time on {0}: {1}", fileOrDirectory, ioexc1.Message);
-            }
-#endif
-        }
-
-
-        #region Support methods
-
-
-        // workitem 7968
-        private string UnsupportedAlgorithm
-        {
-            get
-            {
-                string alg = String.Empty;
-                switch (_UnsupportedAlgorithmId)
-                {
-                    case 0:
-                        alg = "--";
-                        break;
-                    case 0x6601:
-                        alg = "DES";
-                        break;
-                    case 0x6602: // - RC2 (version needed to extract < 5.2)
-                        alg = "RC2";
-                        break;
-                    case 0x6603: // - 3DES 168
-                        alg = "3DES-168";
-                        break;
-                    case 0x6609: // - 3DES 112
-                        alg = "3DES-112";
-                        break;
-                    case 0x660E: // - AES 128
-                        alg = "PKWare AES128";
-                        break;
-                    case 0x660F: // - AES 192
-                        alg = "PKWare AES192";
-                        break;
-                    case 0x6610: // - AES 256
-                        alg = "PKWare AES256";
-                        break;
-                    case 0x6702: // - RC2 (version needed to extract >= 5.2)
-                        alg = "RC2";
-                        break;
-                    case 0x6720: // - Blowfish
-                        alg = "Blowfish";
-                        break;
-                    case 0x6721: // - Twofish
-                        alg = "Twofish";
-                        break;
-                    case 0x6801: // - RC4
-                        alg = "RC4";
-                        break;
-                    case 0xFFFF: // - Unknown algorithm
-                    default:
-                        alg = String.Format("Unknown (0x{0:X4})", _UnsupportedAlgorithmId);
-                        break;
-                }
-                return alg;
-            }
-        }
-
-        // workitem 7968
-        private string UnsupportedCompressionMethod
-        {
-            get
-            {
-                string meth = String.Empty;
-                switch ((int)_CompressionMethod)
-                {
-                    case 0:
-                        meth = "Store";
-                        break;
-                    case 1:
-                        meth = "Shrink";
-                        break;
-                    case 8:
-                        meth = "DEFLATE";
-                        break;
-                    case 9:
-                        meth = "Deflate64";
-                        break;
-                    case 12:
-                        meth = "BZIP2"; // only if BZIP not compiled in
-                        break;
-                    case 14:
-                        meth = "LZMA";
-                        break;
-                    case 19:
-                        meth = "LZ77";
-                        break;
-                    case 98:
-                        meth = "PPMd";
-                        break;
-                    default:
-                        meth = String.Format("Unknown (0x{0:X4})", _CompressionMethod);
-                        break;
-                }
-                return meth;
-            }
-        }
-
-
-        internal void ValidateEncryption()
-        {
-            if (Encryption != EncryptionAlgorithm.PkzipWeak &&
-#if AESCRYPTO
- Encryption != EncryptionAlgorithm.WinZipAes128 &&
-                Encryption != EncryptionAlgorithm.WinZipAes256 &&
-#endif
- Encryption != EncryptionAlgorithm.None)
-            {
-                // workitem 7968
-                if (_UnsupportedAlgorithmId != 0)
-                    throw new ZipException(String.Format("Cannot extract: Entry {0} is encrypted with an algorithm not supported by DotNetZip: {1}",
-                                                         FileName, UnsupportedAlgorithm));
-                else
-                    throw new ZipException(String.Format("Cannot extract: Entry {0} uses an unsupported encryption algorithm ({1:X2})",
-                                                         FileName, (int)Encryption));
-            }
-        }
-
-
-        private void ValidateCompression()
-        {
-            if ((_CompressionMethod_FromZipFile != (short)CompressionMethod.None) &&
-                (_CompressionMethod_FromZipFile != (short)CompressionMethod.Deflate)
-#if BZIP
-                && (_CompressionMethod_FromZipFile != (short)CompressionMethod.BZip2)
-#endif
-                )
-                throw new ZipException(String.Format("Entry {0} uses an unsupported compression method (0x{1:X2}, {2})",
-                                                          FileName, _CompressionMethod_FromZipFile, UnsupportedCompressionMethod));
-        }
-
-
-        private void SetupCryptoForExtract(string password)
-        {
-            //if (password == null) return;
-            if (_Encryption_FromZipFile == EncryptionAlgorithm.None) return;
-
-            if (_Encryption_FromZipFile == EncryptionAlgorithm.PkzipWeak)
-            {
-                if (password == null)
-                    throw new ZipException("Missing password.");
-
-                this.ArchiveStream.Seek(this.FileDataPosition - 12, SeekOrigin.Begin);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-                _zipCrypto_forExtract = ZipCrypto.ForRead(password, this);
-            }
-
-#if AESCRYPTO
-            else if (_Encryption_FromZipFile == EncryptionAlgorithm.WinZipAes128 ||
-                 _Encryption_FromZipFile == EncryptionAlgorithm.WinZipAes256)
-            {
-                if (password == null)
-                    throw new ZipException("Missing password.");
-
-                // If we already have a WinZipAesCrypto object in place, use it.
-                // It can be set up in the ReadDirEntry(), or during a previous Extract.
-                if (_aesCrypto_forExtract != null)
-                {
-                    _aesCrypto_forExtract.Password = password;
-                }
-                else
-                {
-                    int sizeOfSaltAndPv = GetLengthOfCryptoHeaderBytes(_Encryption_FromZipFile);
-                    this.ArchiveStream.Seek(this.FileDataPosition - sizeOfSaltAndPv, SeekOrigin.Begin);
-                    // workitem 10178
-                    Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-                    int keystrength = GetKeyStrengthInBits(_Encryption_FromZipFile);
-                    _aesCrypto_forExtract = WinZipAesCrypto.ReadFromStream(password, keystrength, this.ArchiveStream);
-                }
-            }
-#endif
-        }
-
-
-
-        /// <summary>
-        /// Validates that the args are consistent.
-        /// </summary>
-        /// <remarks>
-        /// Only one of {baseDir, outStream} can be non-null.
-        /// If baseDir is non-null, then the outputFile is created.
-        /// </remarks>
-        private bool ValidateOutput(string basedir, Stream outstream, out string outFileName)
-        {
-            if (basedir != null)
-            {
-                // Sometimes the name on the entry starts with a slash.
-                // Rather than unpack to the root of the volume, we're going to
-                // drop the slash and unpack to the specified base directory.
-                string f = this.FileName.Replace("\\","/");
-
-                // workitem 11772: remove drive letter with separator
-                if (f.IndexOf(':') == 1)
-                    f= f.Substring(2);
-
-                if (f.StartsWith("/"))
-                    f= f.Substring(1);
-
-                // String.Contains is not available on .NET CF 2.0
-
-                if (_container.ZipFile.FlattenFoldersOnExtract)
-                    outFileName = Path.Combine(basedir,
-                                              (f.IndexOf('/') != -1) ? Path.GetFileName(f) : f);
-                else
-                    outFileName = Path.Combine(basedir, f);
-
-                // workitem 10639
-                outFileName = outFileName.Replace("/","\\");
-
-                // check if it is a directory
-                if ((IsDirectory) || (FileName.EndsWith("/")))
-                {
-                    if (!Directory.Exists(outFileName))
-                    {
-                        Directory.CreateDirectory(outFileName);
-                        _SetTimes(outFileName, false);
-                    }
-                    else
-                    {
-                        // the dir exists, maybe we want to overwrite times.
-                        if (ExtractExistingFile == ExtractExistingFileAction.OverwriteSilently)
-                            _SetTimes(outFileName, false);
-                    }
-                    return true;  // true == all done, caller will return
-                }
-                return false;  // false == work to do by caller.
-            }
-
-            if (outstream != null)
-            {
-                outFileName = null;
-                if ((IsDirectory) || (FileName.EndsWith("/")))
-                {
-                    // extract a directory to streamwriter?  nothing to do!
-                    return true;  // true == all done!  caller can return
-                }
-                return false;
-            }
-
-            throw new ArgumentNullException("outstream");
-        }
-
-
-        #endregion
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipEntry.Read.cs b/EPPlus/Packaging/DotNetZip/ZipEntry.Read.cs
deleted file mode 100644
index 46a69eb..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipEntry.Read.cs
+++ /dev/null
@@ -1,798 +0,0 @@
-// ZipEntry.Read.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-09 21:31:28>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for Reading the ZipEntry from a
-// zip file.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal partial class ZipEntry
-    {
-        private int _readExtraDepth;
-        private void ReadExtraField()
-        {
-            _readExtraDepth++;
-            // workitem 8098: ok (restore)
-            long posn = this.ArchiveStream.Position;
-            this.ArchiveStream.Seek(this._RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-
-            byte[] block = new byte[30];
-            this.ArchiveStream.Read(block, 0, block.Length);
-            int i = 26;
-            Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
-            Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
-
-            // workitem 8098: ok (relative)
-            this.ArchiveStream.Seek(filenameLength, SeekOrigin.Current);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-
-            ProcessExtraField(this.ArchiveStream, extraFieldLength);
-
-            // workitem 8098: ok (restore)
-            this.ArchiveStream.Seek(posn, SeekOrigin.Begin);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-            _readExtraDepth--;
-        }
-
-
-        private static bool ReadHeader(ZipEntry ze, System.Text.Encoding defaultEncoding)
-        {
-            int bytesRead = 0;
-
-            // change for workitem 8098
-            ze._RelativeOffsetOfLocalHeader = ze.ArchiveStream.Position;
-
-            int signature = Ionic.Zip.SharedUtilities.ReadEntrySignature(ze.ArchiveStream);
-            bytesRead += 4;
-
-            // Return false if this is not a local file header signature.
-            if (ZipEntry.IsNotValidSig(signature))
-            {
-                // Getting "not a ZipEntry signature" is not always wrong or an error.
-                // This will happen after the last entry in a zipfile.  In that case, we
-                // expect to read :
-                //    a ZipDirEntry signature (if a non-empty zip file) or
-                //    a ZipConstants.EndOfCentralDirectorySignature.
-                //
-                // Anything else is a surprise.
-
-                ze.ArchiveStream.Seek(-4, SeekOrigin.Current); // unread the signature
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(ze.ArchiveStream);
-                if (ZipEntry.IsNotValidZipDirEntrySig(signature) && (signature != ZipConstants.EndOfCentralDirectorySignature))
-                {
-                    throw new BadReadException(String.Format("  Bad signature (0x{0:X8}) at position  0x{1:X8}", signature, ze.ArchiveStream.Position));
-                }
-                return false;
-            }
-
-            byte[] block = new byte[26];
-            int n = ze.ArchiveStream.Read(block, 0, block.Length);
-            if (n != block.Length) return false;
-            bytesRead += n;
-
-            int i = 0;
-            ze._VersionNeeded = (Int16)(block[i++] + block[i++] * 256);
-            ze._BitField = (Int16)(block[i++] + block[i++] * 256);
-            ze._CompressionMethod_FromZipFile = ze._CompressionMethod = (Int16)(block[i++] + block[i++] * 256);
-            ze._TimeBlob = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
-            // transform the time data into something usable (a DateTime)
-            ze._LastModified = Ionic.Zip.SharedUtilities.PackedToDateTime(ze._TimeBlob);
-            ze._timestamp |= ZipEntryTimestamp.DOS;
-
-            if ((ze._BitField & 0x01) == 0x01)
-            {
-                ze._Encryption_FromZipFile = ze._Encryption = EncryptionAlgorithm.PkzipWeak; // this *may* change after processing the Extra field
-                ze._sourceIsEncrypted = true;
-            }
-
-            // NB: if ((ze._BitField & 0x0008) != 0x0008), then the Compressed, uncompressed and
-            // CRC values are not true values; the true values will follow the entry data.
-            // But, regardless of the status of bit 3 in the bitfield, the slots for
-            // the three amigos may contain marker values for ZIP64.  So we must read them.
-            {
-                ze._Crc32 = (Int32)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                ze._CompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                ze._UncompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-
-                if ((uint)ze._CompressedSize == 0xFFFFFFFF ||
-                    (uint)ze._UncompressedSize == 0xFFFFFFFF)
-
-                    ze._InputUsesZip64 = true;
-            }
-
-            Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
-            Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
-
-            block = new byte[filenameLength];
-            n = ze.ArchiveStream.Read(block, 0, block.Length);
-            bytesRead += n;
-
-            // if the UTF8 bit is set for this entry, override the
-            // encoding the application requested.
-
-            if ((ze._BitField & 0x0800) == 0x0800)
-            {
-                // workitem 12744
-                ze.AlternateEncoding = System.Text.Encoding.UTF8;
-                ze.AlternateEncodingUsage = ZipOption.Always;
-            }
-
-            // need to use this form of GetString() for .NET CF
-            ze._FileNameInArchive = ze.AlternateEncoding.GetString(block, 0, block.Length);
-
-            // workitem 6898
-            if (ze._FileNameInArchive.EndsWith("/")) ze.MarkAsDirectory();
-
-            bytesRead += ze.ProcessExtraField(ze.ArchiveStream, extraFieldLength);
-
-            ze._LengthOfTrailer = 0;
-
-            // workitem 6607 - don't read for directories
-            // actually get the compressed size and CRC if necessary
-            if (!ze._FileNameInArchive.EndsWith("/") && (ze._BitField & 0x0008) == 0x0008)
-            {
-                // This descriptor exists only if bit 3 of the general
-                // purpose bit flag is set (see below).  It is byte aligned
-                // and immediately follows the last byte of compressed data,
-                // as well as any encryption trailer, as with AES.
-                // This descriptor is used only when it was not possible to
-                // seek in the output .ZIP file, e.g., when the output .ZIP file
-                // was standard output or a non-seekable device.  For ZIP64(tm) format
-                // archives, the compressed and uncompressed sizes are 8 bytes each.
-
-                // workitem 8098: ok (restore)
-                long posn = ze.ArchiveStream.Position;
-
-                // Here, we're going to loop until we find a ZipEntryDataDescriptorSignature and
-                // a consistent data record after that.   To be consistent, the data record must
-                // indicate the length of the entry data.
-                bool wantMore = true;
-                long SizeOfDataRead = 0;
-                int tries = 0;
-                while (wantMore)
-                {
-                    tries++;
-                    // We call the FindSignature shared routine to find the specified signature
-                    // in the already-opened zip archive, starting from the current cursor
-                    // position in that filestream.  If we cannot find the signature, then the
-                    // routine returns -1, and the ReadHeader() method returns false,
-                    // indicating we cannot read a legal entry header.  If we have found it,
-                    // then the FindSignature() method returns the number of bytes in the
-                    // stream we had to seek forward, to find the sig.  We need this to
-                    // determine if the zip entry is valid, later.
-
-                    if (ze._container.ZipFile != null)
-                        ze._container.ZipFile.OnReadBytes(ze);
-
-                    long d = Ionic.Zip.SharedUtilities.FindSignature(ze.ArchiveStream, ZipConstants.ZipEntryDataDescriptorSignature);
-                    if (d == -1) return false;
-
-                    // total size of data read (through all loops of this).
-                    SizeOfDataRead += d;
-
-                    if (ze._InputUsesZip64)
-                    {
-                        // read 1x 4-byte (CRC) and 2x 8-bytes (Compressed Size, Uncompressed Size)
-                        block = new byte[20];
-                        n = ze.ArchiveStream.Read(block, 0, block.Length);
-                        if (n != 20) return false;
-
-                        // do not increment bytesRead - it is for entry header only.
-                        // the data we have just read is a footer (falls after the file data)
-                        //bytesRead += n;
-
-                        i = 0;
-                        ze._Crc32 = (Int32)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                        ze._CompressedSize = BitConverter.ToInt64(block, i);
-                        i += 8;
-                        ze._UncompressedSize = BitConverter.ToInt64(block, i);
-                        i += 8;
-
-                        ze._LengthOfTrailer = 24;  // bytes including sig, CRC, Comp and Uncomp sizes
-                    }
-                    else
-                    {
-                        // read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size)
-                        block = new byte[12];
-                        n = ze.ArchiveStream.Read(block, 0, block.Length);
-                        if (n != 12) return false;
-
-                        // do not increment bytesRead - it is for entry header only.
-                        // the data we have just read is a footer (falls after the file data)
-                        //bytesRead += n;
-
-                        i = 0;
-                        ze._Crc32 = (Int32)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                        ze._CompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-                        ze._UncompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256);
-
-                        ze._LengthOfTrailer = 16;  // bytes including sig, CRC, Comp and Uncomp sizes
-
-                    }
-
-                    wantMore = (SizeOfDataRead != ze._CompressedSize);
-
-                    if (wantMore)
-                    {
-                        // Seek back to un-read the last 12 bytes  - maybe THEY contain
-                        // the ZipEntryDataDescriptorSignature.
-                        // (12 bytes for the CRC, Comp and Uncomp size.)
-                        ze.ArchiveStream.Seek(-12, SeekOrigin.Current);
-                        // workitem 10178
-                        Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(ze.ArchiveStream);
-
-                        // Adjust the size to account for the false signature read in
-                        // FindSignature().
-                        SizeOfDataRead += 4;
-                    }
-                }
-
-                // seek back to previous position, to prepare to read file data
-                // workitem 8098: ok (restore)
-                ze.ArchiveStream.Seek(posn, SeekOrigin.Begin);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(ze.ArchiveStream);
-            }
-
-            ze._CompressedFileDataSize = ze._CompressedSize;
-
-
-            // bit 0 set indicates that some kind of encryption is in use
-            if ((ze._BitField & 0x01) == 0x01)
-            {
-#if AESCRYPTO
-                if (ze.Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                    ze.Encryption == EncryptionAlgorithm.WinZipAes256)
-                {
-                    int bits = ZipEntry.GetKeyStrengthInBits(ze._Encryption_FromZipFile);
-                    // read in the WinZip AES metadata: salt + PV. 18 bytes for AES256. 10 bytes for AES128.
-                    ze._aesCrypto_forExtract = WinZipAesCrypto.ReadFromStream(null, bits, ze.ArchiveStream);
-                    bytesRead += ze._aesCrypto_forExtract.SizeOfEncryptionMetadata - 10; // MAC (follows crypto bytes)
-                    // according to WinZip, the CompressedSize includes the AES Crypto framing data.
-                    ze._CompressedFileDataSize -= ze._aesCrypto_forExtract.SizeOfEncryptionMetadata;
-                    ze._LengthOfTrailer += 10;  // MAC
-                }
-                else
-#endif
-                {
-                    // read in the header data for "weak" encryption
-                    ze._WeakEncryptionHeader = new byte[12];
-                    bytesRead += ZipEntry.ReadWeakEncryptionHeader(ze._archiveStream, ze._WeakEncryptionHeader);
-                    // decrease the filedata size by 12 bytes
-                    ze._CompressedFileDataSize -= 12;
-                }
-            }
-
-            // Remember the size of the blob for this entry.
-            // We also have the starting position in the stream for this entry.
-            ze._LengthOfHeader = bytesRead;
-            ze._TotalEntrySize = ze._LengthOfHeader + ze._CompressedFileDataSize + ze._LengthOfTrailer;
-
-
-            // We've read in the regular entry header, the extra field, and any
-            // encryption header.  The pointer in the file is now at the start of the
-            // filedata, which is potentially compressed and encrypted.  Just ahead in
-            // the file, there are _CompressedFileDataSize bytes of data, followed by
-            // potentially a non-zero length trailer, consisting of optionally, some
-            // encryption stuff (10 byte MAC for AES), and the bit-3 trailer (16 or 24
-            // bytes).
-
-            return true;
-        }
-
-
-
-        internal static int ReadWeakEncryptionHeader(Stream s, byte[] buffer)
-        {
-            // PKZIP encrypts the compressed data stream.  Encrypted files must
-            // be decrypted before they can be extracted.
-
-            // Each PKZIP-encrypted file has an extra 12 bytes stored at the start of the data
-            // area defining the encryption header for that file.  The encryption header is
-            // originally set to random values, and then itself encrypted, using three, 32-bit
-            // keys.  The key values are initialized using the supplied encryption password.
-            // After each byte is encrypted, the keys are then updated using pseudo-random
-            // number generation techniques in combination with the same CRC-32 algorithm used
-            // in PKZIP and implemented in the CRC32.cs module in this project.
-
-            // read the 12-byte encryption header
-            int additionalBytesRead = s.Read(buffer, 0, 12);
-            if (additionalBytesRead != 12)
-                throw new ZipException(String.Format("Unexpected end of data at position 0x{0:X8}", s.Position));
-
-            return additionalBytesRead;
-        }
-
-
-
-        private static bool IsNotValidSig(int signature)
-        {
-            return (signature != ZipConstants.ZipEntrySignature);
-        }
-
-
-        /// <summary>
-        ///   Reads one <c>ZipEntry</c> from the given stream.  The content for
-        ///   the entry does not get decompressed or decrypted.  This method
-        ///   basically reads metadata, and seeks.
-        /// </summary>
-        /// <param name="zc">the ZipContainer this entry belongs to.</param>
-        /// <param name="first">
-        ///   true of this is the first entry being read from the stream.
-        /// </param>
-        /// <returns>the <c>ZipEntry</c> read from the stream.</returns>
-        internal static ZipEntry ReadEntry(ZipContainer zc, bool first)
-        {
-            ZipFile zf = zc.ZipFile;
-            Stream s = zc.ReadStream;
-            System.Text.Encoding defaultEncoding = zc.AlternateEncoding;
-            ZipEntry entry = new ZipEntry();
-            entry._Source = ZipEntrySource.ZipFile;
-            entry._container = zc;
-            entry._archiveStream = s;
-            if (zf != null)
-                zf.OnReadEntry(true, null);
-
-            if (first) HandlePK00Prefix(s);
-
-            // Read entry header, including any encryption header
-            if (!ReadHeader(entry, defaultEncoding)) return null;
-
-            // Store the position in the stream for this entry
-            // change for workitem 8098
-            entry.__FileDataPosition = entry.ArchiveStream.Position;
-
-            // seek past the data without reading it. We will read on Extract()
-            s.Seek(entry._CompressedFileDataSize + entry._LengthOfTrailer, SeekOrigin.Current);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-
-            // ReadHeader moves the file pointer to the end of the entry header,
-            // as well as any encryption header.
-
-            // CompressedFileDataSize includes:
-            //   the maybe compressed, maybe encrypted file data
-            //   the encryption trailer, if any
-            //   the bit 3 descriptor, if any
-
-            // workitem 5306
-            // http://www.codeplex.com/DotNetZip/WorkItem/View.aspx?WorkItemId=5306
-            HandleUnexpectedDataDescriptor(entry);
-
-            if (zf != null)
-            {
-                zf.OnReadBytes(entry);
-                zf.OnReadEntry(false, entry);
-            }
-
-            return entry;
-        }
-
-
-        internal static void HandlePK00Prefix(Stream s)
-        {
-            // in some cases, the zip file begins with "PK00".  This is a throwback and is rare,
-            // but we handle it anyway. We do not change behavior based on it.
-            uint datum = (uint)Ionic.Zip.SharedUtilities.ReadInt(s);
-            if (datum != ZipConstants.PackedToRemovableMedia)
-            {
-                s.Seek(-4, SeekOrigin.Current); // unread the block
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-            }
-        }
-
-
-
-        private static void HandleUnexpectedDataDescriptor(ZipEntry entry)
-        {
-            Stream s = entry.ArchiveStream;
-
-            // In some cases, the "data descriptor" is present, without a signature, even when
-            // bit 3 of the BitField is NOT SET.  This is the CRC, followed
-            //    by the compressed length and the uncompressed length (4 bytes for each
-            //    of those three elements).  Need to check that here.
-            //
-            uint datum = (uint)Ionic.Zip.SharedUtilities.ReadInt(s);
-            if (datum == entry._Crc32)
-            {
-                int sz = Ionic.Zip.SharedUtilities.ReadInt(s);
-                if (sz == entry._CompressedSize)
-                {
-                    sz = Ionic.Zip.SharedUtilities.ReadInt(s);
-                    if (sz == entry._UncompressedSize)
-                    {
-                        // ignore everything and discard it.
-                    }
-                    else
-                    {
-                        s.Seek(-12, SeekOrigin.Current); // unread the three blocks
-
-                        // workitem 10178
-                        Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-                    }
-                }
-                else
-                {
-                    s.Seek(-8, SeekOrigin.Current); // unread the two blocks
-
-                    // workitem 10178
-                    Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-                }
-            }
-            else
-            {
-                s.Seek(-4, SeekOrigin.Current); // unread the block
-
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-            }
-        }
-
-
-        /// <summary>
-        ///   Finds a particular segment in the given extra field.
-        ///   This is used when modifying a previously-generated
-        ///   extra field, in particular when removing the AES crypto
-        ///   segment in the extra field.
-        /// </summary>
-        static internal int FindExtraFieldSegment(byte[] extra, int offx, UInt16 targetHeaderId)
-        {
-            int j = offx;
-            while (j + 3 < extra.Length)
-            {
-                UInt16 headerId = (UInt16)(extra[j++] + extra[j++] * 256);
-                if (headerId == targetHeaderId) return j-2;
-
-                // else advance to next segment
-                Int16 dataSize = (short)(extra[j++] + extra[j++] * 256);
-                j+= dataSize;
-            }
-
-            return -1;
-        }
-
-
-        /// <summary>
-        ///   At current cursor position in the stream, read the extra
-        ///   field, and set the properties on the ZipEntry instance
-        ///   appropriately.  This can be called when processing the
-        ///   Extra field in the Central Directory, or in the local
-        ///   header.
-        /// </summary>
-        internal int ProcessExtraField(Stream s, Int16 extraFieldLength)
-        {
-            int additionalBytesRead = 0;
-            if (extraFieldLength > 0)
-            {
-                byte[] buffer = this._Extra = new byte[extraFieldLength];
-                additionalBytesRead = s.Read(buffer, 0, buffer.Length);
-                long posn = s.Position - additionalBytesRead;
-                int j = 0;
-                while (j + 3 < buffer.Length)
-                {
-                    int start = j;
-                    UInt16 headerId = (UInt16)(buffer[j++] + buffer[j++] * 256);
-                    Int16 dataSize = (short)(buffer[j++] + buffer[j++] * 256);
-
-                    switch (headerId)
-                    {
-                        case 0x000a:  // NTFS ctime, atime, mtime
-                            j = ProcessExtraFieldWindowsTimes(buffer, j, dataSize, posn);
-                            break;
-
-                        case 0x5455:  // Unix ctime, atime, mtime
-                            j = ProcessExtraFieldUnixTimes(buffer, j, dataSize, posn);
-                            break;
-
-                        case 0x5855:  // Info-zip Extra field (outdated)
-                            // This is outdated, so the field is supported on
-                            // read only.
-                            j = ProcessExtraFieldInfoZipTimes(buffer, j, dataSize, posn);
-                            break;
-
-                        case 0x7855:  // Unix uid/gid
-                            // ignored. DotNetZip does not handle this field.
-                            break;
-
-                        case 0x7875:  // ??
-                            // ignored.  I could not find documentation on this field,
-                            // though it appears in some zip files.
-                            break;
-
-                        case 0x0001: // ZIP64
-                            j = ProcessExtraFieldZip64(buffer, j, dataSize, posn);
-                            break;
-
-#if AESCRYPTO
-                        case 0x9901: // WinZip AES encryption is in use.  (workitem 6834)
-                            // we will handle this extra field only  if compressionmethod is 0x63
-                            j = ProcessExtraFieldWinZipAes(buffer, j, dataSize, posn);
-                            break;
-#endif
-                        case 0x0017: // workitem 7968: handle PKWare Strong encryption header
-                            j = ProcessExtraFieldPkwareStrongEncryption(buffer, j);
-                            break;
-                    }
-
-                    // move to the next Header in the extra field
-                    j = start + dataSize + 4;
-                }
-            }
-            return additionalBytesRead;
-        }
-
-        private int ProcessExtraFieldPkwareStrongEncryption(byte[] Buffer, int j)
-        {
-            //           Value     Size     Description
-            //           -----     ----     -----------
-            //           0x0017    2 bytes  Tag for this "extra" block type
-            //           TSize     2 bytes  Size of data that follows
-            //           Format    2 bytes  Format definition for this record
-            //           AlgID     2 bytes  Encryption algorithm identifier
-            //           Bitlen    2 bytes  Bit length of encryption key
-            //           Flags     2 bytes  Processing flags
-            //           CertData  TSize-8  Certificate decryption extra field data
-            //                              (refer to the explanation for CertData
-            //                               in the section describing the
-            //                               Certificate Processing Method under
-            //                               the Strong Encryption Specification)
-
-            j += 2;
-            _UnsupportedAlgorithmId = (UInt16)(Buffer[j++] + Buffer[j++] * 256);
-            _Encryption_FromZipFile = _Encryption = EncryptionAlgorithm.Unsupported;
-
-            // DotNetZip doesn't support this algorithm, but we don't need to throw
-            // here.  we might just be reading the archive, which is fine.  We'll
-            // need to throw if Extract() is called.
-
-            return j;
-        }
-
-
-#if AESCRYPTO
-        private int ProcessExtraFieldWinZipAes(byte[] buffer, int j, Int16 dataSize, long posn)
-        {
-            if (this._CompressionMethod == 0x0063)
-            {
-                if ((this._BitField & 0x01) != 0x01)
-                    throw new BadReadException(String.Format("  Inconsistent metadata at position 0x{0:X16}", posn));
-
-                this._sourceIsEncrypted = true;
-
-                //this._aesCrypto = new WinZipAesCrypto(this);
-                // see spec at http://www.winzip.com/aes_info.htm
-                if (dataSize != 7)
-                    throw new BadReadException(String.Format("  Inconsistent size (0x{0:X4}) in WinZip AES field at position 0x{1:X16}", dataSize, posn));
-
-                this._WinZipAesMethod = BitConverter.ToInt16(buffer, j);
-                j += 2;
-                if (this._WinZipAesMethod != 0x01 && this._WinZipAesMethod != 0x02)
-                    throw new BadReadException(String.Format("  Unexpected vendor version number (0x{0:X4}) for WinZip AES metadata at position 0x{1:X16}",
-                        this._WinZipAesMethod, posn));
-
-                Int16 vendorId = BitConverter.ToInt16(buffer, j);
-                j += 2;
-                if (vendorId != 0x4541)
-                    throw new BadReadException(String.Format("  Unexpected vendor ID (0x{0:X4}) for WinZip AES metadata at position 0x{1:X16}", vendorId, posn));
-
-                int keystrength = (buffer[j] == 1) ? 128 : (buffer[j] == 3) ? 256 : -1;
-                if (keystrength < 0)
-                    throw new BadReadException(String.Format("Invalid key strength ({0})", keystrength));
-
-                _Encryption_FromZipFile = this._Encryption = (keystrength == 128)
-                    ? EncryptionAlgorithm.WinZipAes128
-                    : EncryptionAlgorithm.WinZipAes256;
-
-                j++;
-
-                // set the actual compression method
-                this._CompressionMethod_FromZipFile =
-                this._CompressionMethod = BitConverter.ToInt16(buffer, j);
-                j += 2; // for the next segment of the extra field
-            }
-            return j;
-        }
-
-#endif
-
-        private delegate T Func<T>();
-
-        private int ProcessExtraFieldZip64(byte[] buffer, int j, Int16 dataSize, long posn)
-        {
-            // The PKWare spec says that any of {UncompressedSize, CompressedSize,
-            // RelativeOffset} exceeding 0xFFFFFFFF can lead to the ZIP64 header,
-            // and the ZIP64 header may contain one or more of those.  If the
-            // values are present, they will be found in the prescribed order.
-            // There may also be a 4-byte "disk start number."
-            // This means that the DataSize must be 28 bytes or less.
-
-            this._InputUsesZip64 = true;
-
-            // workitem 7941: check datasize before reading.
-            if (dataSize > 28)
-                throw new BadReadException(String.Format("  Inconsistent size (0x{0:X4}) for ZIP64 extra field at position 0x{1:X16}",
-                                                         dataSize, posn));
-            int remainingData = dataSize;
-
-            var slurp = new Func<Int64>( () => {
-                    if (remainingData < 8)
-                        throw new BadReadException(String.Format("  Missing data for ZIP64 extra field, position 0x{0:X16}", posn));
-                    var x = BitConverter.ToInt64(buffer, j);
-                    j+= 8;
-                    remainingData -= 8;
-                    return x;
-                });
-
-            if (this._UncompressedSize == 0xFFFFFFFF)
-                this._UncompressedSize = slurp();
-
-            if (this._CompressedSize == 0xFFFFFFFF)
-                this._CompressedSize = slurp();
-
-            if (this._RelativeOffsetOfLocalHeader == 0xFFFFFFFF)
-                this._RelativeOffsetOfLocalHeader = slurp();
-
-            // Ignore anything else. Potentially there are 4 more bytes for the
-            // disk start number.  DotNetZip currently doesn't handle multi-disk
-            // archives.
-            return j;
-        }
-
-
-        private int ProcessExtraFieldInfoZipTimes(byte[] buffer, int j, Int16 dataSize, long posn)
-        {
-            if (dataSize != 12 && dataSize != 8)
-                throw new BadReadException(String.Format("  Unexpected size (0x{0:X4}) for InfoZip v1 extra field at position 0x{1:X16}", dataSize, posn));
-
-            Int32 timet = BitConverter.ToInt32(buffer, j);
-            this._Mtime = _unixEpoch.AddSeconds(timet);
-            j += 4;
-
-            timet = BitConverter.ToInt32(buffer, j);
-            this._Atime = _unixEpoch.AddSeconds(timet);
-            j += 4;
-
-            this._Ctime = DateTime.UtcNow;
-
-            _ntfsTimesAreSet = true;
-            _timestamp |= ZipEntryTimestamp.InfoZip1; return j;
-        }
-
-
-
-        private int ProcessExtraFieldUnixTimes(byte[] buffer, int j, Int16 dataSize, long posn)
-        {
-            // The Unix filetimes are 32-bit unsigned integers,
-            // storing seconds since Unix epoch.
-
-            if (dataSize != 13 && dataSize != 9 && dataSize != 5)
-                throw new BadReadException(String.Format("  Unexpected size (0x{0:X4}) for Extended Timestamp extra field at position 0x{1:X16}", dataSize, posn));
-
-            int remainingData = dataSize;
-
-            var slurp = new Func<DateTime>( () => {
-                    Int32 timet = BitConverter.ToInt32(buffer, j);
-                    j += 4;
-                    remainingData -= 4;
-                    return _unixEpoch.AddSeconds(timet);
-                });
-
-            if (dataSize == 13 || _readExtraDepth > 0)
-            {
-                byte flag = buffer[j++];
-                remainingData--;
-
-                if ((flag & 0x0001) != 0 && remainingData >= 4)
-                    this._Mtime = slurp();
-
-                 this._Atime = ((flag & 0x0002) != 0 && remainingData >= 4)
-                     ? slurp()
-                     : DateTime.UtcNow;
-
-                 this._Ctime =  ((flag & 0x0004) != 0 && remainingData >= 4)
-                     ? slurp()
-                     :DateTime.UtcNow;
-
-                _timestamp |= ZipEntryTimestamp.Unix;
-                _ntfsTimesAreSet = true;
-                _emitUnixTimes = true;
-            }
-            else
-                ReadExtraField(); // will recurse
-
-            return j;
-        }
-
-
-        private int ProcessExtraFieldWindowsTimes(byte[] buffer, int j, Int16 dataSize, long posn)
-        {
-            // The NTFS filetimes are 64-bit unsigned integers, stored in Intel
-            // (least significant byte first) byte order. They are expressed as the
-            // number of 1.0E-07 seconds (1/10th microseconds!) past WinNT "epoch",
-            // which is "01-Jan-1601 00:00:00 UTC".
-            //
-            // HeaderId   2 bytes    0x000a == NTFS stuff
-            // Datasize   2 bytes    ?? (usually 32)
-            // reserved   4 bytes    ??
-            // timetag    2 bytes    0x0001 == time
-            // size       2 bytes    24 == 8 bytes each for ctime, mtime, atime
-            // mtime      8 bytes    win32 ticks since win32epoch
-            // atime      8 bytes    win32 ticks since win32epoch
-            // ctime      8 bytes    win32 ticks since win32epoch
-
-            if (dataSize != 32)
-                throw new BadReadException(String.Format("  Unexpected size (0x{0:X4}) for NTFS times extra field at position 0x{1:X16}", dataSize, posn));
-
-            j += 4;  // reserved
-            Int16 timetag = (Int16)(buffer[j] + buffer[j + 1] * 256);
-            Int16 addlsize = (Int16)(buffer[j + 2] + buffer[j + 3] * 256);
-            j += 4;  // tag and size
-
-            if (timetag == 0x0001 && addlsize == 24)
-            {
-                Int64 z = BitConverter.ToInt64(buffer, j);
-                this._Mtime = DateTime.FromFileTimeUtc(z);
-                j += 8;
-
-                // At this point the library *could* set the LastModified value
-                // to coincide with the Mtime value.  In theory, they refer to
-                // the same property of the file, and should be the same anyway,
-                // allowing for differences in precision.  But they are
-                // independent quantities in the zip archive, and this library
-                // will keep them separate in the object model. There is no ill
-                // effect from this, because as files are extracted, the
-                // higher-precision value (Mtime) is used if it is present.
-                // Apps may wish to compare the Mtime versus LastModified
-                // values, but any difference when both are present is not
-                // germaine to the correctness of the library. but note: when
-                // explicitly setting either value, both are set. See the setter
-                // for LastModified or the SetNtfsTimes() method.
-
-                z = BitConverter.ToInt64(buffer, j);
-                this._Atime = DateTime.FromFileTimeUtc(z);
-                j += 8;
-
-                z = BitConverter.ToInt64(buffer, j);
-                this._Ctime = DateTime.FromFileTimeUtc(z);
-                j += 8;
-
-                _ntfsTimesAreSet = true;
-                _timestamp |= ZipEntryTimestamp.Windows;
-                _emitNtfsTimes = true;
-            }
-            return j;
-        }
-
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipEntry.Write.cs b/EPPlus/Packaging/DotNetZip/ZipEntry.Write.cs
deleted file mode 100644
index dc95211..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipEntry.Write.cs
+++ /dev/null
@@ -1,2583 +0,0 @@
-//#define Trace
-
-// ZipEntry.Write.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// Last Saved: <2011-July-30 14:55:47>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for writing (saving) the ZipEntry into a
-// zip file.
-//
-// ------------------------------------------------------------------
-
-
-using OfficeOpenXml.Packaging.Ionic.Zlib;
-using System;
-using System.IO;
-using RE = System.Text.RegularExpressions;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal partial class ZipEntry
-    {
-        internal void WriteCentralDirectoryEntry(Stream s)
-        {
-            byte[] bytes = new byte[4096];
-            int i = 0;
-            // signature
-            bytes[i++] = (byte)(ZipConstants.ZipDirEntrySignature & 0x000000FF);
-            bytes[i++] = (byte)((ZipConstants.ZipDirEntrySignature & 0x0000FF00) >> 8);
-            bytes[i++] = (byte)((ZipConstants.ZipDirEntrySignature & 0x00FF0000) >> 16);
-            bytes[i++] = (byte)((ZipConstants.ZipDirEntrySignature & 0xFF000000) >> 24);
-
-            // Version Made By
-            // workitem 7071
-            // We must not overwrite the VersionMadeBy field when writing out a zip
-            // archive.  The VersionMadeBy tells the zip reader the meaning of the
-            // File attributes.  Overwriting the VersionMadeBy will result in
-            // inconsistent metadata.  Consider the scenario where the application
-            // opens and reads a zip file that had been created on Linux. Then the
-            // app adds one file to the Zip archive, and saves it.  The file
-            // attributes for all the entries added on Linux will be significant for
-            // Linux.  Therefore the VersionMadeBy for those entries must not be
-            // changed.  Only the entries that are actually created on Windows NTFS
-            // should get the VersionMadeBy indicating Windows/NTFS.
-            bytes[i++] = (byte)(_VersionMadeBy & 0x00FF);
-            bytes[i++] = (byte)((_VersionMadeBy & 0xFF00) >> 8);
-
-            // Apparently we want to duplicate the extra field here; we cannot
-            // simply zero it out and assume tools and apps will use the right one.
-
-            ////Int16 extraFieldLengthSave = (short)(_EntryHeader[28] + _EntryHeader[29] * 256);
-            ////_EntryHeader[28] = 0;
-            ////_EntryHeader[29] = 0;
-
-            // Version Needed, Bitfield, compression method, lastmod,
-            // crc, compressed and uncompressed sizes, filename length and extra field length.
-            // These are all present in the local file header, but they may be zero values there.
-            // So we cannot just copy them.
-
-            // workitem 11969: Version Needed To Extract in central directory must be
-            // the same as the local entry or MS .NET System.IO.Zip fails read.
-            Int16 vNeeded = (Int16)(VersionNeeded != 0 ? VersionNeeded : 20);
-            // workitem 12964
-            if (_OutputUsesZip64==null)
-            {
-                // a zipentry in a zipoutputstream, with zero bytes written
-                _OutputUsesZip64 = new Nullable<bool>(_container.Zip64 == Zip64Option.Always);
-            }
-
-            Int16 versionNeededToExtract = (Int16)(_OutputUsesZip64.Value ? 45 : vNeeded);
-#if BZIP
-            if (this.CompressionMethod == Ionic.Zip.CompressionMethod.BZip2)
-                versionNeededToExtract = 46;
-#endif
-
-            bytes[i++] = (byte)(versionNeededToExtract & 0x00FF);
-            bytes[i++] = (byte)((versionNeededToExtract & 0xFF00) >> 8);
-
-            bytes[i++] = (byte)(_BitField & 0x00FF);
-            bytes[i++] = (byte)((_BitField & 0xFF00) >> 8);
-
-            bytes[i++] = (byte)(_CompressionMethod & 0x00FF);
-            bytes[i++] = (byte)((_CompressionMethod & 0xFF00) >> 8);
-
-#if AESCRYPTO
-            if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-            Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                i -= 2;
-                bytes[i++] = 0x63;
-                bytes[i++] = 0;
-            }
-#endif
-
-            bytes[i++] = (byte)(_TimeBlob & 0x000000FF);
-            bytes[i++] = (byte)((_TimeBlob & 0x0000FF00) >> 8);
-            bytes[i++] = (byte)((_TimeBlob & 0x00FF0000) >> 16);
-            bytes[i++] = (byte)((_TimeBlob & 0xFF000000) >> 24);
-            bytes[i++] = (byte)(_Crc32 & 0x000000FF);
-            bytes[i++] = (byte)((_Crc32 & 0x0000FF00) >> 8);
-            bytes[i++] = (byte)((_Crc32 & 0x00FF0000) >> 16);
-            bytes[i++] = (byte)((_Crc32 & 0xFF000000) >> 24);
-
-            int j = 0;
-            if (_OutputUsesZip64.Value)
-            {
-                // CompressedSize (Int32) and UncompressedSize - all 0xFF
-                for (j = 0; j < 8; j++)
-                    bytes[i++] = 0xFF;
-            }
-            else
-            {
-                bytes[i++] = (byte)(_CompressedSize & 0x000000FF);
-                bytes[i++] = (byte)((_CompressedSize & 0x0000FF00) >> 8);
-                bytes[i++] = (byte)((_CompressedSize & 0x00FF0000) >> 16);
-                bytes[i++] = (byte)((_CompressedSize & 0xFF000000) >> 24);
-
-                bytes[i++] = (byte)(_UncompressedSize & 0x000000FF);
-                bytes[i++] = (byte)((_UncompressedSize & 0x0000FF00) >> 8);
-                bytes[i++] = (byte)((_UncompressedSize & 0x00FF0000) >> 16);
-                bytes[i++] = (byte)((_UncompressedSize & 0xFF000000) >> 24);
-            }
-
-            byte[] fileNameBytes = GetEncodedFileNameBytes();
-            Int16 filenameLength = (Int16)fileNameBytes.Length;
-            bytes[i++] = (byte)(filenameLength & 0x00FF);
-            bytes[i++] = (byte)((filenameLength & 0xFF00) >> 8);
-
-            // do this again because now we have real data
-            _presumeZip64 = _OutputUsesZip64.Value;
-
-            // workitem 11131
-            //
-            // cannot generate the extra field again, here's why: In the case of a
-            // zero-byte entry, which uses encryption, DotNetZip will "remove" the
-            // encryption from the entry.  It does this in PostProcessOutput; it
-            // modifies the entry header, and rewrites it, resetting the Bitfield
-            // (one bit indicates encryption), and potentially resetting the
-            // compression method - for AES the Compression method is 0x63, and it
-            // would get reset to zero (no compression).  It then calls SetLength()
-            // to truncate the stream to remove the encryption header (12 bytes for
-            // AES256).  But, it leaves the previously-generated "Extra Field"
-            // metadata (11 bytes) for AES in the entry header. This extra field
-            // data is now "orphaned" - it refers to AES encryption when in fact no
-            // AES encryption is used. But no problem, the PKWARE spec says that
-            // unrecognized extra fields can just be ignored. ok.  After "removal"
-            // of AES encryption, the length of the Extra Field can remains the
-            // same; it's just that there will be 11 bytes in there that previously
-            // pertained to AES which are now unused. Even the field code is still
-            // there, but it will be unused by readers, as the encryption bit is not
-            // set.
-            //
-            // Re-calculating the Extra field now would produce a block that is 11
-            // bytes shorter, and that mismatch - between the extra field in the
-            // local header and the extra field in the Central Directory - would
-            // cause problems. (where? why? what problems?)  So we can't do
-            // that. It's all good though, because though the content may have
-            // changed, the length definitely has not. Also, the _EntryHeader
-            // contains the "updated" extra field (after PostProcessOutput) at
-            // offset (30 + filenameLength).
-
-            _Extra = ConstructExtraField(true);
-
-            Int16 extraFieldLength = (Int16)((_Extra == null) ? 0 : _Extra.Length);
-            bytes[i++] = (byte)(extraFieldLength & 0x00FF);
-            bytes[i++] = (byte)((extraFieldLength & 0xFF00) >> 8);
-
-            // File (entry) Comment Length
-            // the _CommentBytes private field was set during WriteHeader()
-            int commentLength = (_CommentBytes == null) ? 0 : _CommentBytes.Length;
-
-            // the size of our buffer defines the max length of the comment we can write
-            if (commentLength + i > bytes.Length) commentLength = bytes.Length - i;
-            bytes[i++] = (byte)(commentLength & 0x00FF);
-            bytes[i++] = (byte)((commentLength & 0xFF00) >> 8);
-
-            // Disk number start
-            bool segmented = (this._container.ZipFile != null) &&
-                (this._container.ZipFile.MaxOutputSegmentSize != 0);
-            if (segmented) // workitem 13915
-            {
-                // Emit nonzero disknumber only if saving segmented archive.
-                bytes[i++] = (byte)(_diskNumber & 0x00FF);
-                bytes[i++] = (byte)((_diskNumber & 0xFF00) >> 8);
-            }
-            else
-            {
-                // If reading a segmneted archive and saving to a regular archive,
-                // ZipEntry._diskNumber will be non-zero but it should be saved as
-                // zero.
-                bytes[i++] = 0;
-                bytes[i++] = 0;
-            }
-
-            // internal file attrs
-            // workitem 7801
-            bytes[i++] = (byte)((_IsText) ? 1 : 0); // lo bit: filetype hint.  0=bin, 1=txt.
-            bytes[i++] = 0;
-
-            // external file attrs
-            // workitem 7071
-            bytes[i++] = (byte)(_ExternalFileAttrs & 0x000000FF);
-            bytes[i++] = (byte)((_ExternalFileAttrs & 0x0000FF00) >> 8);
-            bytes[i++] = (byte)((_ExternalFileAttrs & 0x00FF0000) >> 16);
-            bytes[i++] = (byte)((_ExternalFileAttrs & 0xFF000000) >> 24);
-
-            // workitem 11131
-            // relative offset of local header.
-            //
-            // If necessary to go to 64-bit value, then emit 0xFFFFFFFF,
-            // else write out the value.
-            //
-            // Even if zip64 is required for other reasons - number of the entry
-            // > 65534, or uncompressed size of the entry > MAX_INT32, the ROLH
-            // need not be stored in a 64-bit field .
-            if (_RelativeOffsetOfLocalHeader > 0xFFFFFFFFL) // _OutputUsesZip64.Value
-            {
-                bytes[i++] = 0xFF;
-                bytes[i++] = 0xFF;
-                bytes[i++] = 0xFF;
-                bytes[i++] = 0xFF;
-            }
-            else
-            {
-                bytes[i++] = (byte)(_RelativeOffsetOfLocalHeader & 0x000000FF);
-                bytes[i++] = (byte)((_RelativeOffsetOfLocalHeader & 0x0000FF00) >> 8);
-                bytes[i++] = (byte)((_RelativeOffsetOfLocalHeader & 0x00FF0000) >> 16);
-                bytes[i++] = (byte)((_RelativeOffsetOfLocalHeader & 0xFF000000) >> 24);
-            }
-
-            // actual filename
-            Buffer.BlockCopy(fileNameBytes, 0, bytes, i, filenameLength);
-            i += filenameLength;
-
-            // "Extra field"
-            if (_Extra != null)
-            {
-                // workitem 11131
-                //
-                // copy from EntryHeader if available - it may have been updated.
-                // if not, copy from Extra. This would be unnecessary if I just
-                // updated the Extra field when updating EntryHeader, in
-                // PostProcessOutput.
-
-                //?? I don't understand why I wouldn't want to just use
-                // the recalculated Extra field. ??
-
-                // byte[] h = _EntryHeader ?? _Extra;
-                // int offx = (h == _EntryHeader) ? 30 + filenameLength : 0;
-                // Buffer.BlockCopy(h, offx, bytes, i, extraFieldLength);
-                // i += extraFieldLength;
-
-                byte[] h = _Extra;
-                int offx = 0;
-                Buffer.BlockCopy(h, offx, bytes, i, extraFieldLength);
-                i += extraFieldLength;
-            }
-
-            // file (entry) comment
-            if (commentLength != 0)
-            {
-                // now actually write the comment itself into the byte buffer
-                Buffer.BlockCopy(_CommentBytes, 0, bytes, i, commentLength);
-                // for (j = 0; (j < commentLength) && (i + j < bytes.Length); j++)
-                //     bytes[i + j] = _CommentBytes[j];
-                i += commentLength;
-            }
-
-            s.Write(bytes, 0, i);
-        }
-
-
-#if INFOZIP_UTF8
-        static private bool FileNameIsUtf8(char[] FileNameChars)
-        {
-            bool isUTF8 = false;
-            bool isUnicode = false;
-            for (int j = 0; j < FileNameChars.Length; j++)
-            {
-                byte[] b = System.BitConverter.GetBytes(FileNameChars[j]);
-                isUnicode |= (b.Length != 2);
-                isUnicode |= (b[1] != 0);
-                isUTF8 |= ((b[0] & 0x80) != 0);
-            }
-
-            return isUTF8;
-        }
-#endif
-
-
-        private byte[] ConstructExtraField(bool forCentralDirectory)
-        {
-            var listOfBlocks = new System.Collections.Generic.List<byte[]>();
-            byte[] block;
-
-            // Conditionally emit an extra field with Zip64 information.  If the
-            // Zip64 option is Always, we emit the field, before knowing that it's
-            // necessary.  Later, if it turns out this entry does not need zip64,
-            // we'll set the header ID to rubbish and the data will be ignored.
-            // This results in additional overhead metadata in the zip file, but
-            // it will be small in comparison to the entry data.
-            //
-            // On the other hand if the Zip64 option is AsNecessary and it's NOT
-            // for the central directory, then we do the same thing.  Or, if the
-            // Zip64 option is AsNecessary and it IS for the central directory,
-            // and the entry requires zip64, then emit the header.
-            if (_container.Zip64 == Zip64Option.Always ||
-                (_container.Zip64 == Zip64Option.AsNecessary &&
-                 (!forCentralDirectory || _entryRequiresZip64.Value)))
-            {
-                // add extra field for zip64 here
-                // workitem 7924
-                int sz = 4 + (forCentralDirectory ? 28 : 16);
-                block = new byte[sz];
-                int i = 0;
-
-                if (_presumeZip64 || forCentralDirectory)
-                {
-                    // HeaderId = always use zip64 extensions.
-                    block[i++] = 0x01;
-                    block[i++] = 0x00;
-                }
-                else
-                {
-                    // HeaderId = dummy data now, maybe set to 0x0001 (ZIP64) later.
-                    block[i++] = 0x99;
-                    block[i++] = 0x99;
-                }
-
-                // DataSize
-                block[i++] = (byte)(sz - 4);  // decimal 28 or 16  (workitem 7924)
-                block[i++] = 0x00;
-
-                // The actual metadata - we may or may not have real values yet...
-
-                // uncompressed size
-                Array.Copy(BitConverter.GetBytes(_UncompressedSize), 0, block, i, 8);
-                i += 8;
-                // compressed size
-                Array.Copy(BitConverter.GetBytes(_CompressedSize), 0, block, i, 8);
-                i += 8;
-
-                // workitem 7924 - only include this if the "extra" field is for
-                // use in the central directory.  It is unnecessary and not useful
-                // for local header; makes WinZip choke.
-                if (forCentralDirectory)
-                {
-                    // relative offset
-                    Array.Copy(BitConverter.GetBytes(_RelativeOffsetOfLocalHeader), 0, block, i, 8);
-                    i += 8;
-
-                    // starting disk number
-                    Array.Copy(BitConverter.GetBytes(0), 0, block, i, 4);
-                }
-                listOfBlocks.Add(block);
-            }
-
-
-#if AESCRYPTO
-            if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                block = new byte[4 + 7];
-                int i = 0;
-                // extra field for WinZip AES
-                // header id
-                block[i++] = 0x01;
-                block[i++] = 0x99;
-
-                // data size
-                block[i++] = 0x07;
-                block[i++] = 0x00;
-
-                // vendor number
-                block[i++] = 0x01;  // AE-1 - means "Verify CRC"
-                block[i++] = 0x00;
-
-                // vendor id "AE"
-                block[i++] = 0x41;
-                block[i++] = 0x45;
-
-                // key strength
-                int keystrength = GetKeyStrengthInBits(Encryption);
-                if (keystrength == 128)
-                    block[i] = 1;
-                else if (keystrength == 256)
-                    block[i] = 3;
-                else
-                    block[i] = 0xFF;
-                i++;
-
-                // actual compression method
-                block[i++] = (byte)(_CompressionMethod & 0x00FF);
-                block[i++] = (byte)(_CompressionMethod & 0xFF00);
-
-                listOfBlocks.Add(block);
-            }
-#endif
-
-            if (_ntfsTimesAreSet && _emitNtfsTimes)
-            {
-                block = new byte[32 + 4];
-                // HeaderId   2 bytes    0x000a == NTFS times
-                // Datasize   2 bytes    32
-                // reserved   4 bytes    ?? don't care
-                // timetag    2 bytes    0x0001 == NTFS time
-                // size       2 bytes    24 == 8 bytes each for ctime, mtime, atime
-                // mtime      8 bytes    win32 ticks since win32epoch
-                // atime      8 bytes    win32 ticks since win32epoch
-                // ctime      8 bytes    win32 ticks since win32epoch
-                int i = 0;
-                // extra field for NTFS times
-                // header id
-                block[i++] = 0x0a;
-                block[i++] = 0x00;
-
-                // data size
-                block[i++] = 32;
-                block[i++] = 0;
-
-                i += 4; // reserved
-
-                // time tag
-                block[i++] = 0x01;
-                block[i++] = 0x00;
-
-                // data size (again)
-                block[i++] = 24;
-                block[i++] = 0;
-
-                Int64 z = _Mtime.ToFileTime();
-                Array.Copy(BitConverter.GetBytes(z), 0, block, i, 8);
-                i += 8;
-                z = _Atime.ToFileTime();
-                Array.Copy(BitConverter.GetBytes(z), 0, block, i, 8);
-                i += 8;
-                z = _Ctime.ToFileTime();
-                Array.Copy(BitConverter.GetBytes(z), 0, block, i, 8);
-                i += 8;
-
-                listOfBlocks.Add(block);
-            }
-
-            if (_ntfsTimesAreSet && _emitUnixTimes)
-            {
-                int len = 5 + 4;
-                if (!forCentralDirectory) len += 8;
-
-                block = new byte[len];
-                // local form:
-                // --------------
-                // HeaderId   2 bytes    0x5455 == unix timestamp
-                // Datasize   2 bytes    13
-                // flags      1 byte     7 (low three bits all set)
-                // mtime      4 bytes    seconds since unix epoch
-                // atime      4 bytes    seconds since unix epoch
-                // ctime      4 bytes    seconds since unix epoch
-                //
-                // central directory form:
-                //---------------------------------
-                // HeaderId   2 bytes    0x5455 == unix timestamp
-                // Datasize   2 bytes    5
-                // flags      1 byte     7 (low three bits all set)
-                // mtime      4 bytes    seconds since unix epoch
-                //
-                int i = 0;
-                // extra field for "unix" times
-                // header id
-                block[i++] = 0x55;
-                block[i++] = 0x54;
-
-                // data size
-                block[i++] = unchecked((byte)(len - 4));
-                block[i++] = 0;
-
-                // flags
-                block[i++] = 0x07;
-
-                Int32 z = unchecked((int)((_Mtime - _unixEpoch).TotalSeconds));
-                Array.Copy(BitConverter.GetBytes(z), 0, block, i, 4);
-                i += 4;
-                if (!forCentralDirectory)
-                {
-                    z = unchecked((int)((_Atime - _unixEpoch).TotalSeconds));
-                    Array.Copy(BitConverter.GetBytes(z), 0, block, i, 4);
-                    i += 4;
-                    z = unchecked((int)((_Ctime - _unixEpoch).TotalSeconds));
-                    Array.Copy(BitConverter.GetBytes(z), 0, block, i, 4);
-                    i += 4;
-                }
-                listOfBlocks.Add(block);
-            }
-
-
-            // inject other blocks here...
-
-
-            // concatenate any blocks we've got:
-            byte[] aggregateBlock = null;
-            if (listOfBlocks.Count > 0)
-            {
-                int totalLength = 0;
-                int i, current = 0;
-                for (i = 0; i < listOfBlocks.Count; i++)
-                    totalLength += listOfBlocks[i].Length;
-                aggregateBlock = new byte[totalLength];
-                for (i = 0; i < listOfBlocks.Count; i++)
-                {
-                    System.Array.Copy(listOfBlocks[i], 0, aggregateBlock, current, listOfBlocks[i].Length);
-                    current += listOfBlocks[i].Length;
-                }
-            }
-
-            return aggregateBlock;
-        }
-
-
-
-        // private System.Text.Encoding GenerateCommentBytes()
-        // {
-        //     var getEncoding = new Func<System.Text.Encoding>({
-        //     switch (AlternateEncodingUsage)
-        //     {
-        //         case ZipOption.Always:
-        //             return AlternateEncoding;
-        //         case ZipOption.Never:
-        //             return ibm437;
-        //     }
-        //     var cb = ibm437.GetBytes(_Comment);
-        //     // need to use this form of GetString() for .NET CF
-        //     string s1 = ibm437.GetString(cb, 0, cb.Length);
-        //     if (s1 == _Comment)
-        //         return ibm437;
-        //     return AlternateEncoding;
-        //     });
-        //
-        //     var encoding = getEncoding();
-        //     _CommentBytes = encoding.GetBytes(_Comment);
-        //     return encoding;
-        // }
-
-
-        private string NormalizeFileName()
-        {
-            // here, we need to flip the backslashes to forward-slashes,
-            // also, we need to trim the \\server\share syntax from any UNC path.
-            // and finally, we need to remove any leading .\
-
-            string SlashFixed = FileName.Replace("\\", "/");
-            string s1 = null;
-            if ((_TrimVolumeFromFullyQualifiedPaths) && (FileName.Length >= 3)
-                && (FileName[1] == ':') && (SlashFixed[2] == '/'))
-            {
-                // trim off volume letter, colon, and slash
-                s1 = SlashFixed.Substring(3);
-            }
-            else if ((FileName.Length >= 4)
-                     && ((SlashFixed[0] == '/') && (SlashFixed[1] == '/')))
-            {
-                int n = SlashFixed.IndexOf('/', 2);
-                if (n == -1)
-                    throw new ArgumentException("The path for that entry appears to be badly formatted");
-                s1 = SlashFixed.Substring(n + 1);
-            }
-            else if ((FileName.Length >= 3)
-                     && ((SlashFixed[0] == '.') && (SlashFixed[1] == '/')))
-            {
-                // trim off dot and slash
-                s1 = SlashFixed.Substring(2);
-            }
-            else
-            {
-                s1 = SlashFixed;
-            }
-            return s1;
-        }
-
-
-        /// <summary>
-        ///   generate and return a byte array that encodes the filename
-        ///   for the entry.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     side effects: generate and store into _CommentBytes the
-        ///     byte array for any comment attached to the entry. Also
-        ///     sets _actualEncoding to indicate the actual encoding
-        ///     used. The same encoding is used for both filename and
-        ///     comment.
-        ///   </para>
-        /// </remarks>
-        private byte[] GetEncodedFileNameBytes()
-        {
-            // workitem 6513
-            var s1 = NormalizeFileName();
-
-            switch(AlternateEncodingUsage)
-            {
-                case ZipOption.Always:
-                    if (!(_Comment == null || _Comment.Length == 0))
-                        _CommentBytes = AlternateEncoding.GetBytes(_Comment);
-                    _actualEncoding = AlternateEncoding;
-                    return AlternateEncoding.GetBytes(s1);
-
-                case ZipOption.Never:
-                    if (!(_Comment == null || _Comment.Length == 0))
-                        _CommentBytes = ibm437.GetBytes(_Comment);
-                    _actualEncoding = ibm437;
-                    return ibm437.GetBytes(s1);
-            }
-
-            // arriving here means AlternateEncodingUsage is "AsNecessary"
-
-            // case ZipOption.AsNecessary:
-            // workitem 6513: when writing, use the alternative encoding
-            // only when _actualEncoding is not yet set (it can be set
-            // during Read), and when ibm437 will not do.
-
-            byte[] result = ibm437.GetBytes(s1);
-            // need to use this form of GetString() for .NET CF
-            string s2 = ibm437.GetString(result, 0, result.Length);
-            _CommentBytes = null;
-            if (s2 != s1)
-            {
-                // Encoding the filename with ibm437 does not allow round-trips.
-                // Therefore, use the alternate encoding.  Assume it will work,
-                // no checking of round trips here.
-                result = AlternateEncoding.GetBytes(s1);
-                if (_Comment != null && _Comment.Length != 0)
-                    _CommentBytes = AlternateEncoding.GetBytes(_Comment);
-                _actualEncoding = AlternateEncoding;
-                return result;
-            }
-
-            _actualEncoding = ibm437;
-
-            // Using ibm437, FileName can be encoded without information
-            // loss; now try the Comment.
-
-            // if there is no comment, use ibm437.
-            if (_Comment == null || _Comment.Length == 0)
-                return result;
-
-            // there is a comment. Get the encoded form.
-            byte[] cbytes = ibm437.GetBytes(_Comment);
-            string c2 = ibm437.GetString(cbytes,0,cbytes.Length);
-
-            // Check for round-trip.
-            if (c2 != Comment)
-            {
-                // Comment cannot correctly be encoded with ibm437.  Use
-                // the alternate encoding.
-
-                result = AlternateEncoding.GetBytes(s1);
-                _CommentBytes = AlternateEncoding.GetBytes(_Comment);
-                _actualEncoding = AlternateEncoding;
-                return result;
-            }
-
-            // use IBM437
-            _CommentBytes = cbytes;
-            return result;
-        }
-
-
-
-        private bool WantReadAgain()
-        {
-            if (_UncompressedSize < 0x10) return false;
-            if (_CompressionMethod == 0x00) return false;
-            if (CompressionLevel == OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.None) return false;
-            if (_CompressedSize < _UncompressedSize) return false;
-
-            if (this._Source == ZipEntrySource.Stream && !this._sourceStream.CanSeek) return false;
-
-#if AESCRYPTO
-            if (_aesCrypto_forWrite != null && (CompressedSize - _aesCrypto_forWrite.SizeOfEncryptionMetadata) <= UncompressedSize + 0x10) return false;
-#endif
-
-            if (_zipCrypto_forWrite != null && (CompressedSize - 12) <= UncompressedSize) return false;
-
-            return true;
-        }
-
-
-
-        private void MaybeUnsetCompressionMethodForWriting(int cycle)
-        {
-            // if we've already tried with compression... turn it off this time
-            if (cycle > 1)
-            {
-                _CompressionMethod = 0x0;
-                return;
-            }
-            // compression for directories = 0x00 (No Compression)
-            if (IsDirectory)
-            {
-                _CompressionMethod = 0x0;
-                return;
-            }
-
-            if (this._Source == ZipEntrySource.ZipFile)
-            {
-                return; // do nothing
-            }
-
-            // If __FileDataPosition is zero, then that means we will get the data
-            // from a file or stream.
-
-            // It is never possible to compress a zero-length file, so we check for
-            // this condition.
-
-            if (this._Source == ZipEntrySource.Stream)
-            {
-                // workitem 7742
-                if (_sourceStream != null && _sourceStream.CanSeek)
-                {
-                    // Length prop will throw if CanSeek is false
-                    long fileLength = _sourceStream.Length;
-                    if (fileLength == 0)
-                    {
-                        _CompressionMethod = 0x00;
-                        return;
-                    }
-                }
-            }
-            else if ((this._Source == ZipEntrySource.FileSystem) && (SharedUtilities.GetFileLength(LocalFileName) == 0L))
-            {
-                _CompressionMethod = 0x00;
-                return;
-            }
-
-            // Ok, we're getting the data to be compressed from a
-            // non-zero-length file or stream, or a file or stream of
-            // unknown length, and we presume that it is non-zero.  In
-            // that case we check the callback to see if the app wants
-            // to tell us whether to compress or not.
-            if (SetCompression != null)
-                CompressionLevel = SetCompression(LocalFileName, _FileNameInArchive);
-
-            // finally, set CompressionMethod to None if CompressionLevel is None
-            if (CompressionLevel == (short)Ionic.Zlib.CompressionLevel.None &&
-                CompressionMethod == Ionic.Zip.CompressionMethod.Deflate)
-                _CompressionMethod = 0x00;
-
-            return;
-        }
-
-
-
-        // write the header info for an entry
-        internal void WriteHeader(Stream s, int cycle)
-        {
-            // Must remember the offset, within the output stream, of this particular
-            // entry header.
-            //
-            // This is for 2 reasons:
-            //
-            //  1. so we can determine the RelativeOffsetOfLocalHeader (ROLH) for
-            //     use in the central directory.
-            //  2. so we can seek backward in case there is an error opening or reading
-            //     the file, and the application decides to skip the file. In this case,
-            //     we need to seek backward in the output stream to allow the next entry
-            //     to be added to the zipfile output stream.
-            //
-            // Normally you would just store the offset before writing to the output
-            // stream and be done with it.  But the possibility to use split archives
-            // makes this approach ineffective.  In split archives, each file or segment
-            // is bound to a max size limit, and each local file header must not span a
-            // segment boundary; it must be written contiguously.  If it will fit in the
-            // current segment, then the ROLH is just the current Position in the output
-            // stream.  If it won't fit, then we need a new file (segment) and the ROLH
-            // is zero.
-            //
-            // But we only can know if it is possible to write a header contiguously
-            // after we know the size of the local header, a size that varies with
-            // things like filename length, comments, and extra fields.  We have to
-            // compute the header fully before knowing whether it will fit.
-            //
-            // That takes care of item #1 above.  Now, regarding #2.  If an error occurs
-            // while computing the local header, we want to just seek backward. The
-            // exception handling logic (in the caller of WriteHeader) uses ROLH to
-            // scroll back.
-            //
-            // All this means we have to preserve the starting offset before computing
-            // the header, and also we have to compute the offset later, to handle the
-            // case of split archives.
-
-            var counter = s as CountingStream;
-
-            // workitem 8098: ok (output)
-            // This may change later, for split archives
-
-            // Don't set _RelativeOffsetOfLocalHeader. Instead, set a temp variable.
-            // This allows for re-streaming, where a zip entry might be read from a
-            // zip archive (and maybe decrypted, and maybe decompressed) and then
-            // written to another zip archive, with different settings for
-            // compression method, compression level, or encryption algorithm.
-            _future_ROLH = (counter != null)
-                ? counter.ComputedPosition
-                : s.Position;
-
-            int j = 0, i = 0;
-
-            byte[] block = new byte[30];
-
-            // signature
-            block[i++] = (byte)(ZipConstants.ZipEntrySignature & 0x000000FF);
-            block[i++] = (byte)((ZipConstants.ZipEntrySignature & 0x0000FF00) >> 8);
-            block[i++] = (byte)((ZipConstants.ZipEntrySignature & 0x00FF0000) >> 16);
-            block[i++] = (byte)((ZipConstants.ZipEntrySignature & 0xFF000000) >> 24);
-
-            // Design notes for ZIP64:
-            //
-            // The specification says that the header must include the Compressed
-            // and Uncompressed sizes, as well as the CRC32 value.  When creating
-            // a zip via streamed processing, these quantities are not known until
-            // after the compression is done.  Thus, a typical way to do it is to
-            // insert zeroes for these quantities, then do the compression, then
-            // seek back to insert the appropriate values, then seek forward to
-            // the end of the file data.
-            //
-            // There is also the option of using bit 3 in the GP bitfield - to
-            // specify that there is a data descriptor after the file data
-            // containing these three quantities.
-            //
-            // This works when the size of the quantities is known, either 32-bits
-            // or 64 bits as with the ZIP64 extensions.
-            //
-            // With Zip64, the 4-byte fields are set to 0xffffffff, and there is a
-            // corresponding data block in the "extra field" that contains the
-            // actual Compressed, uncompressed sizes.  (As well as an additional
-            // field, the "Relative Offset of Local Header")
-            //
-            // The problem is when the app desires to use ZIP64 extensions
-            // optionally, only when necessary.  Suppose the library assumes no
-            // zip64 extensions when writing the header, then after compression
-            // finds that the size of the data requires zip64.  At this point, the
-            // header, already written to the file, won't have the necessary data
-            // block in the "extra field".  The size of the entry header is fixed,
-            // so it is not possible to just "add on" the zip64 data block after
-            // compressing the file.  On the other hand, always using zip64 will
-            // break interoperability with many other systems and apps.
-            //
-            // The approach we take is to insert a 32-byte dummy data block in the
-            // extra field, whenever zip64 is to be used "as necessary". This data
-            // block will get the actual zip64 HeaderId and zip64 metadata if
-            // necessary.  If not necessary, the data block will get a meaningless
-            // HeaderId (0x1111), and will be filled with zeroes.
-            //
-            // When zip64 is actually in use, we also need to set the
-            // VersionNeededToExtract field to 45.
-            //
-            // There is one additional wrinkle: using zip64 as necessary conflicts
-            // with output to non-seekable devices.  The header is emitted and
-            // must indicate whether zip64 is in use, before we know if zip64 is
-            // necessary.  Because there is no seeking, the header can never be
-            // changed.  Therefore, on non-seekable devices,
-            // Zip64Option.AsNecessary is the same as Zip64Option.Always.
-            //
-
-
-            // version needed- see AppNote.txt.
-            //
-            // need v5.1 for PKZIP strong encryption, or v2.0 for no encryption or
-            // for PK encryption, 4.5 for zip64.  We may reset this later, as
-            // necessary or zip64.
-
-            _presumeZip64 = (_container.Zip64 == Zip64Option.Always ||
-                             (_container.Zip64 == Zip64Option.AsNecessary && !s.CanSeek));
-            Int16 VersionNeededToExtract = (Int16)(_presumeZip64 ? 45 : 20);
-#if BZIP
-            if (this.CompressionMethod == Ionic.Zip.CompressionMethod.BZip2)
-                VersionNeededToExtract = 46;
-#endif
-
-            // (i==4)
-            block[i++] = (byte)(VersionNeededToExtract & 0x00FF);
-            block[i++] = (byte)((VersionNeededToExtract & 0xFF00) >> 8);
-
-            // Get byte array. Side effect: sets ActualEncoding.
-            // Must determine encoding before setting the bitfield.
-            // workitem 6513
-            byte[] fileNameBytes = GetEncodedFileNameBytes();
-            Int16 filenameLength = (Int16)fileNameBytes.Length;
-
-            // general purpose bitfield
-            // In the current implementation, this library uses only these bits
-            // in the GP bitfield:
-            //  bit 0 = if set, indicates the entry is encrypted
-            //  bit 3 = if set, indicates the CRC, C and UC sizes follow the file data.
-            //  bit 6 = strong encryption - for pkware's meaning of strong encryption
-            //  bit 11 = UTF-8 encoding is used in the comment and filename
-
-
-            // Here we set or unset the encryption bit.
-            // _BitField may already be set, as with a ZipEntry added into ZipOutputStream, which
-            // has bit 3 always set. We only want to set one bit
-            if (_Encryption == EncryptionAlgorithm.None)
-                _BitField &= ~1;  // encryption bit OFF
-            else
-                _BitField |= 1;   // encryption bit ON
-
-
-            // workitem 7941: WinZip does not the "strong encryption" bit  when using AES.
-            // This "Strong Encryption" is a PKWare Strong encryption thing.
-            //                 _BitField |= 0x0020;
-
-            // set the UTF8 bit if necessary
-#if SILVERLIGHT
-            if (_actualEncoding.WebName == "utf-8")
-#else
-            if (_actualEncoding.CodePage == System.Text.Encoding.UTF8.CodePage)
-#endif
-                _BitField |= 0x0800;
-
-            // The PKZIP spec says that if bit 3 is set (0x0008) in the General
-            // Purpose BitField, then the CRC, Compressed size, and uncompressed
-            // size are written directly after the file data.
-            //
-            // These 3 quantities are normally present in the regular zip entry
-            // header. But, they are not knowable until after the compression is
-            // done. So, in the normal case, we
-            //
-            //  - write the header, using zeros for these quantities
-            //  - compress the data, and incidentally compute these quantities.
-            //  - seek back and write the correct values them into the header.
-            //
-            // This is nice because, while it is more complicated to write the zip
-            // file, it is simpler and less error prone to read the zip file, and
-            // as a result more applications can read zip files produced this way,
-            // with those 3 quantities in the header.
-            //
-            // But if seeking in the output stream is not possible, then we need
-            // to set the appropriate bitfield and emit these quantities after the
-            // compressed file data in the output.
-            //
-            // workitem 7216 - having trouble formatting a zip64 file that is
-            // readable by WinZip.  not sure why!  What I found is that setting
-            // bit 3 and following all the implications, the zip64 file is
-            // readable by WinZip 12. and Perl's IO::Compress::Zip .  Perl takes
-            // an interesting approach - it always sets bit 3 if ZIP64 in use.
-            // DotNetZip now does the same; this gives better compatibility with
-            // WinZip 12.
-
-            if (IsDirectory || cycle == 99)
-            {
-                // (cycle == 99) indicates a zero-length entry written by ZipOutputStream
-
-                _BitField &= ~0x0008;  // unset bit 3 - no "data descriptor" - ever
-                _BitField &= ~0x0001;  // unset bit 1 - no encryption - ever
-                Encryption = EncryptionAlgorithm.None;
-                Password = null;
-            }
-            else if (!s.CanSeek)
-                _BitField |= 0x0008;
-
-#if DONT_GO_THERE
-            else if (this.Encryption == EncryptionAlgorithm.PkzipWeak  &&
-                     this._Source != ZipEntrySource.ZipFile)
-            {
-                // Set bit 3 to avoid the double-read perf issue.
-                //
-                // When PKZIP encryption is used, byte 11 of the encryption header is
-                // used as a consistency check. It is normally set to the MSByte of the
-                // CRC.  But this means the cRC must be known ebfore compression and
-                // encryption, which means the entire stream has to be read twice.  To
-                // avoid that, the high-byte of the time blob (when in DOS format) can
-                // be used for the consistency check (byte 11 in the encryption header).
-                // But this means the entry must have bit 3 set.
-                //
-                // Previously I used a more complex arrangement - using the methods like
-                // FigureCrc32(), PrepOutputStream() and others, in order to manage the
-                // seek-back in the source stream.  Why?  Because bit 3 is not always
-                // friendly with third-party zip tools, like those on the Mac.
-                //
-                // This is why this code is still ifdef'd  out.
-                //
-                // Might consider making this yet another programmable option -
-                // AlwaysUseBit3ForPkzip.  But that's for another day.
-                //
-                _BitField |= 0x0008;
-            }
-#endif
-
-            // (i==6)
-            block[i++] = (byte)(_BitField & 0x00FF);
-            block[i++] = (byte)((_BitField & 0xFF00) >> 8);
-
-            // Here, we want to set values for Compressed Size, Uncompressed Size,
-            // and CRC.  If we have __FileDataPosition as not -1 (zero is a valid
-            // FDP), then that means we are reading this zip entry from a zip
-            // file, and we have good values for those quantities.
-            //
-            // If _FileDataPosition is -1, then we are constructing this Entry
-            // from nothing.  We zero those quantities now, and we will compute
-            // actual values for the three quantities later, when we do the
-            // compression, and then seek back to write them into the appropriate
-            // place in the header.
-            if (this.__FileDataPosition == -1)
-            {
-                //_UncompressedSize = 0; // do not unset - may need this value for restream
-                // _Crc32 = 0;           // ditto
-                _CompressedSize = 0;
-                _crcCalculated = false;
-            }
-
-            // set compression method here
-            MaybeUnsetCompressionMethodForWriting(cycle);
-
-            // (i==8) compression method
-            block[i++] = (byte)(_CompressionMethod & 0x00FF);
-            block[i++] = (byte)((_CompressionMethod & 0xFF00) >> 8);
-
-            if (cycle == 99)
-            {
-                // (cycle == 99) indicates a zero-length entry written by ZipOutputStream
-                SetZip64Flags();
-            }
-
-#if AESCRYPTO
-            else if (Encryption == EncryptionAlgorithm.WinZipAes128 || Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                i -= 2;
-                block[i++] = 0x63;
-                block[i++] = 0;
-            }
-#endif
-
-            // LastMod
-            _TimeBlob = Ionic.Zip.SharedUtilities.DateTimeToPacked(LastModified);
-
-            // (i==10) time blob
-            block[i++] = (byte)(_TimeBlob & 0x000000FF);
-            block[i++] = (byte)((_TimeBlob & 0x0000FF00) >> 8);
-            block[i++] = (byte)((_TimeBlob & 0x00FF0000) >> 16);
-            block[i++] = (byte)((_TimeBlob & 0xFF000000) >> 24);
-
-            // (i==14) CRC - if source==filesystem, this is zero now, actual value
-            // will be calculated later.  if source==archive, this is a bonafide
-            // value.
-            block[i++] = (byte)(_Crc32 & 0x000000FF);
-            block[i++] = (byte)((_Crc32 & 0x0000FF00) >> 8);
-            block[i++] = (byte)((_Crc32 & 0x00FF0000) >> 16);
-            block[i++] = (byte)((_Crc32 & 0xFF000000) >> 24);
-
-            if (_presumeZip64)
-            {
-                // (i==18) CompressedSize (Int32) and UncompressedSize - all 0xFF for now
-                for (j = 0; j < 8; j++)
-                    block[i++] = 0xFF;
-            }
-            else
-            {
-                // (i==18) CompressedSize (Int32) - this value may or may not be
-                // bonafide.  if source == filesystem, then it is zero, and we'll
-                // learn it after we compress.  if source == archive, then it is
-                // bonafide data.
-                block[i++] = (byte)(_CompressedSize & 0x000000FF);
-                block[i++] = (byte)((_CompressedSize & 0x0000FF00) >> 8);
-                block[i++] = (byte)((_CompressedSize & 0x00FF0000) >> 16);
-                block[i++] = (byte)((_CompressedSize & 0xFF000000) >> 24);
-
-                // (i==22) UncompressedSize (Int32) - this value may or may not be
-                // bonafide.
-                block[i++] = (byte)(_UncompressedSize & 0x000000FF);
-                block[i++] = (byte)((_UncompressedSize & 0x0000FF00) >> 8);
-                block[i++] = (byte)((_UncompressedSize & 0x00FF0000) >> 16);
-                block[i++] = (byte)((_UncompressedSize & 0xFF000000) >> 24);
-            }
-
-            // (i==26) filename length (Int16)
-            block[i++] = (byte)(filenameLength & 0x00FF);
-            block[i++] = (byte)((filenameLength & 0xFF00) >> 8);
-
-            _Extra = ConstructExtraField(false);
-
-            // (i==28) extra field length (short)
-            Int16 extraFieldLength = (Int16)((_Extra == null) ? 0 : _Extra.Length);
-            block[i++] = (byte)(extraFieldLength & 0x00FF);
-            block[i++] = (byte)((extraFieldLength & 0xFF00) >> 8);
-
-            // workitem 13542
-            byte[] bytes = new byte[i + filenameLength + extraFieldLength];
-
-            // get the fixed portion
-            Buffer.BlockCopy(block, 0, bytes, 0, i);
-            //for (j = 0; j < i; j++) bytes[j] = block[j];
-
-            // The filename written to the archive.
-            Buffer.BlockCopy(fileNameBytes, 0, bytes, i, fileNameBytes.Length);
-            // for (j = 0; j < fileNameBytes.Length; j++)
-            //     bytes[i + j] = fileNameBytes[j];
-
-            i += fileNameBytes.Length;
-
-            // "Extra field"
-            if (_Extra != null)
-            {
-                Buffer.BlockCopy(_Extra, 0, bytes, i, _Extra.Length);
-                // for (j = 0; j < _Extra.Length; j++)
-                //     bytes[i + j] = _Extra[j];
-                i += _Extra.Length;
-            }
-
-            _LengthOfHeader = i;
-
-            // handle split archives
-            var zss = s as ZipSegmentedStream;
-            if (zss != null)
-            {
-                zss.ContiguousWrite = true;
-                UInt32 requiredSegment = zss.ComputeSegment(i);
-                if (requiredSegment != zss.CurrentSegment)
-                    _future_ROLH = 0; // rollover!
-                else
-                    _future_ROLH = zss.Position;
-
-                _diskNumber = requiredSegment;
-            }
-
-            // validate the ZIP64 usage
-            if (_container.Zip64 == Zip64Option.Never && (uint)_RelativeOffsetOfLocalHeader >= 0xFFFFFFFF)
-                throw new ZipException("Offset within the zip archive exceeds 0xFFFFFFFF. Consider setting the UseZip64WhenSaving property on the ZipFile instance.");
-
-
-            // finally, write the header to the stream
-            s.Write(bytes, 0, i);
-
-            // now that the header is written, we can turn off the contiguous write restriction.
-            if (zss != null)
-                zss.ContiguousWrite = false;
-
-            // Preserve this header data, we'll use it again later.
-            // ..when seeking backward, to write again, after we have the Crc, compressed
-            //   and uncompressed sizes.
-            // ..and when writing the central directory structure.
-            _EntryHeader = bytes;
-        }
-
-
-
-
-        private Int32 FigureCrc32()
-        {
-            if (_crcCalculated == false)
-            {
-                Stream input = null;
-                // get the original stream:
-                if (this._Source == ZipEntrySource.WriteDelegate)
-                {
-                    var output = new Ionic.Crc.CrcCalculatorStream(Stream.Null);
-                    // allow the application to write the data
-                    this._WriteDelegate(this.FileName, output);
-                    _Crc32 = output.Crc;
-                }
-                else if (this._Source == ZipEntrySource.ZipFile)
-                {
-                    // nothing to do - the CRC is already set
-                }
-                else
-                {
-                    if (this._Source == ZipEntrySource.Stream)
-                    {
-                        PrepSourceStream();
-                        input = this._sourceStream;
-                    }
-                    else if (this._Source == ZipEntrySource.JitStream)
-                    {
-                        // allow the application to open the stream
-                        if (this._sourceStream == null)
-                            _sourceStream = this._OpenDelegate(this.FileName);
-                        PrepSourceStream();
-                        input = this._sourceStream;
-                    }
-                    else if (this._Source == ZipEntrySource.ZipOutputStream)
-                    {
-                    }
-                    else
-                    {
-                        //input = File.OpenRead(LocalFileName);
-                        input = File.Open(LocalFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-                    }
-
-                    var crc32 = new Ionic.Crc.CRC32();
-                    _Crc32 = crc32.GetCrc32(input);
-
-                    if (_sourceStream == null)
-                    {
-#if NETCF
-                        input.Close();
-#else
-                        input.Dispose();
-#endif
-                    }
-                }
-                _crcCalculated = true;
-            }
-            return _Crc32;
-        }
-
-
-        /// <summary>
-        ///   Stores the position of the entry source stream, or, if the position is
-        ///   already stored, seeks to that position.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method is called in prep for reading the source stream.  If PKZIP
-        ///   encryption is used, then we need to calc the CRC32 before doing the
-        ///   encryption, because the CRC is used in the 12th byte of the PKZIP
-        ///   encryption header.  So, we need to be able to seek backward in the source
-        ///   when saving the ZipEntry. This method is called from the place that
-        ///   calculates the CRC, and also from the method that does the encryption of
-        ///   the file data.
-        /// </para>
-        ///
-        /// <para>
-        ///   The first time through, this method sets the _sourceStreamOriginalPosition
-        ///   field. Subsequent calls to this method seek to that position.
-        /// </para>
-        /// </remarks>
-        private void PrepSourceStream()
-        {
-            if (_sourceStream == null)
-                throw new ZipException(String.Format("The input stream is null for entry '{0}'.", FileName));
-
-            if (this._sourceStreamOriginalPosition != null)
-            {
-                // this will happen the 2nd cycle through, if the stream is seekable
-                this._sourceStream.Position = this._sourceStreamOriginalPosition.Value;
-            }
-            else if (this._sourceStream.CanSeek)
-            {
-                // this will happen the first cycle through, if seekable
-                this._sourceStreamOriginalPosition = new Nullable<Int64>(this._sourceStream.Position);
-            }
-            else if (this.Encryption == EncryptionAlgorithm.PkzipWeak)
-            {
-                // In general, using PKZIP encryption on a a zip entry whose input
-                // comes from a non-seekable stream, is tricky.  Here's why:
-                //
-                // Byte 11 of the PKZIP encryption header is used for password
-                // validation and consistency checknig.
-                //
-                // Normally, the highest byte of the CRC is used as the 11th (last) byte
-                // in the PKZIP encryption header. This means the CRC must be known
-                // before encryption is performed. Normally that means we read the full
-                // data stream, compute the CRC, then seek back and read it again for
-                // the compression+encryption phase. Obviously this is bad for
-                // performance with a large input file.
-                //
-                // There's a twist in the ZIP spec (actually documented only in infozip
-                // code, not in the spec itself) that allows the high-order byte of the
-                // last modified time for the entry, when the lastmod time is in packed
-                // (DOS) format, to be used for Byte 11 in the encryption header. In
-                // this case, the bit 3 "data descriptor" must be used.
-                //
-                // An intelligent implementation would therefore force the use of the
-                // bit 3 data descriptor when PKZIP encryption is in use, regardless.
-                // This avoids the double-read of the stream to be encrypted.  So far,
-                // DotNetZip doesn't do that; it just punts when the input stream is
-                // non-seekable, and the output does not use Bit 3.
-                //
-                // The other option is to use the CRC when it is already available, eg,
-                // when the source for the data is a ZipEntry (when the zip file is
-                // being updated). In this case we already know the CRC and can just use
-                // what we know.
-
-                if (this._Source != ZipEntrySource.ZipFile && ((this._BitField & 0x0008) != 0x0008))
-                    throw new ZipException("It is not possible to use PKZIP encryption on a non-seekable input stream");
-            }
-        }
-
-
-        /// <summary>
-        /// Copy metadata that may have been changed by the app.  We do this when
-        /// resetting the zipFile instance.  If the app calls Save() on a ZipFile, then
-        /// tries to party on that file some more, we may need to Reset() it , which
-        /// means re-reading the entries and then copying the metadata.  I think.
-        /// </summary>
-        internal void CopyMetaData(ZipEntry source)
-        {
-            this.__FileDataPosition = source.__FileDataPosition;
-            this.CompressionMethod = source.CompressionMethod;
-            this._CompressionMethod_FromZipFile = source._CompressionMethod_FromZipFile;
-            this._CompressedFileDataSize = source._CompressedFileDataSize;
-            this._UncompressedSize = source._UncompressedSize;
-            this._BitField = source._BitField;
-            this._Source = source._Source;
-            this._LastModified = source._LastModified;
-            this._Mtime = source._Mtime;
-            this._Atime = source._Atime;
-            this._Ctime = source._Ctime;
-            this._ntfsTimesAreSet = source._ntfsTimesAreSet;
-            this._emitUnixTimes = source._emitUnixTimes;
-            this._emitNtfsTimes = source._emitNtfsTimes;
-        }
-
-
-        private void OnWriteBlock(Int64 bytesXferred, Int64 totalBytesToXfer)
-        {
-            if (_container.ZipFile != null)
-                _ioOperationCanceled = _container.ZipFile.OnSaveBlock(this, bytesXferred, totalBytesToXfer);
-        }
-
-
-
-        private void _WriteEntryData(Stream s)
-        {
-            // Read in the data from the input stream (often a file in the filesystem),
-            // and write it to the output stream, calculating a CRC on it as we go.
-            // We will also compress and encrypt as necessary.
-
-            Stream input = null;
-            long fdp = -1L;
-            try
-            {
-                // Want to record the position in the zip file of the zip entry
-                // data (as opposed to the metadata).  s.Position may fail on some
-                // write-only streams, eg stdout or System.Web.HttpResponseStream.
-                // We swallow that exception, because we don't care, in that case.
-                // But, don't set __FileDataPosition directly.  It may be needed
-                // to READ the zip entry from the zip file, if this is a
-                // "re-stream" situation. In other words if the zip entry has
-                // changed compression level, or compression method, or (maybe?)
-                // encryption algorithm.  In that case if the original entry is
-                // encrypted, we need __FileDataPosition to be the value for the
-                // input zip file.  This s.Position is for the output zipfile.  So
-                // we copy fdp to __FileDataPosition after this entry has been
-                // (maybe) restreamed.
-                fdp = s.Position;
-            }
-            catch (Exception) { }
-
-            try
-            {
-                // Use fileLength for progress updates, and to decide whether we can
-                // skip encryption and compression altogether (in case of length==zero)
-                long fileLength = SetInputAndFigureFileLength(ref input);
-
-                // Wrap a counting stream around the raw output stream:
-                // This is the last thing that happens before the bits go to the
-                // application-provided stream.
-                //
-                // Sometimes s is a CountingStream. Doesn't matter. Wrap it with a
-                // counter anyway. We need to count at both levels.
-
-                CountingStream entryCounter = new CountingStream(s);
-
-                Stream encryptor;
-                Stream compressor;
-
-                if (fileLength != 0L)
-                {
-                    // Maybe wrap an encrypting stream around the counter: This will
-                    // happen BEFORE output counting, and AFTER compression, if encryption
-                    // is used.
-                    encryptor = MaybeApplyEncryption(entryCounter);
-
-                    // Maybe wrap a compressing Stream around that.
-                    // This will happen BEFORE encryption (if any) as we write data out.
-                    compressor = MaybeApplyCompression(encryptor, fileLength);
-                }
-                else
-                {
-                    encryptor = compressor = entryCounter;
-                }
-
-                // Wrap a CrcCalculatorStream around that.
-                // This will happen BEFORE compression (if any) as we write data out.
-                var output = new Ionic.Crc.CrcCalculatorStream(compressor, true);
-
-                // output.Write() causes this flow:
-                // calc-crc -> compress -> encrypt -> count -> actually write
-
-                if (this._Source == ZipEntrySource.WriteDelegate)
-                {
-                    // allow the application to write the data
-                    this._WriteDelegate(this.FileName, output);
-                }
-                else
-                {
-                    // synchronously copy the input stream to the output stream-chain
-                    byte[] buffer = new byte[BufferSize];
-                    int n;
-                    while ((n = SharedUtilities.ReadWithRetry(input, buffer, 0, buffer.Length, FileName)) != 0)
-                    {
-                        output.Write(buffer, 0, n);
-                        OnWriteBlock(output.TotalBytesSlurped, fileLength);
-                        if (_ioOperationCanceled)
-                            break;
-                    }
-                }
-
-                FinishOutputStream(s, entryCounter, encryptor, compressor, output);
-            }
-            finally
-            {
-                if (this._Source == ZipEntrySource.JitStream)
-                {
-                    // allow the application to close the stream
-                    if (this._CloseDelegate != null)
-                        this._CloseDelegate(this.FileName, input);
-                }
-                else if ((input as FileStream) != null)
-                {
-#if NETCF
-                    input.Close();
-#else
-                    input.Dispose();
-#endif
-                }
-            }
-
-            if (_ioOperationCanceled)
-                return;
-
-            // set FDP now, to allow for re-streaming
-            this.__FileDataPosition = fdp;
-            PostProcessOutput(s);
-        }
-
-
-        /// <summary>
-        ///   Set the input stream and get its length, if possible.  The length is
-        ///   used for progress updates, AND, to allow an optimization in case of
-        ///   a stream/file of zero length. In that case we skip the Encrypt and
-        ///   compression Stream. (like DeflateStream or BZip2OutputStream)
-        /// </summary>
-        private long SetInputAndFigureFileLength(ref Stream input)
-        {
-            long fileLength = -1L;
-            // get the original stream:
-            if (this._Source == ZipEntrySource.Stream)
-            {
-                PrepSourceStream();
-                input = this._sourceStream;
-
-                // Try to get the length, no big deal if not available.
-                try { fileLength = this._sourceStream.Length; }
-                catch (NotSupportedException) { }
-            }
-            else if (this._Source == ZipEntrySource.ZipFile)
-            {
-                // we are "re-streaming" the zip entry.
-                string pwd = (_Encryption_FromZipFile == EncryptionAlgorithm.None) ? null : (this._Password ?? this._container.Password);
-                this._sourceStream = InternalOpenReader(pwd);
-                PrepSourceStream();
-                input = this._sourceStream;
-                fileLength = this._sourceStream.Length;
-            }
-            else if (this._Source == ZipEntrySource.JitStream)
-            {
-                // allow the application to open the stream
-                if (this._sourceStream == null) _sourceStream = this._OpenDelegate(this.FileName);
-                PrepSourceStream();
-                input = this._sourceStream;
-                try { fileLength = this._sourceStream.Length; }
-                catch (NotSupportedException) { }
-            }
-            else if (this._Source == ZipEntrySource.FileSystem)
-            {
-                // workitem 7145
-                FileShare fs = FileShare.ReadWrite;
-#if !NETCF
-                // FileShare.Delete is not defined for the Compact Framework
-                fs |= FileShare.Delete;
-#endif
-                // workitem 8423
-                input = File.Open(LocalFileName, FileMode.Open, FileAccess.Read, fs);
-                fileLength = input.Length;
-            }
-
-            return fileLength;
-        }
-
-
-
-        internal void FinishOutputStream(Stream s,
-                                         CountingStream entryCounter,
-                                         Stream encryptor,
-                                         Stream compressor,
-                                         Ionic.Crc.CrcCalculatorStream output)
-        {
-            if (output == null) return;
-
-            output.Close();
-
-            // by calling Close() on the deflate stream, we write the footer bytes, as necessary.
-            if ((compressor as Ionic.Zlib.DeflateStream) != null)
-                compressor.Close();
-#if BZIP
-            else if ((compressor as Ionic.BZip2.BZip2OutputStream) != null)
-                compressor.Close();
-#if !NETCF
-            else if ((compressor as Ionic.BZip2.ParallelBZip2OutputStream) != null)
-                compressor.Close();
-#endif
-#endif
-
-#if !NETCF
-            else if ((compressor as Ionic.Zlib.ParallelDeflateOutputStream) != null)
-                compressor.Close();
-#endif
-
-            encryptor.Flush();
-            encryptor.Close();
-
-            _LengthOfTrailer = 0;
-
-            _UncompressedSize = output.TotalBytesSlurped;
-
-#if AESCRYPTO
-            WinZipAesCipherStream wzacs = encryptor as WinZipAesCipherStream;
-            if (wzacs != null && _UncompressedSize > 0)
-            {
-                s.Write(wzacs.FinalAuthentication, 0, 10);
-                _LengthOfTrailer += 10;
-            }
-#endif
-            _CompressedFileDataSize = entryCounter.BytesWritten;
-            _CompressedSize = _CompressedFileDataSize;   // may be adjusted
-            _Crc32 = output.Crc;
-
-            // Set _RelativeOffsetOfLocalHeader now, to allow for re-streaming
-            StoreRelativeOffset();
-        }
-
-
-
-
-        internal void PostProcessOutput(Stream s)
-        {
-            var s1 = s as CountingStream;
-
-            // workitem 8931 - for WriteDelegate.
-            // The WriteDelegate changes things because there can be a zero-byte stream
-            // written. In all other cases DotNetZip knows the length of the stream
-            // before compressing and encrypting. In this case we have to circle back,
-            // and omit all the crypto stuff - the GP bitfield, and the crypto header.
-            if (_UncompressedSize == 0 && _CompressedSize == 0)
-            {
-                if (this._Source == ZipEntrySource.ZipOutputStream) return;  // nothing to do...
-
-                if (_Password != null)
-                {
-                    int headerBytesToRetract = 0;
-                    if (Encryption == EncryptionAlgorithm.PkzipWeak)
-                        headerBytesToRetract = 12;
-#if AESCRYPTO
-                    else if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                             Encryption == EncryptionAlgorithm.WinZipAes256)
-                    {
-                        headerBytesToRetract = _aesCrypto_forWrite._Salt.Length + _aesCrypto_forWrite.GeneratedPV.Length;
-                    }
-#endif
-                    if (this._Source == ZipEntrySource.ZipOutputStream && !s.CanSeek)
-                        throw new ZipException("Zero bytes written, encryption in use, and non-seekable output.");
-
-                    if (Encryption != EncryptionAlgorithm.None)
-                    {
-                        // seek back in the stream to un-output the security metadata
-                        s.Seek(-1 * headerBytesToRetract, SeekOrigin.Current);
-                        s.SetLength(s.Position);
-                        // workitem 10178
-                        Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);
-
-                        // workitem 11131
-                        // adjust the count on the CountingStream as necessary
-                        if (s1 != null) s1.Adjust(headerBytesToRetract);
-
-                        // subtract the size of the security header from the _LengthOfHeader
-                        _LengthOfHeader -= headerBytesToRetract;
-                        __FileDataPosition -= headerBytesToRetract;
-                    }
-                    _Password = null;
-
-                    // turn off the encryption bit
-                    _BitField &= ~(0x0001);
-
-                    // copy the updated bitfield value into the header
-                    int j = 6;
-                    _EntryHeader[j++] = (byte)(_BitField & 0x00FF);
-                    _EntryHeader[j++] = (byte)((_BitField & 0xFF00) >> 8);
-
-#if AESCRYPTO
-                    if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                        Encryption == EncryptionAlgorithm.WinZipAes256)
-                    {
-                        // Fix the extra field - overwrite the 0x9901 headerId
-                        // with dummy data. (arbitrarily, 0x9999)
-                        Int16 fnLength = (short)(_EntryHeader[26] + _EntryHeader[27] * 256);
-                        int offx = 30 + fnLength;
-                        int aesIndex = FindExtraFieldSegment(_EntryHeader, offx, 0x9901);
-                        if (aesIndex >= 0)
-                        {
-                            _EntryHeader[aesIndex++] = 0x99;
-                            _EntryHeader[aesIndex++] = 0x99;
-                        }
-                    }
-#endif
-                }
-
-                CompressionMethod = 0;
-                Encryption = EncryptionAlgorithm.None;
-            }
-            else if (_zipCrypto_forWrite != null
-#if AESCRYPTO
-                     || _aesCrypto_forWrite != null
-#endif
-                     )
-
-            {
-                if (Encryption == EncryptionAlgorithm.PkzipWeak)
-                {
-                    _CompressedSize += 12; // 12 extra bytes for the encryption header
-                }
-#if AESCRYPTO
-                else if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                         Encryption == EncryptionAlgorithm.WinZipAes256)
-                {
-                    // adjust the compressed size to include the variable (salt+pv)
-                    // security header and 10-byte trailer. According to the winzip AES
-                    // spec, that metadata is included in the "Compressed Size" figure
-                    // when encoding the zip archive.
-                    _CompressedSize += _aesCrypto_forWrite.SizeOfEncryptionMetadata;
-                }
-#endif
-            }
-
-            int i = 8;
-            _EntryHeader[i++] = (byte)(_CompressionMethod & 0x00FF);
-            _EntryHeader[i++] = (byte)((_CompressionMethod & 0xFF00) >> 8);
-
-            i = 14;
-            // CRC - the correct value now
-            _EntryHeader[i++] = (byte)(_Crc32 & 0x000000FF);
-            _EntryHeader[i++] = (byte)((_Crc32 & 0x0000FF00) >> 8);
-            _EntryHeader[i++] = (byte)((_Crc32 & 0x00FF0000) >> 16);
-            _EntryHeader[i++] = (byte)((_Crc32 & 0xFF000000) >> 24);
-
-            SetZip64Flags();
-
-            // (i==26) filename length (Int16)
-            Int16 filenameLength = (short)(_EntryHeader[26] + _EntryHeader[27] * 256);
-            Int16 extraFieldLength = (short)(_EntryHeader[28] + _EntryHeader[29] * 256);
-
-            if (_OutputUsesZip64.Value)
-            {
-                // VersionNeededToExtract - set to 45 to indicate zip64
-                _EntryHeader[4] = (byte)(45 & 0x00FF);
-                _EntryHeader[5] = 0x00;
-
-                // workitem 7924 - don't need bit 3
-                // // workitem 7917
-                // // set bit 3 for ZIP64 compatibility with WinZip12
-                // _BitField |= 0x0008;
-                // _EntryHeader[6] = (byte)(_BitField & 0x00FF);
-
-                // CompressedSize and UncompressedSize - 0xFF
-                for (int j = 0; j < 8; j++)
-                    _EntryHeader[i++] = 0xff;
-
-                // At this point we need to find the "Extra field" that follows the
-                // filename.  We had already emitted it, but the data (uncomp, comp,
-                // ROLH) was not available at the time we did so.  Here, we emit it
-                // again, with final values.
-
-                i = 30 + filenameLength;
-                _EntryHeader[i++] = 0x01;  // zip64
-                _EntryHeader[i++] = 0x00;
-
-                i += 2; // skip over data size, which is 16+4
-
-                Array.Copy(BitConverter.GetBytes(_UncompressedSize), 0, _EntryHeader, i, 8);
-                i += 8;
-                Array.Copy(BitConverter.GetBytes(_CompressedSize), 0, _EntryHeader, i, 8);
-            }
-            else
-            {
-                // VersionNeededToExtract - reset to 20 since no zip64
-                _EntryHeader[4] = (byte)(20 & 0x00FF);
-                _EntryHeader[5] = 0x00;
-
-                // CompressedSize - the correct value now
-                i = 18;
-                _EntryHeader[i++] = (byte)(_CompressedSize & 0x000000FF);
-                _EntryHeader[i++] = (byte)((_CompressedSize & 0x0000FF00) >> 8);
-                _EntryHeader[i++] = (byte)((_CompressedSize & 0x00FF0000) >> 16);
-                _EntryHeader[i++] = (byte)((_CompressedSize & 0xFF000000) >> 24);
-
-                // UncompressedSize - the correct value now
-                _EntryHeader[i++] = (byte)(_UncompressedSize & 0x000000FF);
-                _EntryHeader[i++] = (byte)((_UncompressedSize & 0x0000FF00) >> 8);
-                _EntryHeader[i++] = (byte)((_UncompressedSize & 0x00FF0000) >> 16);
-                _EntryHeader[i++] = (byte)((_UncompressedSize & 0xFF000000) >> 24);
-
-                // The HeaderId in the extra field header, is already dummied out.
-                if (extraFieldLength != 0)
-                {
-                    i = 30 + filenameLength;
-                    // For zip archives written by this library, if the zip64
-                    // header exists, it is the first header. Because of the logic
-                    // used when first writing the _EntryHeader bytes, the
-                    // HeaderId is not guaranteed to be any particular value.  So
-                    // we determine if the first header is a putative zip64 header
-                    // by examining the datasize.  UInt16 HeaderId =
-                    // (UInt16)(_EntryHeader[i] + _EntryHeader[i + 1] * 256);
-                    Int16 DataSize = (short)(_EntryHeader[i + 2] + _EntryHeader[i + 3] * 256);
-                    if (DataSize == 16)
-                    {
-                        // reset to Header Id to dummy value, effectively dummy-ing out the zip64 metadata
-                        _EntryHeader[i++] = 0x99;
-                        _EntryHeader[i++] = 0x99;
-                    }
-                }
-            }
-
-
-#if AESCRYPTO
-
-            if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                // Must set compressionmethod to 0x0063 (decimal 99)
-                //
-                // and then set the compression method bytes inside the extra
-                // field to the actual compression method value.
-
-                i = 8;
-                _EntryHeader[i++] = 0x63;
-                _EntryHeader[i++] = 0;
-
-                i = 30 + filenameLength;
-                do
-                {
-                    UInt16 HeaderId = (UInt16)(_EntryHeader[i] + _EntryHeader[i + 1] * 256);
-                    Int16 DataSize = (short)(_EntryHeader[i + 2] + _EntryHeader[i + 3] * 256);
-                    if (HeaderId != 0x9901)
-                    {
-                        // skip this header
-                        i += DataSize + 4;
-                    }
-                    else
-                    {
-                        i += 9;
-                        // actual compression method
-                        _EntryHeader[i++] = (byte)(_CompressionMethod & 0x00FF);
-                        _EntryHeader[i++] = (byte)(_CompressionMethod & 0xFF00);
-                    }
-                } while (i < (extraFieldLength - 30 - filenameLength));
-            }
-#endif
-
-            // finally, write the data.
-
-            // workitem 7216 - sometimes we don't seek even if we CAN.  ASP.NET
-            // Response.OutputStream, or stdout are non-seekable.  But we may also want
-            // to NOT seek in other cases, eg zip64.  For all cases, we just check bit 3
-            // to see if we want to seek.  There's one exception - if using a
-            // ZipOutputStream, and PKZip encryption is in use, then we set bit 3 even
-            // if the out is seekable. This is so the check on the last byte of the
-            // PKZip Encryption Header can be done on the current time, as opposed to
-            // the CRC, to prevent streaming the file twice.  So, test for
-            // ZipOutputStream and seekable, and if so, seek back, even if bit 3 is set.
-
-            if ((_BitField & 0x0008) != 0x0008 ||
-                 (this._Source == ZipEntrySource.ZipOutputStream && s.CanSeek))
-            {
-                // seek back and rewrite the entry header
-                var zss = s as ZipSegmentedStream;
-                if (zss != null && _diskNumber != zss.CurrentSegment)
-                {
-                    // In this case the entry header is in a different file,
-                    // which has already been closed. Need to re-open it.
-                    using (Stream hseg = ZipSegmentedStream.ForUpdate(this._container.ZipFile.Name, _diskNumber))
-                    {
-                        hseg.Seek(this._RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-                        hseg.Write(_EntryHeader, 0, _EntryHeader.Length);
-                    }
-                }
-                else
-                {
-                    // seek in the raw output stream, to the beginning of the header for
-                    // this entry.
-                    // workitem 8098: ok (output)
-                    s.Seek(this._RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-
-                    // write the updated header to the output stream
-                    s.Write(_EntryHeader, 0, _EntryHeader.Length);
-
-                    // adjust the count on the CountingStream as necessary
-                    if (s1 != null) s1.Adjust(_EntryHeader.Length);
-
-                    // seek in the raw output stream, to the end of the file data
-                    // for this entry
-                    s.Seek(_CompressedSize, SeekOrigin.Current);
-                }
-            }
-
-            // emit the descriptor - only if not a directory.
-            if (((_BitField & 0x0008) == 0x0008) && !IsDirectory)
-            {
-                byte[] Descriptor = new byte[16 + (_OutputUsesZip64.Value ? 8 : 0)];
-                i = 0;
-
-                // signature
-                Array.Copy(BitConverter.GetBytes(ZipConstants.ZipEntryDataDescriptorSignature), 0, Descriptor, i, 4);
-                i += 4;
-
-                // CRC - the correct value now
-                Array.Copy(BitConverter.GetBytes(_Crc32), 0, Descriptor, i, 4);
-                i += 4;
-
-                // workitem 7917
-                if (_OutputUsesZip64.Value)
-                {
-                    // CompressedSize - the correct value now
-                    Array.Copy(BitConverter.GetBytes(_CompressedSize), 0, Descriptor, i, 8);
-                    i += 8;
-
-                    // UncompressedSize - the correct value now
-                    Array.Copy(BitConverter.GetBytes(_UncompressedSize), 0, Descriptor, i, 8);
-                    i += 8;
-                }
-                else
-                {
-                    // CompressedSize - (lower 32 bits) the correct value now
-                    Descriptor[i++] = (byte)(_CompressedSize & 0x000000FF);
-                    Descriptor[i++] = (byte)((_CompressedSize & 0x0000FF00) >> 8);
-                    Descriptor[i++] = (byte)((_CompressedSize & 0x00FF0000) >> 16);
-                    Descriptor[i++] = (byte)((_CompressedSize & 0xFF000000) >> 24);
-
-                    // UncompressedSize - (lower 32 bits) the correct value now
-                    Descriptor[i++] = (byte)(_UncompressedSize & 0x000000FF);
-                    Descriptor[i++] = (byte)((_UncompressedSize & 0x0000FF00) >> 8);
-                    Descriptor[i++] = (byte)((_UncompressedSize & 0x00FF0000) >> 16);
-                    Descriptor[i++] = (byte)((_UncompressedSize & 0xFF000000) >> 24);
-                }
-
-                // finally, write the trailing descriptor to the output stream
-                s.Write(Descriptor, 0, Descriptor.Length);
-
-                _LengthOfTrailer += Descriptor.Length;
-            }
-        }
-
-
-
-        private void SetZip64Flags()
-        {
-            // zip64 housekeeping
-            _entryRequiresZip64 = new Nullable<bool>
-                (_CompressedSize >= 0xFFFFFFFF || _UncompressedSize >= 0xFFFFFFFF || _RelativeOffsetOfLocalHeader >= 0xFFFFFFFF);
-
-            // validate the ZIP64 usage
-            if (_container.Zip64 == Zip64Option.Never && _entryRequiresZip64.Value)
-                throw new ZipException("Compressed or Uncompressed size, or offset exceeds the maximum value. Consider setting the UseZip64WhenSaving property on the ZipFile instance.");
-
-            _OutputUsesZip64 = new Nullable<bool>(_container.Zip64 == Zip64Option.Always || _entryRequiresZip64.Value);
-        }
-
-
-
-        /// <summary>
-        ///   Prepare the given stream for output - wrap it in a CountingStream, and
-        ///   then in a CRC stream, and an encryptor and deflator as appropriate.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Previously this was used in ZipEntry.Write(), but in an effort to
-        ///     introduce some efficiencies in that method I've refactored to put the
-        ///     code inline.  This method still gets called by ZipOutputStream.
-        ///   </para>
-        /// </remarks>
-        internal void PrepOutputStream(Stream s,
-                                       long streamLength,
-                                       out CountingStream outputCounter,
-                                       out Stream encryptor,
-                                       out Stream compressor,
-                                       out Ionic.Crc.CrcCalculatorStream output)
-        {
-            TraceWriteLine("PrepOutputStream: e({0}) comp({1}) crypto({2}) zf({3})",
-                           FileName,
-                           CompressionLevel,
-                           Encryption,
-                           _container.Name);
-
-            // Wrap a counting stream around the raw output stream:
-            // This is the last thing that happens before the bits go to the
-            // application-provided stream.
-            outputCounter = new CountingStream(s);
-
-            // Sometimes the incoming "raw" output stream is already a CountingStream.
-            // Doesn't matter. Wrap it with a counter anyway. We need to count at both
-            // levels.
-
-            if (streamLength != 0L)
-            {
-                // Maybe wrap an encrypting stream around that:
-                // This will happen BEFORE output counting, and AFTER deflation, if encryption
-                // is used.
-                encryptor = MaybeApplyEncryption(outputCounter);
-
-                // Maybe wrap a compressing Stream around that.
-                // This will happen BEFORE encryption (if any) as we write data out.
-                compressor = MaybeApplyCompression(encryptor, streamLength);
-            }
-            else
-            {
-                encryptor = compressor = outputCounter;
-            }
-            // Wrap a CrcCalculatorStream around that.
-            // This will happen BEFORE compression (if any) as we write data out.
-            output = new Ionic.Crc.CrcCalculatorStream(compressor, true);
-        }
-
-
-
-        private Stream MaybeApplyCompression(Stream s, long streamLength)
-        {
-            if (_CompressionMethod == 0x08 && CompressionLevel != Ionic.Zlib.CompressionLevel.None)
-            {
-#if !NETCF
-                // ParallelDeflateThreshold == 0    means ALWAYS use parallel deflate
-                // ParallelDeflateThreshold == -1L  means NEVER use parallel deflate
-                // Other values specify the actual threshold.
-                if (_container.ParallelDeflateThreshold == 0L ||
-                    (streamLength > _container.ParallelDeflateThreshold &&
-                     _container.ParallelDeflateThreshold > 0L))
-                {
-                    // This is sort of hacky.
-                    //
-                    // It's expensive to create a ParallelDeflateOutputStream, because
-                    // of the large memory buffers.  But the class is unlike most Stream
-                    // classes in that it can be re-used, so the caller can compress
-                    // multiple files with it, one file at a time.  The key is to call
-                    // Reset() on it, in between uses.
-                    //
-                    // The ParallelDeflateOutputStream is attached to the container
-                    // itself - there is just one for the entire ZipFile or
-                    // ZipOutputStream. So it gets created once, per save, and then
-                    // re-used many times.
-                    //
-                    // This approach will break when we go to a "parallel save"
-                    // approach, where multiple entries within the zip file are being
-                    // compressed and saved at the same time.  But for now it's ok.
-                    //
-
-                    // instantiate the ParallelDeflateOutputStream
-                    if (_container.ParallelDeflater == null)
-                    {
-                        _container.ParallelDeflater =
-                            new ParallelDeflateOutputStream(s,
-                                                                        CompressionLevel,
-                                                                       _container.Strategy,
-                                                                       true);
-                        // can set the codec buffer size only before the first call to Write().
-                        if (_container.CodecBufferSize > 0)
-                            _container.ParallelDeflater.BufferSize = _container.CodecBufferSize;
-                        if (_container.ParallelDeflateMaxBufferPairs > 0)
-                            _container.ParallelDeflater.MaxBufferPairs =
-                                _container.ParallelDeflateMaxBufferPairs;
-                    }
-                    // reset it with the new stream
-                    Ionic.Zlib.ParallelDeflateOutputStream o1 = _container.ParallelDeflater;
-                    o1.Reset(s);
-                    return o1;
-                }
-#endif
-                var o = new DeflateStream(s, OfficeOpenXml.Packaging.Ionic.Zlib.CompressionMode.Compress,
-                                                     CompressionLevel,
-                                                     true);
-                if (_container.CodecBufferSize > 0)
-                    o.BufferSize = _container.CodecBufferSize;
-                o.Strategy = _container.Strategy;
-                return o;
-            }
-
-
-#if BZIP
-            if (_CompressionMethod == 0x0c)
-            {
-#if !NETCF
-                if (_container.ParallelDeflateThreshold == 0L ||
-                    (streamLength > _container.ParallelDeflateThreshold &&
-                     _container.ParallelDeflateThreshold > 0L))
-                {
-
-                    var o1 = new Ionic.BZip2.ParallelBZip2OutputStream(s, true);
-                    return o1;
-                }
-#endif
-                var o = new Ionic.BZip2.BZip2OutputStream(s, true);
-                return o;
-            }
-#endif
-
-            return s;
-        }
-
-
-
-        private Stream MaybeApplyEncryption(Stream s)
-        {
-            if (Encryption == EncryptionAlgorithm.PkzipWeak)
-            {
-                TraceWriteLine("MaybeApplyEncryption: e({0}) PKZIP", FileName);
-
-                return new ZipCipherStream(s, _zipCrypto_forWrite, CryptoMode.Encrypt);
-            }
-#if AESCRYPTO
-            if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                     Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                TraceWriteLine("MaybeApplyEncryption: e({0}) AES", FileName);
-
-                return new WinZipAesCipherStream(s, _aesCrypto_forWrite, CryptoMode.Encrypt);
-            }
-#endif
-            TraceWriteLine("MaybeApplyEncryption: e({0}) None", FileName);
-
-            return s;
-        }
-
-
-
-        private void OnZipErrorWhileSaving(Exception e)
-        {
-            if (_container.ZipFile != null)
-                _ioOperationCanceled = _container.ZipFile.OnZipErrorSaving(this, e);
-        }
-
-
-
-        internal void Write(Stream s)
-        {
-            var cs1 = s as CountingStream;
-            var zss1 = s as ZipSegmentedStream;
-
-            bool done = false;
-            do
-            {
-                try
-                {
-                    // When the app is updating a zip file, it may be possible to
-                    // just copy data for a ZipEntry from the source zipfile to the
-                    // destination, as a block, without decompressing and
-                    // recompressing, etc.  But, in some cases the app modifies the
-                    // properties on a ZipEntry prior to calling Save(). A change to
-                    // any of the metadata - the FileName, CompressioLeve and so on,
-                    // means DotNetZip cannot simply copy through the existing
-                    // ZipEntry data unchanged.
-                    //
-                    // There are two cases:
-                    //
-                    //  1. Changes to only metadata, which means the header and
-                    //     central directory must be changed.
-                    //
-                    //  2. Changes to the properties that affect the compressed
-                    //     stream, such as CompressionMethod, CompressionLevel, or
-                    //     EncryptionAlgorithm. In this case, DotNetZip must
-                    //     "re-stream" the data: the old entry data must be maybe
-                    //     decrypted, maybe decompressed, then maybe re-compressed
-                    //     and maybe re-encrypted.
-                    //
-                    // This test checks if the source for the entry data is a zip file, and
-                    // if a restream is necessary.  If NOT, then it just copies through
-                    // one entry, potentially changing the metadata.
-
-                    if (_Source == ZipEntrySource.ZipFile && !_restreamRequiredOnSave)
-                    {
-                        CopyThroughOneEntry(s);
-                        return;
-                    }
-
-                    // Is the entry a directory?  If so, the write is relatively simple.
-                    if (IsDirectory)
-                    {
-                        WriteHeader(s, 1);
-                        StoreRelativeOffset();
-                        _entryRequiresZip64 = new Nullable<bool>(_RelativeOffsetOfLocalHeader >= 0xFFFFFFFF);
-                        _OutputUsesZip64 = new Nullable<bool>(_container.Zip64 == Zip64Option.Always || _entryRequiresZip64.Value);
-                        // handle case for split archives
-                        if (zss1 != null)
-                            _diskNumber = zss1.CurrentSegment;
-
-                        return;
-                    }
-
-                    // At this point, the source for this entry is not a directory, and
-                    // not a previously created zip file, or the source for the entry IS
-                    // a previously created zip but the settings whave changed in
-                    // important ways and therefore we will need to process the
-                    // bytestream (compute crc, maybe compress, maybe encrypt) in order
-                    // to write the content into the new zip.
-                    //
-                    // We do this in potentially 2 passes: The first time we do it as
-                    // requested, maybe with compression and maybe encryption.  If that
-                    // causes the bytestream to inflate in size, and if compression was
-                    // on, then we turn off compression and do it again.
-
-
-                    bool readAgain = true;
-                    int nCycles = 0;
-                    do
-                    {
-                        nCycles++;
-
-                        WriteHeader(s, nCycles);
-
-                        // write the encrypted header
-                        WriteSecurityMetadata(s);
-
-                        // write the (potentially compressed, potentially encrypted) file data
-                        _WriteEntryData(s);
-
-                        // track total entry size (including the trailing descriptor and MAC)
-                        _TotalEntrySize = _LengthOfHeader + _CompressedFileDataSize + _LengthOfTrailer;
-
-                        // The file data has now been written to the stream, and
-                        // the file pointer is positioned directly after file data.
-
-                        if (nCycles > 1) readAgain = false;
-                        else if (!s.CanSeek) readAgain = false;
-                        else readAgain = WantReadAgain();
-
-                        if (readAgain)
-                        {
-                            // Seek back in the raw output stream, to the beginning of the file
-                            // data for this entry.
-
-                            // handle case for split archives
-                            if (zss1 != null)
-                            {
-                                // Console.WriteLine("***_diskNumber/first: {0}", _diskNumber);
-                                // Console.WriteLine("***_diskNumber/current: {0}", zss.CurrentSegment);
-                                zss1.TruncateBackward(_diskNumber, _RelativeOffsetOfLocalHeader);
-                            }
-                            else
-                                // workitem 8098: ok (output).
-                                s.Seek(_RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-
-                            // If the last entry expands, we read again; but here, we must
-                            // truncate the stream to prevent garbage data after the
-                            // end-of-central-directory.
-
-                            // workitem 8098: ok (output).
-                            s.SetLength(s.Position);
-
-                            // Adjust the count on the CountingStream as necessary.
-                            if (cs1 != null) cs1.Adjust(_TotalEntrySize);
-                        }
-                    }
-                    while (readAgain);
-                    _skippedDuringSave = false;
-                    done = true;
-                }
-                catch (System.Exception exc1)
-                {
-                    ZipErrorAction orig = this.ZipErrorAction;
-                    int loop = 0;
-                    do
-                    {
-                        if (ZipErrorAction == ZipErrorAction.Throw)
-                            throw;
-
-                        if (ZipErrorAction == ZipErrorAction.Skip ||
-                            ZipErrorAction == ZipErrorAction.Retry)
-                        {
-                            // must reset file pointer here.
-                            // workitem 13903 - seek back only when necessary
-                            long p1 = (cs1 != null)
-                                ? cs1.ComputedPosition
-                                : s.Position;
-                            long delta = p1 - _future_ROLH;
-                            if (delta > 0)
-                            {
-                                s.Seek(delta, SeekOrigin.Current); // may throw
-                                long p2 = s.Position;
-                                s.SetLength(s.Position);  // to prevent garbage if this is the last entry
-                                if (cs1 != null) cs1.Adjust(p1 - p2);
-                            }
-                            if (ZipErrorAction == ZipErrorAction.Skip)
-                            {
-                                WriteStatus("Skipping file {0} (exception: {1})", LocalFileName, exc1.ToString());
-
-                                _skippedDuringSave = true;
-                                done = true;
-                            }
-                            else
-                                this.ZipErrorAction = orig;
-                            break;
-                        }
-
-                        if (loop > 0) throw;
-
-                        if (ZipErrorAction == ZipErrorAction.InvokeErrorEvent)
-                        {
-                            OnZipErrorWhileSaving(exc1);
-                            if (_ioOperationCanceled)
-                            {
-                                done = true;
-                                break;
-                            }
-                        }
-                        loop++;
-                    }
-                    while (true);
-                }
-            }
-            while (!done);
-        }
-
-
-        internal void StoreRelativeOffset()
-        {
-            _RelativeOffsetOfLocalHeader = _future_ROLH;
-        }
-
-
-
-        internal void NotifySaveComplete()
-        {
-            // When updating a zip file, there are two contexts for properties
-            // like Encryption or CompressionMethod - the values read from the
-            // original zip file, and the values used in the updated zip file.
-            // The _FromZipFile versions are the originals.  At the end of a save,
-            // these values are the same.  So we need to update them.  This takes
-            // care of the boundary case where a single zipfile instance can be
-            // saved multiple times, with distinct changes to the properties on
-            // the entries, in between each Save().
-            _Encryption_FromZipFile = _Encryption;
-            _CompressionMethod_FromZipFile = _CompressionMethod;
-            _restreamRequiredOnSave = false;
-            _metadataChanged = false;
-            //_Source = ZipEntrySource.None;
-            _Source = ZipEntrySource.ZipFile; // workitem 10694
-        }
-
-
-        internal void WriteSecurityMetadata(Stream outstream)
-        {
-            if (Encryption == EncryptionAlgorithm.None)
-                return;
-
-            string pwd = this._Password;
-
-            // special handling for source == ZipFile.
-            // Want to support the case where we re-stream an encrypted entry. This will involve,
-            // at runtime, reading, decrypting, and decompressing from the original zip file, then
-            // compressing, encrypting, and writing to the output zip file.
-
-            // If that's what we're doing, and the password hasn't been set on the entry,
-            // we use the container (ZipFile/ZipOutputStream) password to decrypt.
-            // This test here says to use the container password to re-encrypt, as well,
-            // with that password, if the entry password is null.
-
-            if (this._Source == ZipEntrySource.ZipFile && pwd == null)
-                pwd = this._container.Password;
-
-            if (pwd == null)
-            {
-                _zipCrypto_forWrite = null;
-#if AESCRYPTO
-                _aesCrypto_forWrite = null;
-#endif
-                return;
-            }
-
-            TraceWriteLine("WriteSecurityMetadata: e({0}) crypto({1}) pw({2})",
-                           FileName, Encryption.ToString(), pwd);
-
-            if (Encryption == EncryptionAlgorithm.PkzipWeak)
-            {
-                // If PKZip (weak) encryption is in use, then the encrypted entry data
-                // is preceded by 12-byte "encryption header" for the entry.
-
-                _zipCrypto_forWrite = ZipCrypto.ForWrite(pwd);
-
-                // generate the random 12-byte header:
-                var rnd = new System.Random();
-                byte[] encryptionHeader = new byte[12];
-                rnd.NextBytes(encryptionHeader);
-
-                // workitem 8271
-                if ((this._BitField & 0x0008) == 0x0008)
-                {
-                    // In the case that bit 3 of the general purpose bit flag is set to
-                    // indicate the presence of a 'data descriptor' (signature
-                    // 0x08074b50), the last byte of the decrypted header is sometimes
-                    // compared with the high-order byte of the lastmodified time,
-                    // rather than the high-order byte of the CRC, to verify the
-                    // password.
-                    //
-                    // This is not documented in the PKWare Appnote.txt.
-                    // This was discovered this by analysis of the Crypt.c source file in the
-                    // InfoZip library
-                    // http://www.info-zip.org/pub/infozip/
-
-                    // Also, winzip insists on this!
-                    _TimeBlob = Ionic.Zip.SharedUtilities.DateTimeToPacked(LastModified);
-                    encryptionHeader[11] = (byte)((this._TimeBlob >> 8) & 0xff);
-                }
-                else
-                {
-                    // When bit 3 is not set, the CRC value is required before
-                    // encryption of the file data begins. In this case there is no way
-                    // around it: must read the stream in its entirety to compute the
-                    // actual CRC before proceeding.
-                    FigureCrc32();
-                    encryptionHeader[11] = (byte)((this._Crc32 >> 24) & 0xff);
-                }
-
-                // Encrypt the random header, INCLUDING the final byte which is either
-                // the high-order byte of the CRC32, or the high-order byte of the
-                // _TimeBlob.  Must do this BEFORE encrypting the file data.  This
-                // step changes the state of the cipher, or in the words of the PKZIP
-                // spec, it "further initializes" the cipher keys.
-
-                byte[] cipherText = _zipCrypto_forWrite.EncryptMessage(encryptionHeader, encryptionHeader.Length);
-
-                // Write the ciphered bonafide encryption header.
-                outstream.Write(cipherText, 0, cipherText.Length);
-                _LengthOfHeader += cipherText.Length;  // 12 bytes
-            }
-
-#if AESCRYPTO
-            else if (Encryption == EncryptionAlgorithm.WinZipAes128 ||
-                Encryption == EncryptionAlgorithm.WinZipAes256)
-            {
-                // If WinZip AES encryption is in use, then the encrypted entry data is
-                // preceded by a variable-sized Salt and a 2-byte "password
-                // verification" value for the entry.
-
-                int keystrength = GetKeyStrengthInBits(Encryption);
-                _aesCrypto_forWrite = WinZipAesCrypto.Generate(pwd, keystrength);
-                outstream.Write(_aesCrypto_forWrite.Salt, 0, _aesCrypto_forWrite._Salt.Length);
-                outstream.Write(_aesCrypto_forWrite.GeneratedPV, 0, _aesCrypto_forWrite.GeneratedPV.Length);
-                _LengthOfHeader += _aesCrypto_forWrite._Salt.Length + _aesCrypto_forWrite.GeneratedPV.Length;
-
-                TraceWriteLine("WriteSecurityMetadata: AES e({0}) keybits({1}) _LOH({2})",
-                               FileName, keystrength, _LengthOfHeader);
-
-            }
-#endif
-
-        }
-
-
-
-        private void CopyThroughOneEntry(Stream outStream)
-        {
-            // Just read the entry from the existing input zipfile and write to the output.
-            // But, if metadata has changed (like file times or attributes), or if the ZIP64
-            // option has changed, we can re-stream the entry data but must recompute the
-            // metadata.
-            if (this.LengthOfHeader == 0)
-                throw new BadStateException("Bad header length.");
-
-            // is it necessary to re-constitute new metadata for this entry?
-            bool needRecompute = _metadataChanged ||
-                (this.ArchiveStream is ZipSegmentedStream) ||
-                (outStream is ZipSegmentedStream) ||
-                (_InputUsesZip64 && _container.UseZip64WhenSaving == Zip64Option.Never) ||
-                (!_InputUsesZip64 && _container.UseZip64WhenSaving == Zip64Option.Always);
-
-            if (needRecompute)
-                CopyThroughWithRecompute(outStream);
-            else
-                CopyThroughWithNoChange(outStream);
-
-            // zip64 housekeeping
-            _entryRequiresZip64 = new Nullable<bool>
-                (_CompressedSize >= 0xFFFFFFFF || _UncompressedSize >= 0xFFFFFFFF ||
-                _RelativeOffsetOfLocalHeader >= 0xFFFFFFFF
-                );
-
-            _OutputUsesZip64 = new Nullable<bool>(_container.Zip64 == Zip64Option.Always || _entryRequiresZip64.Value);
-        }
-
-
-
-        private void CopyThroughWithRecompute(Stream outstream)
-        {
-            int n;
-            byte[] bytes = new byte[BufferSize];
-            var input = new CountingStream(this.ArchiveStream);
-
-            long origRelativeOffsetOfHeader = _RelativeOffsetOfLocalHeader;
-
-            // The header length may change due to rename of file, add a comment, etc.
-            // We need to retain the original.
-            int origLengthOfHeader = LengthOfHeader; // including crypto bytes!
-
-            // WriteHeader() has the side effect of changing _RelativeOffsetOfLocalHeader
-            // and setting _LengthOfHeader.  While ReadHeader() reads the crypto header if
-            // present, WriteHeader() does not write the crypto header.
-            WriteHeader(outstream, 0);
-            StoreRelativeOffset();
-
-            if (!this.FileName.EndsWith("/"))
-            {
-                // Not a directory; there is file data.
-                // Seek to the beginning of the entry data in the input stream.
-
-                long pos = origRelativeOffsetOfHeader + origLengthOfHeader;
-                int len = GetLengthOfCryptoHeaderBytes(_Encryption_FromZipFile);
-                pos -= len; // want to keep the crypto header
-                _LengthOfHeader += len;
-
-                input.Seek(pos, SeekOrigin.Begin);
-
-                // copy through everything after the header to the output stream
-                long remaining = this._CompressedSize;
-
-                while (remaining > 0)
-                {
-                    len = (remaining > bytes.Length) ? bytes.Length : (int)remaining;
-
-                    // read
-                    n = input.Read(bytes, 0, len);
-                    //_CheckRead(n);
-
-                    // write
-                    outstream.Write(bytes, 0, n);
-                    remaining -= n;
-                    OnWriteBlock(input.BytesRead, this._CompressedSize);
-                    if (_ioOperationCanceled)
-                        break;
-                }
-
-                // bit 3 descriptor
-                if ((this._BitField & 0x0008) == 0x0008)
-                {
-                    int size = 16;
-                    if (_InputUsesZip64) size += 8;
-                    byte[] Descriptor = new byte[size];
-                    input.Read(Descriptor, 0, size);
-
-                    if (_InputUsesZip64 && _container.UseZip64WhenSaving == Zip64Option.Never)
-                    {
-                        // original descriptor was 24 bytes, now we need 16.
-                        // Must check for underflow here.
-                        // signature + CRC.
-                        outstream.Write(Descriptor, 0, 8);
-
-                        // Compressed
-                        if (_CompressedSize > 0xFFFFFFFF)
-                            throw new InvalidOperationException("ZIP64 is required");
-                        outstream.Write(Descriptor, 8, 4);
-
-                        // UnCompressed
-                        if (_UncompressedSize > 0xFFFFFFFF)
-                            throw new InvalidOperationException("ZIP64 is required");
-                        outstream.Write(Descriptor, 16, 4);
-                        _LengthOfTrailer -= 8;
-                    }
-                    else if (!_InputUsesZip64 && _container.UseZip64WhenSaving == Zip64Option.Always)
-                    {
-                        // original descriptor was 16 bytes, now we need 24
-                        // signature + CRC
-                        byte[] pad = new byte[4];
-                        outstream.Write(Descriptor, 0, 8);
-                        // Compressed
-                        outstream.Write(Descriptor, 8, 4);
-                        outstream.Write(pad, 0, 4);
-                        // UnCompressed
-                        outstream.Write(Descriptor, 12, 4);
-                        outstream.Write(pad, 0, 4);
-                        _LengthOfTrailer += 8;
-                    }
-                    else
-                    {
-                        // same descriptor on input and output. Copy it through.
-                        outstream.Write(Descriptor, 0, size);
-                        //_LengthOfTrailer += size;
-                    }
-                }
-            }
-
-            _TotalEntrySize = _LengthOfHeader + _CompressedFileDataSize + _LengthOfTrailer;
-        }
-
-
-        private void CopyThroughWithNoChange(Stream outstream)
-        {
-            int n;
-            byte[] bytes = new byte[BufferSize];
-            var input = new CountingStream(this.ArchiveStream);
-
-            // seek to the beginning of the entry data in the input stream
-            input.Seek(this._RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-
-            if (this._TotalEntrySize == 0)
-            {
-                // We've never set the length of the entry.
-                // Set it here.
-                this._TotalEntrySize = this._LengthOfHeader + this._CompressedFileDataSize + _LengthOfTrailer;
-
-                // The CompressedSize includes all the leading metadata associated
-                // to encryption, if any, as well as the compressed data, or
-                // compressed-then-encrypted data, and the trailer in case of AES.
-
-                // The CompressedFileData size is the same, less the encryption
-                // framing data (12 bytes header for PKZip; 10/18 bytes header and
-                // 10 byte trailer for AES).
-
-                // The _LengthOfHeader includes all the zip entry header plus the
-                // crypto header, if any.  The _LengthOfTrailer includes the
-                // 10-byte MAC for AES, where appropriate, and the bit-3
-                // Descriptor, where applicable.
-            }
-
-
-            // workitem 5616
-            // remember the offset, within the output stream, of this particular entry header.
-            // This may have changed if any of the other entries changed (eg, if a different
-            // entry was removed or added.)
-            var counter = outstream as CountingStream;
-            _RelativeOffsetOfLocalHeader = (counter != null)
-                ? counter.ComputedPosition
-                : outstream.Position;  // BytesWritten
-
-            // copy through the header, filedata, trailer, everything...
-            long remaining = this._TotalEntrySize;
-            while (remaining > 0)
-            {
-                int len = (remaining > bytes.Length) ? bytes.Length : (int)remaining;
-
-                // read
-                n = input.Read(bytes, 0, len);
-                //_CheckRead(n);
-
-                // write
-                outstream.Write(bytes, 0, n);
-                remaining -= n;
-                OnWriteBlock(input.BytesRead, this._TotalEntrySize);
-                if (_ioOperationCanceled)
-                    break;
-            }
-        }
-
-
-
-
-        [System.Diagnostics.ConditionalAttribute("Trace")]
-        private void TraceWriteLine(string format, params object[] varParams)
-        {
-            lock (_outputLock)
-            {
-                int tid = System.Threading.Thread.CurrentThread.GetHashCode();
-#if ! (NETCF || SILVERLIGHT)
-                Console.ForegroundColor = (ConsoleColor)(tid % 8 + 8);
-#endif
-                Console.Write("{0:000} ZipEntry.Write ", tid);
-                Console.WriteLine(format, varParams);
-#if ! (NETCF || SILVERLIGHT)
-                Console.ResetColor();
-#endif
-            }
-        }
-
-        private object _outputLock = new Object();
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipEntry.cs b/EPPlus/Packaging/DotNetZip/ZipEntry.cs
deleted file mode 100644
index 7d727d0..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipEntry.cs
+++ /dev/null
@@ -1,2968 +0,0 @@
-// ZipEntry.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006-2010 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-06 17:25:53>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZipEntry class, which models the entries within a zip file.
-//
-// Created: Tue, 27 Mar 2007  15:30
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-using Interop = System.Runtime.InteropServices;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// Represents a single entry in a ZipFile. Typically, applications get a ZipEntry
-    /// by enumerating the entries within a ZipFile, or by adding an entry to a ZipFile.
-    /// </summary>
-
-    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00004")]
-    [Interop.ComVisible(true)]
-#if !NETCF
-    [Interop.ClassInterface(Interop.ClassInterfaceType.AutoDispatch)]  // AutoDual
-#endif
-    internal partial class ZipEntry
-    {
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        /// <remarks>
-        /// Applications should never need to call this directly.  It is exposed to
-        /// support COM Automation environments.
-        /// </remarks>
-        public ZipEntry()
-        {
-            _CompressionMethod = (Int16)CompressionMethod.Deflate;
-            _CompressionLevel = Ionic.Zlib.CompressionLevel.Default;
-            _Encryption = EncryptionAlgorithm.None;
-            _Source = ZipEntrySource.None;
-            AlternateEncoding = System.Text.Encoding.ASCII;
-            AlternateEncodingUsage = ZipOption.Never;
-        }
-
-        /// <summary>
-        ///   The time and date at which the file indicated by the <c>ZipEntry</c> was
-        ///   last modified.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The DotNetZip library sets the LastModified value for an entry, equal to
-        ///   the Last Modified time of the file in the filesystem.  If an entry is
-        ///   added from a stream, the library uses <c>System.DateTime.Now</c> for this
-        ///   value, for the given entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property allows the application to retrieve and possibly set the
-        ///   LastModified value on an entry, to an arbitrary value.  <see
-        ///   cref="System.DateTime"/> values with a <see cref="System.DateTimeKind" />
-        ///   setting of <c>DateTimeKind.Unspecified</c> are taken to be expressed as
-        ///   <c>DateTimeKind.Local</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Be aware that because of the way <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWare's
-        ///   Zip specification</see> describes how times are stored in the zip file,
-        ///   the full precision of the <c>System.DateTime</c> datatype is not stored
-        ///   for the last modified time when saving zip files.  For more information on
-        ///   how times are formatted, see the PKZip specification.
-        /// </para>
-        ///
-        /// <para>
-        ///   The actual last modified time of a file can be stored in multiple ways in
-        ///   the zip file, and they are not mutually exclusive:
-        /// </para>
-        ///
-        /// <list type="bullet">
-        ///   <item>
-        ///     In the so-called "DOS" format, which has a 2-second precision. Values
-        ///     are rounded to the nearest even second. For example, if the time on the
-        ///     file is 12:34:43, then it will be stored as 12:34:44. This first value
-        ///     is accessible via the <c>LastModified</c> property. This value is always
-        ///     present in the metadata for each zip entry.  In some cases the value is
-        ///     invalid, or zero.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     In the so-called "Windows" or "NTFS" format, as an 8-byte integer
-        ///     quantity expressed as the number of 1/10 milliseconds (in other words
-        ///     the number of 100 nanosecond units) since January 1, 1601 (UTC).  This
-        ///     format is how Windows represents file times.  This time is accessible
-        ///     via the <c>ModifiedTime</c> property.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     In the "Unix" format, a 4-byte quantity specifying the number of seconds since
-        ///     January 1, 1970 UTC.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     In an older format, now deprecated but still used by some current
-        ///     tools. This format is also a 4-byte quantity specifying the number of
-        ///     seconds since January 1, 1970 UTC.
-        ///   </item>
-        ///
-        /// </list>
-        ///
-        /// <para>
-        ///   Zip tools and libraries will always at least handle (read or write) the
-        ///   DOS time, and may also handle the other time formats.  Keep in mind that
-        ///   while the names refer to particular operating systems, there is nothing in
-        ///   the time formats themselves that prevents their use on other operating
-        ///   systems.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading ZIP files, the DotNetZip library reads the Windows-formatted
-        ///   time, if it is stored in the entry, and sets both <c>LastModified</c> and
-        ///   <c>ModifiedTime</c> to that value. When writing ZIP files, the DotNetZip
-        ///   library by default will write both time quantities. It can also emit the
-        ///   Unix-formatted time if desired (See <see
-        ///   cref="EmitTimesInUnixFormatWhenSaving"/>.)
-        /// </para>
-        ///
-        /// <para>
-        ///   The last modified time of the file created upon a call to
-        ///   <c>ZipEntry.Extract()</c> may be adjusted during extraction to compensate
-        ///   for differences in how the .NET Base Class Library deals with daylight
-        ///   saving time (DST) versus how the Windows filesystem deals with daylight
-        ///   saving time.  Raymond Chen <see
-        ///   href="http://blogs.msdn.com/oldnewthing/archive/2003/10/24/55413.aspx">provides
-        ///   some good context</see>.
-        /// </para>
-        ///
-        /// <para>
-        ///   In a nutshell: Daylight savings time rules change regularly.  In 2007, for
-        ///   example, the inception week of DST changed.  In 1977, DST was in place all
-        ///   year round. In 1945, likewise.  And so on.  Win32 does not attempt to
-        ///   guess which time zone rules were in effect at the time in question.  It
-        ///   will render a time as "standard time" and allow the app to change to DST
-        ///   as necessary.  .NET makes a different choice.
-        /// </para>
-        ///
-        /// <para>
-        ///   Compare the output of FileInfo.LastWriteTime.ToString("f") with what you
-        ///   see in the Windows Explorer property sheet for a file that was last
-        ///   written to on the other side of the DST transition. For example, suppose
-        ///   the file was last modified on October 17, 2003, during DST but DST is not
-        ///   currently in effect. Explorer's file properties reports Thursday, October
-        ///   17, 2003, 8:45:38 AM, but .NETs FileInfo reports Thursday, October 17,
-        ///   2003, 9:45 AM.
-        /// </para>
-        ///
-        /// <para>
-        ///   Win32 says, "Thursday, October 17, 2002 8:45:38 AM PST". Note: Pacific
-        ///   STANDARD Time. Even though October 17 of that year occurred during Pacific
-        ///   Daylight Time, Win32 displays the time as standard time because that's
-        ///   what time it is NOW.
-        /// </para>
-        ///
-        /// <para>
-        ///   .NET BCL assumes that the current DST rules were in place at the time in
-        ///   question.  So, .NET says, "Well, if the rules in effect now were also in
-        ///   effect on October 17, 2003, then that would be daylight time" so it
-        ///   displays "Thursday, October 17, 2003, 9:45 AM PDT" - daylight time.
-        /// </para>
-        ///
-        /// <para>
-        ///   So .NET gives a value which is more intuitively correct, but is also
-        ///   potentially incorrect, and which is not invertible. Win32 gives a value
-        ///   which is intuitively incorrect, but is strictly correct.
-        /// </para>
-        ///
-        /// <para>
-        ///   Because of this funkiness, this library adds one hour to the LastModified
-        ///   time on the extracted file, if necessary.  That is to say, if the time in
-        ///   question had occurred in what the .NET Base Class Library assumed to be
-        ///   DST. This assumption may be wrong given the constantly changing DST rules,
-        ///   but it is the best we can do.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        public DateTime LastModified
-        {
-            get { return _LastModified.ToLocalTime(); }
-            set
-            {
-                _LastModified = (value.Kind == DateTimeKind.Unspecified)
-                    ? DateTime.SpecifyKind(value, DateTimeKind.Local)
-                    : value.ToLocalTime();
-                _Mtime = Ionic.Zip.SharedUtilities.AdjustTime_Reverse(_LastModified).ToUniversalTime();
-                _metadataChanged = true;
-            }
-        }
-
-
-        private int BufferSize
-        {
-            get
-            {
-                return this._container.BufferSize;
-            }
-        }
-
-        /// <summary>
-        /// Last Modified time for the file represented by the entry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This value corresponds to the "last modified" time in the NTFS file times
-        ///   as described in <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip
-        ///   specification</see>.  When getting this property, the value may be
-        ///   different from <see cref="LastModified" />.  When setting the property,
-        ///   the <see cref="LastModified"/> property also gets set, but with a lower
-        ///   precision.
-        /// </para>
-        ///
-        /// <para>
-        ///   Let me explain. It's going to take a while, so get
-        ///   comfortable. Originally, waaaaay back in 1989 when the ZIP specification
-        ///   was originally described by the esteemed Mr. Phil Katz, the dominant
-        ///   operating system of the time was MS-DOS. MSDOS stored file times with a
-        ///   2-second precision, because, c'mon, <em>who is ever going to need better
-        ///   resolution than THAT?</em> And so ZIP files, regardless of the platform on
-        ///   which the zip file was created, store file times in exactly <see
-        ///   href="http://www.vsft.com/hal/dostime.htm">the same format that DOS used
-        ///   in 1989</see>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Since then, the ZIP spec has evolved, but the internal format for file
-        ///   timestamps remains the same.  Despite the fact that the way times are
-        ///   stored in a zip file is rooted in DOS heritage, any program on any
-        ///   operating system can format a time in this way, and most zip tools and
-        ///   libraries DO - they round file times to the nearest even second and store
-        ///   it just like DOS did 25+ years ago.
-        /// </para>
-        ///
-        /// <para>
-        ///   PKWare extended the ZIP specification to allow a zip file to store what
-        ///   are called "NTFS Times" and "Unix(tm) times" for a file.  These are the
-        ///   <em>last write</em>, <em>last access</em>, and <em>file creation</em>
-        ///   times of a particular file. These metadata are not actually specific
-        ///   to NTFS or Unix. They are tracked for each file by NTFS and by various
-        ///   Unix filesystems, but they are also tracked by other filesystems, too.
-        ///   The key point is that the times are <em>formatted in the zip file</em>
-        ///   in the same way that NTFS formats the time (ticks since win32 epoch),
-        ///   or in the same way that Unix formats the time (seconds since Unix
-        ///   epoch). As with the DOS time, any tool or library running on any
-        ///   operating system is capable of formatting a time in one of these ways
-        ///   and embedding it into the zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   These extended times are higher precision quantities than the DOS time.
-        ///   As described above, the (DOS) LastModified has a precision of 2 seconds.
-        ///   The Unix time is stored with a precision of 1 second. The NTFS time is
-        ///   stored with a precision of 0.0000001 seconds. The quantities are easily
-        ///   convertible, except for the loss of precision you may incur.
-        /// </para>
-        ///
-        /// <para>
-        ///   A zip archive can store the {C,A,M} times in NTFS format, in Unix format,
-        ///   or not at all.  Often a tool running on Unix or Mac will embed the times
-        ///   in Unix format (1 second precision), while WinZip running on Windows might
-        ///   embed the times in NTFS format (precision of of 0.0000001 seconds).  When
-        ///   reading a zip file with these "extended" times, in either format,
-        ///   DotNetZip represents the values with the
-        ///   <c>ModifiedTime</c>, <c>AccessedTime</c> and <c>CreationTime</c>
-        ///   properties on the <c>ZipEntry</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   While any zip application or library, regardless of the platform it
-        ///   runs on, could use any of the time formats allowed by the ZIP
-        ///   specification, not all zip tools or libraries do support all these
-        ///   formats.  Storing the higher-precision times for each entry is
-        ///   optional for zip files, and many tools and libraries don't use the
-        ///   higher precision quantities at all. The old DOS time, represented by
-        ///   <see cref="LastModified"/>, is guaranteed to be present, though it
-        ///   sometimes unset.
-        /// </para>
-        ///
-        /// <para>
-        ///   Ok, getting back to the question about how the <c>LastModified</c>
-        ///   property relates to this <c>ModifiedTime</c>
-        ///   property... <c>LastModified</c> is always set, while
-        ///   <c>ModifiedTime</c> is not. (The other times stored in the <em>NTFS
-        ///   times extension</em>, <c>CreationTime</c> and <c>AccessedTime</c> also
-        ///   may not be set on an entry that is read from an existing zip file.)
-        ///   When reading a zip file, then <c>LastModified</c> takes the DOS time
-        ///   that is stored with the file. If the DOS time has been stored as zero
-        ///   in the zipfile, then this library will use <c>DateTime.Now</c> for the
-        ///   <c>LastModified</c> value.  If the ZIP file was created by an evolved
-        ///   tool, then there will also be higher precision NTFS or Unix times in
-        ///   the zip file.  In that case, this library will read those times, and
-        ///   set <c>LastModified</c> and <c>ModifiedTime</c> to the same value, the
-        ///   one corresponding to the last write time of the file.  If there are no
-        ///   higher precision times stored for the entry, then <c>ModifiedTime</c>
-        ///   remains unset (likewise <c>AccessedTime</c> and <c>CreationTime</c>),
-        ///   and <c>LastModified</c> keeps its DOS time.
-        /// </para>
-        ///
-        /// <para>
-        ///   When creating zip files with this library, by default the extended time
-        ///   properties (<c>ModifiedTime</c>, <c>AccessedTime</c>, and
-        ///   <c>CreationTime</c>) are set on the ZipEntry instance, and these data are
-        ///   stored in the zip archive for each entry, in NTFS format. If you add an
-        ///   entry from an actual filesystem file, then the entry gets the actual file
-        ///   times for that file, to NTFS-level precision.  If you add an entry from a
-        ///   stream, or a string, then the times get the value <c>DateTime.Now</c>.  In
-        ///   this case <c>LastModified</c> and <c>ModifiedTime</c> will be identical,
-        ///   to 2 seconds of precision.  You can explicitly set the
-        ///   <c>CreationTime</c>, <c>AccessedTime</c>, and <c>ModifiedTime</c> of an
-        ///   entry using the property setters.  If you want to set all of those
-        ///   quantities, it's more efficient to use the <see
-        ///   cref="SetEntryTimes(DateTime, DateTime, DateTime)"/> method.  Those
-        ///   changes are not made permanent in the zip file until you call <see
-        ///   cref="ZipFile.Save()"/> or one of its cousins.
-        /// </para>
-        ///
-        /// <para>
-        ///   When creating a zip file, you can override the default behavior of
-        ///   this library for formatting times in the zip file, disabling the
-        ///   embedding of file times in NTFS format or enabling the storage of file
-        ///   times in Unix format, or both.  You may want to do this, for example,
-        ///   when creating a zip file on Windows, that will be consumed on a Mac,
-        ///   by an application that is not hip to the "NTFS times" format. To do
-        ///   this, use the <see cref="EmitTimesInWindowsFormatWhenSaving"/> and
-        ///   <see cref="EmitTimesInUnixFormatWhenSaving"/> properties.  A valid zip
-        ///   file may store the file times in both formats.  But, there are no
-        ///   guarantees that a program running on Mac or Linux will gracefully
-        ///   handle the NTFS-formatted times when Unix times are present, or that a
-        ///   non-DotNetZip-powered application running on Windows will be able to
-        ///   handle file times in Unix format. DotNetZip will always do something
-        ///   reasonable; other libraries or tools may not. When in doubt, test.
-        /// </para>
-        ///
-        /// <para>
-        ///   I'll bet you didn't think one person could type so much about time, eh?
-        ///   And reading it was so enjoyable, too!  Well, in appreciation, <see
-        ///   href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">maybe you
-        ///   should donate</see>?
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="AccessedTime"/>
-        /// <seealso cref="CreationTime"/>
-        /// <seealso cref="Ionic.Zip.ZipEntry.LastModified"/>
-        /// <seealso cref="SetEntryTimes"/>
-        public DateTime ModifiedTime
-        {
-            get { return _Mtime; }
-            set
-            {
-                SetEntryTimes(_Ctime, _Atime, value);
-            }
-        }
-
-        /// <summary>
-        /// Last Access time for the file represented by the entry.
-        /// </summary>
-        /// <remarks>
-        /// This value may or may not be meaningful.  If the <c>ZipEntry</c> was read from an existing
-        /// Zip archive, this information may not be available. For an explanation of why, see
-        /// <see cref="ModifiedTime"/>.
-        /// </remarks>
-        /// <seealso cref="ModifiedTime"/>
-        /// <seealso cref="CreationTime"/>
-        /// <seealso cref="SetEntryTimes"/>
-        public DateTime AccessedTime
-        {
-            get { return _Atime; }
-            set
-            {
-                SetEntryTimes(_Ctime, value, _Mtime);
-            }
-        }
-
-        /// <summary>
-        /// The file creation time for the file represented by the entry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// This value may or may not be meaningful.  If the <c>ZipEntry</c> was read
-        /// from an existing zip archive, and the creation time was not set on the entry
-        /// when the zip file was created, then this property may be meaningless. For an
-        /// explanation of why, see <see cref="ModifiedTime"/>.
-        /// </remarks>
-        /// <seealso cref="ModifiedTime"/>
-        /// <seealso cref="AccessedTime"/>
-        /// <seealso cref="SetEntryTimes"/>
-        public DateTime CreationTime
-        {
-            get { return _Ctime; }
-            set
-            {
-                SetEntryTimes(value, _Atime, _Mtime);
-            }
-        }
-
-        /// <summary>
-        ///   Sets the NTFS Creation, Access, and Modified times for the given entry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   When adding an entry from a file or directory, the Creation, Access, and
-        ///   Modified times for the given entry are automatically set from the
-        ///   filesystem values. When adding an entry from a stream or string, the
-        ///   values are implicitly set to DateTime.Now.  The application may wish to
-        ///   set these values to some arbitrary value, before saving the archive, and
-        ///   can do so using the various setters.  If you want to set all of the times,
-        ///   this method is more efficient.
-        /// </para>
-        ///
-        /// <para>
-        ///   The values you set here will be retrievable with the <see
-        ///   cref="ModifiedTime"/>, <see cref="CreationTime"/> and <see
-        ///   cref="AccessedTime"/> properties.
-        /// </para>
-        ///
-        /// <para>
-        ///   When this method is called, if both <see
-        ///   cref="EmitTimesInWindowsFormatWhenSaving"/> and <see
-        ///   cref="EmitTimesInUnixFormatWhenSaving"/> are false, then the
-        ///   <c>EmitTimesInWindowsFormatWhenSaving</c> flag is automatically set.
-        /// </para>
-        ///
-        /// <para>
-        ///   DateTime values provided here without a DateTimeKind are assumed to be Local Time.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <param name="created">the creation time of the entry.</param>
-        /// <param name="accessed">the last access time of the entry.</param>
-        /// <param name="modified">the last modified time of the entry.</param>
-        ///
-        /// <seealso cref="EmitTimesInWindowsFormatWhenSaving" />
-        /// <seealso cref="EmitTimesInUnixFormatWhenSaving" />
-        /// <seealso cref="AccessedTime"/>
-        /// <seealso cref="CreationTime"/>
-        /// <seealso cref="ModifiedTime"/>
-        public void SetEntryTimes(DateTime created, DateTime accessed, DateTime modified)
-        {
-            _ntfsTimesAreSet = true;
-            if (created == _zeroHour && created.Kind == _zeroHour.Kind) created = _win32Epoch;
-            if (accessed == _zeroHour && accessed.Kind == _zeroHour.Kind) accessed = _win32Epoch;
-            if (modified == _zeroHour && modified.Kind == _zeroHour.Kind) modified = _win32Epoch;
-            _Ctime = created.ToUniversalTime();
-            _Atime = accessed.ToUniversalTime();
-            _Mtime = modified.ToUniversalTime();
-            _LastModified = _Mtime;
-            if (!_emitUnixTimes && !_emitNtfsTimes)
-                _emitNtfsTimes = true;
-            _metadataChanged = true;
-        }
-
-
-
-        /// <summary>
-        ///   Specifies whether the Creation, Access, and Modified times for the given
-        ///   entry will be emitted in "Windows format" when the zip archive is saved.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   An application creating a zip archive can use this flag to explicitly
-        ///   specify that the file times for the entry should or should not be stored
-        ///   in the zip archive in the format used by Windows. The default value of
-        ///   this property is <c>true</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   When adding an entry from a file or directory, the Creation (<see
-        ///   cref="CreationTime"/>), Access (<see cref="AccessedTime"/>), and Modified
-        ///   (<see cref="ModifiedTime"/>) times for the given entry are automatically
-        ///   set from the filesystem values. When adding an entry from a stream or
-        ///   string, all three values are implicitly set to DateTime.Now.  Applications
-        ///   can also explicitly set those times by calling <see
-        ///   cref="SetEntryTimes(DateTime, DateTime, DateTime)" />.
-        /// </para>
-        ///
-        /// <para>
-        ///   <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see> describes multiple ways to format these times in a
-        ///   zip file. One is the format Windows applications normally use: 100ns ticks
-        ///   since Jan 1, 1601 UTC.  The other is a format Unix applications typically
-        ///   use: seconds since January 1, 1970 UTC.  Each format can be stored in an
-        ///   "extra field" in the zip entry when saving the zip archive. The former
-        ///   uses an extra field with a Header Id of 0x000A, while the latter uses a
-        ///   header ID of 0x5455.
-        /// </para>
-        ///
-        /// <para>
-        ///   Not all zip tools and libraries can interpret these fields.  Windows
-        ///   compressed folders is one that can read the Windows Format timestamps,
-        ///   while I believe the <see href="http://www.info-zip.org/">Infozip</see>
-        ///   tools can read the Unix format timestamps. Although the time values are
-        ///   easily convertible, subject to a loss of precision, some tools and
-        ///   libraries may be able to read only one or the other. DotNetZip can read or
-        ///   write times in either or both formats.
-        /// </para>
-        ///
-        /// <para>
-        ///   The times stored are taken from <see cref="ModifiedTime"/>, <see
-        ///   cref="AccessedTime"/>, and <see cref="CreationTime"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not mutually exclusive from the <see
-        ///   cref="ZipEntry.EmitTimesInUnixFormatWhenSaving"/> property.  It is
-        ///   possible that a zip entry can embed the timestamps in both forms, one
-        ///   form, or neither.  But, there are no guarantees that a program running on
-        ///   Mac or Linux will gracefully handle NTFS Formatted times, or that a
-        ///   non-DotNetZip-powered application running on Windows will be able to
-        ///   handle file times in Unix format. When in doubt, test.
-        /// </para>
-        ///
-        /// <para>
-        ///   Normally you will use the <see
-        ///   cref="ZipFile.EmitTimesInWindowsFormatWhenSaving">ZipFile.EmitTimesInWindowsFormatWhenSaving</see>
-        ///   property, to specify the behavior for all entries in a zip, rather than
-        ///   the property on each individual entry.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="SetEntryTimes(DateTime, DateTime, DateTime)"/>
-        /// <seealso cref="EmitTimesInUnixFormatWhenSaving"/>
-        /// <seealso cref="CreationTime"/>
-        /// <seealso cref="AccessedTime"/>
-        /// <seealso cref="ModifiedTime"/>
-        public bool EmitTimesInWindowsFormatWhenSaving
-        {
-            get
-            {
-                return _emitNtfsTimes;
-            }
-            set
-            {
-                _emitNtfsTimes = value;
-                _metadataChanged = true;
-            }
-        }
-
-        /// <summary>
-        ///   Specifies whether the Creation, Access, and Modified times for the given
-        ///   entry will be emitted in &quot;Unix(tm) format&quot; when the zip archive is saved.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   An application creating a zip archive can use this flag to explicitly
-        ///   specify that the file times for the entry should or should not be stored
-        ///   in the zip archive in the format used by Unix. By default this flag is
-        ///   <c>false</c>, meaning the Unix-format times are not stored in the zip
-        ///   archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   When adding an entry from a file or directory, the Creation (<see
-        ///   cref="CreationTime"/>), Access (<see cref="AccessedTime"/>), and Modified
-        ///   (<see cref="ModifiedTime"/>) times for the given entry are automatically
-        ///   set from the filesystem values. When adding an entry from a stream or
-        ///   string, all three values are implicitly set to DateTime.Now.  Applications
-        ///   can also explicitly set those times by calling <see
-        ///   cref="SetEntryTimes(DateTime, DateTime, DateTime)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see> describes multiple ways to format these times in a
-        ///   zip file. One is the format Windows applications normally use: 100ns ticks
-        ///   since Jan 1, 1601 UTC.  The other is a format Unix applications typically
-        ///   use: seconds since Jan 1, 1970 UTC.  Each format can be stored in an
-        ///   "extra field" in the zip entry when saving the zip archive. The former
-        ///   uses an extra field with a Header Id of 0x000A, while the latter uses a
-        ///   header ID of 0x5455.
-        /// </para>
-        ///
-        /// <para>
-        ///   Not all tools and libraries can interpret these fields.  Windows
-        ///   compressed folders is one that can read the Windows Format timestamps,
-        ///   while I believe the <see href="http://www.info-zip.org/">Infozip</see>
-        ///   tools can read the Unix format timestamps. Although the time values are
-        ///   easily convertible, subject to a loss of precision, some tools and
-        ///   libraries may be able to read only one or the other. DotNetZip can read or
-        ///   write times in either or both formats.
-        /// </para>
-        ///
-        /// <para>
-        ///   The times stored are taken from <see cref="ModifiedTime"/>, <see
-        ///   cref="AccessedTime"/>, and <see cref="CreationTime"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not mutually exclusive from the <see
-        ///   cref="ZipEntry.EmitTimesInWindowsFormatWhenSaving"/> property.  It is
-        ///   possible that a zip entry can embed the timestamps in both forms, one
-        ///   form, or neither.  But, there are no guarantees that a program running on
-        ///   Mac or Linux will gracefully handle NTFS Formatted times, or that a
-        ///   non-DotNetZip-powered application running on Windows will be able to
-        ///   handle file times in Unix format. When in doubt, test.
-        /// </para>
-        ///
-        /// <para>
-        ///   Normally you will use the <see
-        ///   cref="ZipFile.EmitTimesInUnixFormatWhenSaving">ZipFile.EmitTimesInUnixFormatWhenSaving</see>
-        ///   property, to specify the behavior for all entries, rather than the
-        ///   property on each individual entry.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="SetEntryTimes(DateTime, DateTime, DateTime)"/>
-        /// <seealso cref="EmitTimesInWindowsFormatWhenSaving"/>
-        /// <seealso cref="ZipFile.EmitTimesInUnixFormatWhenSaving"/>
-        /// <seealso cref="CreationTime"/>
-        /// <seealso cref="AccessedTime"/>
-        /// <seealso cref="ModifiedTime"/>
-        public bool EmitTimesInUnixFormatWhenSaving
-        {
-            get
-            {
-                return _emitUnixTimes;
-            }
-            set
-            {
-                _emitUnixTimes = value;
-                _metadataChanged = true;
-            }
-        }
-
-
-        /// <summary>
-        /// The type of timestamp attached to the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// This property is valid only for a ZipEntry that was read from a zip archive.
-        /// It indicates the type of timestamp attached to the entry.
-        /// </remarks>
-        ///
-        /// <seealso cref="EmitTimesInWindowsFormatWhenSaving"/>
-        /// <seealso cref="EmitTimesInUnixFormatWhenSaving"/>
-        internal ZipEntryTimestamp Timestamp
-        {
-            get
-            {
-                return _timestamp;
-            }
-        }
-
-        /// <summary>
-        ///   The file attributes for the entry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The <see cref="System.IO.FileAttributes">attributes</see> in NTFS include
-        ///   ReadOnly, Archive, Hidden, System, and Indexed.  When adding a
-        ///   <c>ZipEntry</c> to a ZipFile, these attributes are set implicitly when
-        ///   adding an entry from the filesystem.  When adding an entry from a stream
-        ///   or string, the Attributes are not set implicitly.  Regardless of the way
-        ///   an entry was added to a <c>ZipFile</c>, you can set the attributes
-        ///   explicitly if you like.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading a <c>ZipEntry</c> from a <c>ZipFile</c>, the attributes are
-        ///   set according to the data stored in the <c>ZipFile</c>. If you extract the
-        ///   entry from the archive to a filesystem file, DotNetZip will set the
-        ///   attributes on the resulting file accordingly.
-        /// </para>
-        ///
-        /// <para>
-        ///   The attributes can be set explicitly by the application.  For example the
-        ///   application may wish to set the <c>FileAttributes.ReadOnly</c> bit for all
-        ///   entries added to an archive, so that on unpack, this attribute will be set
-        ///   on the extracted file.  Any changes you make to this property are made
-        ///   permanent only when you call a <c>Save()</c> method on the <c>ZipFile</c>
-        ///   instance that contains the ZipEntry.
-        /// </para>
-        ///
-        /// <para>
-        ///   For example, an application may wish to zip up a directory and set the
-        ///   ReadOnly bit on every file in the archive, so that upon later extraction,
-        ///   the resulting files will be marked as ReadOnly.  Not every extraction tool
-        ///   respects these attributes, but if you unpack with DotNetZip, as for
-        ///   example in a self-extracting archive, then the attributes will be set as
-        ///   they are stored in the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   These attributes may not be interesting or useful if the resulting archive
-        ///   is extracted on a non-Windows platform.  How these attributes get used
-        ///   upon extraction depends on the platform and tool used.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is only partially supported in the Silverlight version
-        ///   of the library: applications can read attributes on entries within
-        ///   ZipFiles. But extracting entries within Silverlight will not set the
-        ///   attributes on the extracted files.
-        /// </para>
-        ///
-        /// </remarks>
-        public System.IO.FileAttributes Attributes
-        {
-            // workitem 7071
-            get { return (System.IO.FileAttributes)_ExternalFileAttrs; }
-            set
-            {
-                _ExternalFileAttrs = (int)value;
-                // Since the application is explicitly setting the attributes, overwriting
-                // whatever was there, we will explicitly set the Version made by field.
-                // workitem 7926 - "version made by" OS should be zero for compat with WinZip
-                _VersionMadeBy = (0 << 8) + 45;  // v4.5 of the spec
-                _metadataChanged = true;
-            }
-        }
-
-
-        /// <summary>
-        ///   The name of the filesystem file, referred to by the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    This property specifies the thing-to-be-zipped on disk, and is set only
-        ///    when the <c>ZipEntry</c> is being created from a filesystem file.  If the
-        ///    <c>ZipFile</c> is instantiated by reading an existing .zip archive, then
-        ///    the LocalFileName will be <c>null</c> (<c>Nothing</c> in VB).
-        ///  </para>
-        ///
-        ///  <para>
-        ///    When it is set, the value of this property may be different than <see
-        ///    cref="FileName"/>, which is the path used in the archive itself.  If you
-        ///    call <c>Zip.AddFile("foop.txt", AlternativeDirectory)</c>, then the path
-        ///    used for the <c>ZipEntry</c> within the zip archive will be different
-        ///    than this path.
-        ///  </para>
-        ///
-        ///  <para>
-        ///   If the entry is being added from a stream, then this is null (Nothing in VB).
-        ///  </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="FileName"/>
-        internal string LocalFileName
-        {
-            get { return _LocalFileName; }
-        }
-
-        /// <summary>
-        ///   The name of the file contained in the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This is the name of the entry in the <c>ZipFile</c> itself.  When creating
-        ///   a zip archive, if the <c>ZipEntry</c> has been created from a filesystem
-        ///   file, via a call to <see cref="ZipFile.AddFile(String,String)"/> or <see
-        ///   cref="ZipFile.AddItem(String,String)"/>, or a related overload, the value
-        ///   of this property is derived from the name of that file. The
-        ///   <c>FileName</c> property does not include drive letters, and may include a
-        ///   different directory path, depending on the value of the
-        ///   <c>directoryPathInArchive</c> parameter used when adding the entry into
-        ///   the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   In some cases there is no related filesystem file - for example when a
-        ///   <c>ZipEntry</c> is created using <see cref="ZipFile.AddEntry(string,
-        ///   string)"/> or one of the similar overloads.  In this case, the value of
-        ///   this property is derived from the fileName and the directory path passed
-        ///   to that method.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading a zip file, this property takes the value of the entry name
-        ///   as stored in the zip file. If you extract such an entry, the extracted
-        ///   file will take the name given by this property.
-        /// </para>
-        ///
-        /// <para>
-        ///   Applications can set this property when creating new zip archives or when
-        ///   reading existing archives. When setting this property, the actual value
-        ///   that is set will replace backslashes with forward slashes, in accordance
-        ///   with <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip
-        ///   specification</see>, for compatibility with Unix(tm) and ... get
-        ///   this.... Amiga!
-        /// </para>
-        ///
-        /// <para>
-        ///   If an application reads a <c>ZipFile</c> via <see
-        ///   cref="ZipFile.Read(String)"/> or a related overload, and then explicitly
-        ///   sets the FileName on an entry contained within the <c>ZipFile</c>, and
-        ///   then calls <see cref="ZipFile.Save()"/>, the application will effectively
-        ///   rename the entry within the zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   If an application sets the value of <c>FileName</c>, then calls
-        ///   <c>Extract()</c> on the entry, the entry is extracted to a file using the
-        ///   newly set value as the filename.  The <c>FileName</c> value is made
-        ///   permanent in the zip archive only <em>after</em> a call to one of the
-        ///   <c>ZipFile.Save()</c> methods on the <c>ZipFile</c> that contains the
-        ///   ZipEntry.
-        /// </para>
-        ///
-        /// <para>
-        ///   If an application attempts to set the <c>FileName</c> to a value that
-        ///   would result in a duplicate entry in the <c>ZipFile</c>, an exception is
-        ///   thrown.
-        /// </para>
-        ///
-        /// <para>
-        ///   When a <c>ZipEntry</c> is contained within a <c>ZipFile</c>, applications
-        ///   cannot rename the entry within the context of a <c>foreach</c> (<c>For
-        ///   Each</c> in VB) loop, because of the way the <c>ZipFile</c> stores
-        ///   entries.  If you need to enumerate through all the entries and rename one
-        ///   or more of them, use <see
-        ///   cref="ZipFile.EntriesSorted">ZipFile.EntriesSorted</see> as the
-        ///   collection.  See also, <see
-        ///   cref="ZipFile.GetEnumerator()">ZipFile.GetEnumerator()</see>.
-        /// </para>
-        ///
-        /// </remarks>
-        public string FileName
-        {
-            get { return _FileNameInArchive; }
-            set
-            {
-                if (_container.ZipFile == null)
-                    throw new ZipException("Cannot rename; this is not supported in ZipOutputStream/ZipInputStream.");
-
-                // rename the entry!
-                if (String.IsNullOrEmpty(value)) throw new ZipException("The FileName must be non empty and non-null.");
-
-                var filename = ZipEntry.NameInArchive(value, null);
-                // workitem 8180
-                if (_FileNameInArchive == filename) return; // nothing to do
-
-                // workitem 8047 - when renaming, must remove old and then add a new entry
-                this._container.ZipFile.RemoveEntry(this);
-                this._container.ZipFile.InternalAddEntry(filename, this);
-
-                _FileNameInArchive = filename;
-                _container.ZipFile.NotifyEntryChanged();
-                _metadataChanged = true;
-            }
-        }
-
-
-        /// <summary>
-        /// The stream that provides content for the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The application can use this property to set the input stream for an
-        ///   entry on a just-in-time basis. Imagine a scenario where the application
-        ///   creates a <c>ZipFile</c> comprised of content obtained from hundreds of
-        ///   files, via calls to <c>AddFile()</c>. The DotNetZip library opens streams
-        ///   on these files on a just-in-time basis, only when writing the entry out to
-        ///   an external store within the scope of a <c>ZipFile.Save()</c> call.  Only
-        ///   one input stream is opened at a time, as each entry is being written out.
-        /// </para>
-        ///
-        /// <para>
-        ///   Now imagine a different application that creates a <c>ZipFile</c>
-        ///   with content obtained from hundreds of streams, added through <see
-        ///   cref="ZipFile.AddEntry(string, System.IO.Stream)"/>.  Normally the
-        ///   application would supply an open stream to that call.  But when large
-        ///   numbers of streams are being added, this can mean many open streams at one
-        ///   time, unnecessarily.
-        /// </para>
-        ///
-        /// <para>
-        ///   To avoid this, call <see cref="ZipFile.AddEntry(String, OpenDelegate,
-        ///   CloseDelegate)"/> and specify delegates that open and close the stream at
-        ///   the time of Save.
-        /// </para>
-        ///
-        ///
-        /// <para>
-        ///   Setting the value of this property when the entry was not added from a
-        ///   stream (for example, when the <c>ZipEntry</c> was added with <see
-        ///   cref="ZipFile.AddFile(String)"/> or <see
-        ///   cref="ZipFile.AddDirectory(String)"/>, or when the entry was added by
-        ///   reading an existing zip archive) will throw an exception.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        public Stream InputStream
-        {
-            get { return _sourceStream; }
-
-            set
-            {
-                if (this._Source != ZipEntrySource.Stream)
-                    throw new ZipException("You must not set the input stream for this entry.");
-
-                _sourceWasJitProvided = true;
-                _sourceStream = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   A flag indicating whether the InputStream was provided Just-in-time.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When creating a zip archive, an application can obtain content for one or
-        ///   more of the <c>ZipEntry</c> instances from streams, using the <see
-        ///   cref="ZipFile.AddEntry(string, System.IO.Stream)"/> method.  At the time
-        ///   of calling that method, the application can supply null as the value of
-        ///   the stream parameter.  By doing so, the application indicates to the
-        ///   library that it will provide a stream for the entry on a just-in-time
-        ///   basis, at the time one of the <c>ZipFile.Save()</c> methods is called and
-        ///   the data for the various entries are being compressed and written out.
-        /// </para>
-        ///
-        /// <para>
-        ///   In this case, the application can set the <see cref="InputStream"/>
-        ///   property, typically within the SaveProgress event (event type: <see
-        ///   cref="ZipProgressEventType.Saving_BeforeWriteEntry"/>) for that entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   The application will later want to call Close() and Dispose() on that
-        ///   stream.  In the SaveProgress event, when the event type is <see
-        ///   cref="ZipProgressEventType.Saving_AfterWriteEntry"/>, the application can
-        ///   do so.  This flag indicates that the stream has been provided by the
-        ///   application on a just-in-time basis and that it is the application's
-        ///   responsibility to call Close/Dispose on that stream.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="InputStream"/>
-        public bool InputStreamWasJitProvided
-        {
-            get { return _sourceWasJitProvided; }
-        }
-
-
-
-        /// <summary>
-        /// An enum indicating the source of the ZipEntry.
-        /// </summary>
-        internal ZipEntrySource Source
-        {
-            get { return _Source; }
-        }
-
-
-        /// <summary>
-        /// The version of the zip engine needed to read the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is a readonly property, indicating the version of <a
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip
-        ///   specification</a> that the extracting tool or library must support to
-        ///   extract the given entry.  Generally higher versions indicate newer
-        ///   features.  Older zip engines obviously won't know about new features, and
-        ///   won't be able to extract entries that depend on those newer features.
-        /// </para>
-        ///
-        /// <list type="table">
-        /// <listheader>
-        /// <term>value</term>
-        /// <description>Features</description>
-        /// </listheader>
-        ///
-        /// <item>
-        /// <term>20</term>
-        /// <description>a basic Zip Entry, potentially using PKZIP encryption.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>45</term>
-        /// <description>The ZIP64 extension is used on the entry.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>46</term>
-        /// <description> File is compressed using BZIP2 compression*</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>50</term>
-        /// <description> File is encrypted using PkWare's DES, 3DES, (broken) RC2 or RC4</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>51</term>
-        /// <description> File is encrypted using PKWare's AES encryption or corrected RC2 encryption.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>52</term>
-        /// <description> File is encrypted using corrected RC2-64 encryption**</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>61</term>
-        /// <description> File is encrypted using non-OAEP key wrapping***</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>63</term>
-        /// <description> File is compressed using LZMA, PPMd+, Blowfish, or Twofish</description>
-        /// </item>
-        ///
-        /// </list>
-        ///
-        /// <para>
-        ///   There are other values possible, not listed here. DotNetZip supports
-        ///   regular PKZip encryption, and ZIP64 extensions.  DotNetZip cannot extract
-        ///   entries that require a zip engine higher than 45.
-        /// </para>
-        ///
-        /// <para>
-        ///   This value is set upon reading an existing zip file, or after saving a zip
-        ///   archive.
-        /// </para>
-        /// </remarks>
-        public Int16 VersionNeeded
-        {
-            get { return _VersionNeeded; }
-        }
-
-        /// <summary>
-        /// The comment attached to the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Each entry in a zip file can optionally have a comment associated to
-        ///   it. The comment might be displayed by a zip tool during extraction, for
-        ///   example.
-        /// </para>
-        ///
-        /// <para>
-        ///   By default, the <c>Comment</c> is encoded in IBM437 code page. You can
-        ///   specify an alternative with <see cref="AlternateEncoding"/> and
-        ///  <see cref="AlternateEncodingUsage"/>.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="AlternateEncoding"/>
-        /// <seealso cref="AlternateEncodingUsage"/>
-        public string Comment
-        {
-            get { return _Comment; }
-            set
-            {
-                _Comment = value;
-                _metadataChanged = true;
-            }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the entry requires ZIP64 extensions.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This property is null (Nothing in VB) until a <c>Save()</c> method on the
-        ///   containing <see cref="ZipFile"/> instance has been called. The property is
-        ///   non-null (<c>HasValue</c> is true) only after a <c>Save()</c> method has
-        ///   been called.
-        /// </para>
-        ///
-        /// <para>
-        ///   After the containing <c>ZipFile</c> has been saved, the Value of this
-        ///   property is true if any of the following three conditions holds: the
-        ///   uncompressed size of the entry is larger than 0xFFFFFFFF; the compressed
-        ///   size of the entry is larger than 0xFFFFFFFF; the relative offset of the
-        ///   entry within the zip archive is larger than 0xFFFFFFFF.  These quantities
-        ///   are not known until a <c>Save()</c> is attempted on the zip archive and
-        ///   the compression is applied.
-        /// </para>
-        ///
-        /// <para>
-        ///   If none of the three conditions holds, then the <c>Value</c> is false.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>Value</c> of false does not indicate that the entry, as saved in the
-        ///   zip archive, does not use ZIP64.  It merely indicates that ZIP64 is
-        ///   <em>not required</em>.  An entry may use ZIP64 even when not required if
-        ///   the <see cref="ZipFile.UseZip64WhenSaving"/> property on the containing
-        ///   <c>ZipFile</c> instance is set to <see cref="Zip64Option.Always"/>, or if
-        ///   the <see cref="ZipFile.UseZip64WhenSaving"/> property on the containing
-        ///   <c>ZipFile</c> instance is set to <see cref="Zip64Option.AsNecessary"/>
-        ///   and the output stream was not seekable.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="OutputUsedZip64"/>
-        public Nullable<bool> RequiresZip64
-        {
-            get
-            {
-                return _entryRequiresZip64;
-            }
-        }
-
-        /// <summary>
-        ///   Indicates whether the entry actually used ZIP64 extensions, as it was most
-        ///   recently written to the output file or stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This Nullable property is null (Nothing in VB) until a <c>Save()</c>
-        ///   method on the containing <see cref="ZipFile"/> instance has been
-        ///   called. <c>HasValue</c> is true only after a <c>Save()</c> method has been
-        ///   called.
-        /// </para>
-        ///
-        /// <para>
-        ///   The value of this property for a particular <c>ZipEntry</c> may change
-        ///   over successive calls to <c>Save()</c> methods on the containing ZipFile,
-        ///   even if the file that corresponds to the <c>ZipEntry</c> does not. This
-        ///   may happen if other entries contained in the <c>ZipFile</c> expand,
-        ///   causing the offset for this particular entry to exceed 0xFFFFFFFF.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="RequiresZip64"/>
-        public Nullable<bool> OutputUsedZip64
-        {
-            get { return _OutputUsesZip64; }
-        }
-
-
-        /// <summary>
-        ///   The bitfield for the entry as defined in the zip spec. You probably
-        ///   never need to look at this.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   You probably do not need to concern yourself with the contents of this
-        ///   property, but in case you do:
-        /// </para>
-        ///
-        /// <list type="table">
-        /// <listheader>
-        /// <term>bit</term>
-        /// <description>meaning</description>
-        /// </listheader>
-        ///
-        /// <item>
-        /// <term>0</term>
-        /// <description>set if encryption is used.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>1-2</term>
-        /// <description>
-        /// set to determine whether normal, max, fast deflation.  DotNetZip library
-        /// always leaves these bits unset when writing (indicating "normal"
-        /// deflation"), but can read an entry with any value here.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>3</term>
-        /// <description>
-        /// Indicates that the Crc32, Compressed and Uncompressed sizes are zero in the
-        /// local header.  This bit gets set on an entry during writing a zip file, when
-        /// it is saved to a non-seekable output stream.
-        /// </description>
-        /// </item>
-        ///
-        ///
-        /// <item>
-        /// <term>4</term>
-        /// <description>reserved for "enhanced deflating". This library doesn't do enhanced deflating.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>5</term>
-        /// <description>set to indicate the zip is compressed patched data.  This library doesn't do that.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>6</term>
-        /// <description>
-        /// set if PKWare's strong encryption is used (must also set bit 1 if bit 6 is
-        /// set). This bit is not set if WinZip's AES encryption is set.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>7</term>
-        /// <description>not used</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>8</term>
-        /// <description>not used</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>9</term>
-        /// <description>not used</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>10</term>
-        /// <description>not used</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>11</term>
-        /// <description>
-        /// Language encoding flag (EFS).  If this bit is set, the filename and comment
-        /// fields for this file must be encoded using UTF-8. This library currently
-        /// does not support UTF-8.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>12</term>
-        /// <description>Reserved by PKWARE for enhanced compression.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>13</term>
-        /// <description>
-        ///   Used when encrypting the Central Directory to indicate selected data
-        ///   values in the Local Header are masked to hide their actual values.  See
-        ///   the section in <a
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip
-        ///   specification</a> describing the Strong Encryption Specification for
-        ///   details.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>14</term>
-        /// <description>Reserved by PKWARE.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>15</term>
-        /// <description>Reserved by PKWARE.</description>
-        /// </item>
-        ///
-        /// </list>
-        ///
-        /// </remarks>
-        public Int16 BitField
-        {
-            get { return _BitField; }
-        }
-
-        /// <summary>
-        ///   The compression method employed for this ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The
-        ///   Zip specification</see> allows a variety of compression methods.  This
-        ///   library supports just two: 0x08 = Deflate.  0x00 = Store (no compression),
-        ///   for reading or writing.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading an entry from an existing zipfile, the value you retrieve
-        ///   here indicates the compression method used on the entry by the original
-        ///   creator of the zip.  When writing a zipfile, you can specify either 0x08
-        ///   (Deflate) or 0x00 (None).  If you try setting something else, you will get
-        ///   an exception.
-        /// </para>
-        ///
-        /// <para>
-        ///   You may wish to set <c>CompressionMethod</c> to <c>CompressionMethod.None</c> (0)
-        ///   when zipping already-compressed data like a jpg, png, or mp3 file.
-        ///   This can save time and cpu cycles.
-        /// </para>
-        ///
-        /// <para>
-        ///   When setting this property on a <c>ZipEntry</c> that is read from an
-        ///   existing zip file, calling <c>ZipFile.Save()</c> will cause the new
-        ///   CompressionMethod to be used on the entry in the newly saved zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   Setting this property may have the side effect of modifying the
-        ///   <c>CompressionLevel</c> property. If you set the <c>CompressionMethod</c> to a
-        ///   value other than <c>None</c>, and <c>CompressionLevel</c> is previously
-        ///   set to <c>None</c>, then <c>CompressionLevel</c> will be set to
-        ///   <c>Default</c>.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="CompressionMethod"/>
-        ///
-        /// <example>
-        ///   In this example, the first entry added to the zip archive uses the default
-        ///   behavior - compression is used where it makes sense.  The second entry,
-        ///   the MP3 file, is added to the archive without being compressed.
-        /// <code>
-        /// using (ZipFile zip = new ZipFile(ZipFileToCreate))
-        /// {
-        ///   ZipEntry e1= zip.AddFile(@"notes\Readme.txt");
-        ///   ZipEntry e2= zip.AddFile(@"music\StopThisTrain.mp3");
-        ///   e2.CompressionMethod = CompressionMethod.None;
-        ///   zip.Save();
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile(ZipFileToCreate)
-        ///   zip.AddFile("notes\Readme.txt")
-        ///   Dim e2 as ZipEntry = zip.AddFile("music\StopThisTrain.mp3")
-        ///   e2.CompressionMethod = CompressionMethod.None
-        ///   zip.Save
-        /// End Using
-        /// </code>
-        /// </example>
-        internal CompressionMethod CompressionMethod
-        {
-            get { return (CompressionMethod)_CompressionMethod; }
-            set
-            {
-                if (value == (CompressionMethod)_CompressionMethod) return; // nothing to do.
-
-                if (value != CompressionMethod.None && value != CompressionMethod.Deflate
-#if BZIP
-                    && value != CompressionMethod.BZip2
-#endif
-                    )
-                    throw new InvalidOperationException("Unsupported compression method.");
-
-                // If the source is a zip archive and there was encryption on the
-                // entry, changing the compression method is not supported.
-                //                 if (this._Source == ZipEntrySource.ZipFile && _sourceIsEncrypted)
-                //                     throw new InvalidOperationException("Cannot change compression method on encrypted entries read from archives.");
-
-                _CompressionMethod = (Int16)value;
-
-                if (_CompressionMethod == (Int16)Ionic.Zip.CompressionMethod.None)
-                    _CompressionLevel = Ionic.Zlib.CompressionLevel.None;
-                else if (CompressionLevel == Ionic.Zlib.CompressionLevel.None)
-                    _CompressionLevel = Ionic.Zlib.CompressionLevel.Default;
-
-                if (_container.ZipFile != null) _container.ZipFile.NotifyEntryChanged();
-                _restreamRequiredOnSave = true;
-            }
-        }
-
-
-        /// <summary>
-        ///   Sets the compression level to be used for the entry when saving the zip
-        ///   archive. This applies only for CompressionMethod = DEFLATE.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    When using the DEFLATE compression method, Varying the compression
-        ///    level used on entries can affect the size-vs-speed tradeoff when
-        ///    compression and decompressing data streams or files.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you do not set this property, the default compression level is used,
-        ///    which normally gives a good balance of compression efficiency and
-        ///    compression speed.  In some tests, using <c>BestCompression</c> can
-        ///    double the time it takes to compress, while delivering just a small
-        ///    increase in compression efficiency.  This behavior will vary with the
-        ///    type of data you compress.  If you are in doubt, just leave this setting
-        ///    alone, and accept the default.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    When setting this property on a <c>ZipEntry</c> that is read from an
-        ///    existing zip file, calling <c>ZipFile.Save()</c> will cause the new
-        ///    <c>CompressionLevel</c> to be used on the entry in the newly saved zip file.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    Setting this property may have the side effect of modifying the
-        ///    <c>CompressionMethod</c> property. If you set the <c>CompressionLevel</c>
-        ///    to a value other than <c>None</c>, <c>CompressionMethod</c> will be set
-        ///    to <c>Deflate</c>, if it was previously <c>None</c>.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    Setting this property has no effect if the <c>CompressionMethod</c> is something
-        ///    other than <c>Deflate</c> or <c>None</c>.
-        ///  </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="CompressionMethod"/>
-        public OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel CompressionLevel
-        {
-            get
-            {
-                return _CompressionLevel;
-            }
-            set
-            {
-                if (_CompressionMethod != (short)CompressionMethod.Deflate &&
-                    _CompressionMethod != (short)CompressionMethod.None)
-                    return ; // no effect
-
-                if (value == OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.Default &&
-                    _CompressionMethod == (short)CompressionMethod.Deflate) return; // nothing to do
-                _CompressionLevel = value;
-
-                if (value == OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.None &&
-                    _CompressionMethod == (short)CompressionMethod.None)
-                    return; // nothing more to do
-
-                if (_CompressionLevel == OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.None)
-                    _CompressionMethod = (short)OfficeOpenXml.Packaging.Ionic.Zip.CompressionMethod.None;
-                else
-                    _CompressionMethod = (short)OfficeOpenXml.Packaging.Ionic.Zip.CompressionMethod.Deflate;
-
-                if (_container.ZipFile != null) _container.ZipFile.NotifyEntryChanged();
-                _restreamRequiredOnSave = true;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   The compressed size of the file, in bytes, within the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   When reading a <c>ZipFile</c>, this value is read in from the existing
-        ///   zip file. When creating or updating a <c>ZipFile</c>, the compressed
-        ///   size is computed during compression.  Therefore the value on a
-        ///   <c>ZipEntry</c> is valid after a call to <c>Save()</c> (or one of its
-        ///   overloads) in that case.
-        /// </remarks>
-        ///
-        /// <seealso cref="ZipEntry.UncompressedSize"/>
-        public Int64 CompressedSize
-        {
-            get { return _CompressedSize; }
-        }
-
-        /// <summary>
-        ///   The size of the file, in bytes, before compression, or after extraction.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   When reading a <c>ZipFile</c>, this value is read in from the existing
-        ///   zip file. When creating or updating a <c>ZipFile</c>, the uncompressed
-        ///   size is computed during compression.  Therefore the value on a
-        ///   <c>ZipEntry</c> is valid after a call to <c>Save()</c> (or one of its
-        ///   overloads) in that case.
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipEntry.CompressedSize"/>
-        public Int64 UncompressedSize
-        {
-            get { return _UncompressedSize; }
-        }
-
-        /// <summary>
-        /// The ratio of compressed size to uncompressed size of the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is a ratio of the compressed size to the uncompressed size of the
-        ///   entry, expressed as a double in the range of 0 to 100+. A value of 100
-        ///   indicates no compression at all.  It could be higher than 100 when the
-        ///   compression algorithm actually inflates the data, as may occur for small
-        ///   files, or uncompressible data that is encrypted.
-        /// </para>
-        ///
-        /// <para>
-        ///   You could format it for presentation to a user via a format string of
-        ///   "{3,5:F0}%" to see it as a percentage.
-        /// </para>
-        ///
-        /// <para>
-        ///   If the size of the original uncompressed file is 0, implying a
-        ///   denominator of 0, the return value will be zero.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is valid after reading in an existing zip file, or after
-        ///   saving the <c>ZipFile</c> that contains the ZipEntry. You cannot know the
-        ///   effect of a compression transform until you try it.
-        /// </para>
-        ///
-        /// </remarks>
-        public Double CompressionRatio
-        {
-            get
-            {
-                if (UncompressedSize == 0) return 0;
-                return 100 * (1.0 - (1.0 * CompressedSize) / (1.0 * UncompressedSize));
-            }
-        }
-
-        /// <summary>
-        /// The 32-bit CRC (Cyclic Redundancy Check) on the contents of the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para> You probably don't need to concern yourself with this. It is used
-        /// internally by DotNetZip to verify files or streams upon extraction.  </para>
-        ///
-        /// <para> The value is a <see href="http://en.wikipedia.org/wiki/CRC32">32-bit
-        /// CRC</see> using 0xEDB88320 for the polynomial. This is the same CRC-32 used in
-        /// PNG, MPEG-2, and other protocols and formats.  It is a read-only property; when
-        /// creating a Zip archive, the CRC for each entry is set only after a call to
-        /// <c>Save()</c> on the containing ZipFile. When reading an existing zip file, the value
-        /// of this property reflects the stored CRC for the entry.  </para>
-        ///
-        /// </remarks>
-        public Int32 Crc
-        {
-            get { return _Crc32; }
-        }
-
-        /// <summary>
-        /// True if the entry is a directory (not a file).
-        /// This is a readonly property on the entry.
-        /// </summary>
-        public bool IsDirectory
-        {
-            get { return _IsDirectory; }
-        }
-
-        /// <summary>
-        /// A derived property that is <c>true</c> if the entry uses encryption.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is a readonly property on the entry.  When reading a zip file,
-        ///   the value for the <c>ZipEntry</c> is determined by the data read
-        ///   from the zip file.  After saving a ZipFile, the value of this
-        ///   property for each <c>ZipEntry</c> indicates whether encryption was
-        ///   actually used (which will have been true if the <see
-        ///   cref="Password"/> was set and the <see cref="Encryption"/> property
-        ///   was something other than <see cref="EncryptionAlgorithm.None"/>.
-        /// </para>
-        /// </remarks>
-        public bool UsesEncryption
-        {
-            get { return (_Encryption_FromZipFile != EncryptionAlgorithm.None); }
-        }
-
-
-        /// <summary>
-        ///   Set this to specify which encryption algorithm to use for the entry when
-        ///   saving it to a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Set this property in order to encrypt the entry when the <c>ZipFile</c> is
-        ///   saved. When setting this property, you must also set a <see
-        ///   cref="Password"/> on the entry.  If you set a value other than <see
-        ///   cref="EncryptionAlgorithm.None"/> on this property and do not set a
-        ///   <c>Password</c> then the entry will not be encrypted. The <c>ZipEntry</c>
-        ///   data is encrypted as the <c>ZipFile</c> is saved, when you call <see
-        ///   cref="ZipFile.Save()"/> or one of its cousins on the containing
-        ///   <c>ZipFile</c> instance. You do not need to specify the <c>Encryption</c>
-        ///   when extracting entries from an archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   The Zip specification from PKWare defines a set of encryption algorithms,
-        ///   and the data formats for the zip archive that support them, and PKWare
-        ///   supports those algorithms in the tools it produces. Other vendors of tools
-        ///   and libraries, such as WinZip or Xceed, typically support <em>a
-        ///   subset</em> of the algorithms specified by PKWare. These tools can
-        ///   sometimes support additional different encryption algorithms and data
-        ///   formats, not specified by PKWare. The AES Encryption specified and
-        ///   supported by WinZip is the most popular example. This library supports a
-        ///   subset of the complete set of algorithms specified by PKWare and other
-        ///   vendors.
-        /// </para>
-        ///
-        /// <para>
-        ///   There is no common, ubiquitous multi-vendor standard for strong encryption
-        ///   within zip files. There is broad support for so-called "traditional" Zip
-        ///   encryption, sometimes called Zip 2.0 encryption, as <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specified
-        ///   by PKWare</see>, but this encryption is considered weak and
-        ///   breakable. This library currently supports the Zip 2.0 "weak" encryption,
-        ///   and also a stronger WinZip-compatible AES encryption, using either 128-bit
-        ///   or 256-bit key strength. If you want DotNetZip to support an algorithm
-        ///   that is not currently supported, call the author of this library and maybe
-        ///   we can talk business.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="ZipFile"/> class also has a <see
-        ///   cref="ZipFile.Encryption"/> property.  In most cases you will use
-        ///   <em>that</em> property when setting encryption. This property takes
-        ///   precedence over any <c>Encryption</c> set on the <c>ZipFile</c> itself.
-        ///   Typically, you would use the per-entry Encryption when most entries in the
-        ///   zip archive use one encryption algorithm, and a few entries use a
-        ///   different one.  If all entries in the zip file use the same Encryption,
-        ///   then it is simpler to just set this property on the ZipFile itself, when
-        ///   creating a zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   Some comments on updating archives: If you read a <c>ZipFile</c>, you can
-        ///   modify the Encryption on an encrypted entry: you can remove encryption
-        ///   from an entry that was encrypted; you can encrypt an entry that was not
-        ///   encrypted previously; or, you can change the encryption algorithm.  The
-        ///   changes in encryption are not made permanent until you call Save() on the
-        ///   <c>ZipFile</c>.  To effect changes in encryption, the entry content is
-        ///   streamed through several transformations, depending on the modification
-        ///   the application has requested. For example if the entry is not encrypted
-        ///   and the application sets <c>Encryption</c> to <c>PkzipWeak</c>, then at
-        ///   the time of <c>Save()</c>, the original entry is read and decompressed,
-        ///   then re-compressed and encrypted.  Conversely, if the original entry is
-        ///   encrypted with <c>PkzipWeak</c> encryption, and the application sets the
-        ///   <c>Encryption</c> property to <c>WinZipAes128</c>, then at the time of
-        ///   <c>Save()</c>, the original entry is decrypted via PKZIP encryption and
-        ///   decompressed, then re-compressed and re-encrypted with AES.  This all
-        ///   happens automatically within the library, but it can be time-consuming for
-        ///   large entries.
-        /// </para>
-        ///
-        /// <para>
-        ///   Additionally, when updating archives, it is not possible to change the
-        ///   password when changing the encryption algorithm.  To change both the
-        ///   algorithm and the password, you need to Save() the zipfile twice.  First
-        ///   set the <c>Encryption</c> to None, then call <c>Save()</c>.  Then set the
-        ///   <c>Encryption</c> to the new value (not "None"), then call <c>Save()</c>
-        ///   once again.
-        /// </para>
-        ///
-        /// <para>
-        ///   The WinZip AES encryption algorithms are not supported on the .NET Compact
-        ///   Framework.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example creates a zip archive that uses encryption, and then extracts
-        ///   entries from the archive.  When creating the zip archive, the ReadMe.txt
-        ///   file is zipped without using a password or encryption.  The other file
-        ///   uses encryption.
-        /// </para>
-        /// <code>
-        /// // Create a zip archive with AES Encryption.
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddFile("ReadMe.txt")
-        ///     ZipEntry e1= zip.AddFile("2008-Regional-Sales-Report.pdf");
-        ///     e1.Encryption= EncryptionAlgorithm.WinZipAes256;
-        ///     e1.Password= "Top.Secret.No.Peeking!";
-        ///     zip.Save("EncryptedArchive.zip");
-        /// }
-        ///
-        /// // Extract a zip archive that uses AES Encryption.
-        /// // You do not need to specify the algorithm during extraction.
-        /// using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))
-        /// {
-        ///     // Specify the password that is used during extraction, for
-        ///     // all entries that require a password:
-        ///     zip.Password= "Top.Secret.No.Peeking!";
-        ///     zip.ExtractAll("extractDirectory");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// ' Create a zip that uses Encryption.
-        /// Using zip As New ZipFile()
-        ///     zip.AddFile("ReadMe.txt")
-        ///     Dim e1 as ZipEntry
-        ///     e1= zip.AddFile("2008-Regional-Sales-Report.pdf")
-        ///     e1.Encryption= EncryptionAlgorithm.WinZipAes256
-        ///     e1.Password= "Top.Secret.No.Peeking!"
-        ///     zip.Save("EncryptedArchive.zip")
-        /// End Using
-        ///
-        /// ' Extract a zip archive that uses AES Encryption.
-        /// ' You do not need to specify the algorithm during extraction.
-        /// Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))
-        ///     ' Specify the password that is used during extraction, for
-        ///     ' all entries that require a password:
-        ///     zip.Password= "Top.Secret.No.Peeking!"
-        ///     zip.ExtractAll("extractDirectory")
-        /// End Using
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <exception cref="System.InvalidOperationException">
-        /// Thrown in the setter if EncryptionAlgorithm.Unsupported is specified.
-        /// </exception>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipEntry.Password">ZipEntry.Password</seealso>
-        /// <seealso cref="Ionic.Zip.ZipFile.Encryption">ZipFile.Encryption</seealso>
-        internal EncryptionAlgorithm Encryption
-        {
-            get
-            {
-                return _Encryption;
-            }
-            set
-            {
-                if (value == _Encryption) return; // no change
-
-                if (value == EncryptionAlgorithm.Unsupported)
-                    throw new InvalidOperationException("You may not set Encryption to that value.");
-
-                // If the source is a zip archive and there was encryption
-                // on the entry, this will not work. <XXX>
-                //if (this._Source == ZipEntrySource.ZipFile && _sourceIsEncrypted)
-                //    throw new InvalidOperationException("You cannot change the encryption method on encrypted entries read from archives.");
-
-                _Encryption = value;
-                _restreamRequiredOnSave = true;
-                if (_container.ZipFile!=null)
-                    _container.ZipFile.NotifyEntryChanged();
-            }
-        }
-
-
-        /// <summary>
-        /// The Password to be used when encrypting a <c>ZipEntry</c> upon
-        /// <c>ZipFile.Save()</c>, or when decrypting an entry upon Extract().
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is a write-only property on the entry. Set this to request that the
-        ///   entry be encrypted when writing the zip archive, or set it to specify the
-        ///   password to be used when extracting an existing entry that is encrypted.
-        /// </para>
-        ///
-        /// <para>
-        ///   The password set here is implicitly used to encrypt the entry during the
-        ///   <see cref="ZipFile.Save()"/> operation, or to decrypt during the <see
-        ///   cref="Extract()"/> or <see cref="OpenReader()"/> operation.  If you set
-        ///   the Password on a <c>ZipEntry</c> after calling <c>Save()</c>, there is no
-        ///   effect.
-        /// </para>
-        ///
-        /// <para>
-        ///   Consider setting the <see cref="Encryption"/> property when using a
-        ///   password. Answering concerns that the standard password protection
-        ///   supported by all zip tools is weak, WinZip has extended the ZIP
-        ///   specification with a way to use AES Encryption to protect entries in the
-        ///   Zip file. Unlike the "PKZIP 2.0" encryption specified in the PKZIP
-        ///   specification, <see href=
-        ///   "http://en.wikipedia.org/wiki/Advanced_Encryption_Standard">AES
-        ///   Encryption</see> uses a standard, strong, tested, encryption
-        ///   algorithm. DotNetZip can create zip archives that use WinZip-compatible
-        ///   AES encryption, if you set the <see cref="Encryption"/> property. But,
-        ///   archives created that use AES encryption may not be readable by all other
-        ///   tools and libraries. For example, Windows Explorer cannot read a
-        ///   "compressed folder" (a zip file) that uses AES encryption, though it can
-        ///   read a zip file that uses "PKZIP encryption."
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="ZipFile"/> class also has a <see cref="ZipFile.Password"/>
-        ///   property.  This property takes precedence over any password set on the
-        ///   ZipFile itself.  Typically, you would use the per-entry Password when most
-        ///   entries in the zip archive use one password, and a few entries use a
-        ///   different password.  If all entries in the zip file use the same password,
-        ///   then it is simpler to just set this property on the ZipFile itself,
-        ///   whether creating a zip archive or extracting a zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   Some comments on updating archives: If you read a <c>ZipFile</c>, you
-        ///   cannot modify the password on any encrypted entry, except by extracting
-        ///   the entry with the original password (if any), removing the original entry
-        ///   via <see cref="ZipFile.RemoveEntry(ZipEntry)"/>, and then adding a new
-        ///   entry with a new Password.
-        /// </para>
-        ///
-        /// <para>
-        ///   For example, suppose you read a <c>ZipFile</c>, and there is an encrypted
-        ///   entry.  Setting the Password property on that <c>ZipEntry</c> and then
-        ///   calling <c>Save()</c> on the <c>ZipFile</c> does not update the password
-        ///   on that entry in the archive.  Neither is an exception thrown. Instead,
-        ///   what happens during the <c>Save()</c> is the existing entry is copied
-        ///   through to the new zip archive, in its original encrypted form. Upon
-        ///   re-reading that archive, the entry can be decrypted with its original
-        ///   password.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you read a ZipFile, and there is an un-encrypted entry, you can set the
-        ///   <c>Password</c> on the entry and then call Save() on the ZipFile, and get
-        ///   encryption on that entry.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example creates a zip file with two entries, and then extracts the
-        ///   entries from the zip file.  When creating the zip file, the two files are
-        ///   added to the zip file using password protection. Each entry uses a
-        ///   different password.  During extraction, each file is extracted with the
-        ///   appropriate password.
-        /// </para>
-        /// <code>
-        /// // create a file with encryption
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     ZipEntry entry;
-        ///     entry= zip.AddFile("Declaration.txt");
-        ///     entry.Password= "123456!";
-        ///     entry = zip.AddFile("Report.xls");
-        ///     entry.Password= "1Secret!";
-        ///     zip.Save("EncryptedArchive.zip");
-        /// }
-        ///
-        /// // extract entries that use encryption
-        /// using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))
-        /// {
-        ///     ZipEntry entry;
-        ///     entry = zip["Declaration.txt"];
-        ///     entry.Password = "123456!";
-        ///     entry.Extract("extractDir");
-        ///     entry = zip["Report.xls"];
-        ///     entry.Password = "1Secret!";
-        ///     entry.Extract("extractDir");
-        /// }
-        ///
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     Dim entry as ZipEntry
-        ///     entry= zip.AddFile("Declaration.txt")
-        ///     entry.Password= "123456!"
-        ///     entry = zip.AddFile("Report.xls")
-        ///     entry.Password= "1Secret!"
-        ///     zip.Save("EncryptedArchive.zip")
-        /// End Using
-        ///
-        ///
-        /// ' extract entries that use encryption
-        /// Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))
-        ///     Dim entry as ZipEntry
-        ///     entry = zip("Declaration.txt")
-        ///     entry.Password = "123456!"
-        ///     entry.Extract("extractDir")
-        ///     entry = zip("Report.xls")
-        ///     entry.Password = "1Secret!"
-        ///     entry.Extract("extractDir")
-        /// End Using
-        ///
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipEntry.Encryption"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.Password">ZipFile.Password</seealso>
-        public string Password
-        {
-            set
-            {
-                _Password = value;
-                if (_Password == null)
-                {
-                    _Encryption = EncryptionAlgorithm.None;
-                }
-                else
-                {
-                    // We're setting a non-null password.
-
-                    // For entries obtained from a zip file that are encrypted, we cannot
-                    // simply restream (recompress, re-encrypt) the file data, because we
-                    // need the old password in order to decrypt the data, and then we
-                    // need the new password to encrypt.  So, setting the password is
-                    // never going to work on an entry that is stored encrypted in a zipfile.
-
-                    // But it is not en error to set the password, obviously: callers will
-                    // set the password in order to Extract encrypted archives.
-
-                    // If the source is a zip archive and there was previously no encryption
-                    // on the entry, then we must re-stream the entry in order to encrypt it.
-                    if (this._Source == ZipEntrySource.ZipFile && !_sourceIsEncrypted)
-                        _restreamRequiredOnSave = true;
-
-                    if (Encryption == EncryptionAlgorithm.None)
-                    {
-                        _Encryption = EncryptionAlgorithm.PkzipWeak;
-                    }
-                }
-            }
-            private get { return _Password; }
-        }
-
-
-
-        internal bool IsChanged
-        {
-            get
-            {
-                return _restreamRequiredOnSave | _metadataChanged;
-            }
-        }
-
-
-        /// <summary>
-        /// The action the library should take when extracting a file that already exists.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     This property affects the behavior of the Extract methods (one of the
-        ///     <c>Extract()</c> or <c>ExtractWithPassword()</c> overloads), when
-        ///     extraction would would overwrite an existing filesystem file. If you do
-        ///     not set this property, the library throws an exception when extracting
-        ///     an entry would overwrite an existing file.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     This property has no effect when extracting to a stream, or when the file to be
-        ///     extracted does not already exist.
-        ///   </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractExistingFile"/>
-        ///
-        /// <example>
-        ///   This example shows how to set the <c>ExtractExistingFile</c> property in
-        ///   an <c>ExtractProgress</c> event, in response to user input. The
-        ///   <c>ExtractProgress</c> event is invoked if and only if the
-        ///   <c>ExtractExistingFile</c> property was previously set to
-        ///   <c>ExtractExistingFileAction.InvokeExtractProgressEvent</c>.
-        /// <code lang="C#">
-        /// public static void ExtractProgress(object sender, ExtractProgressEventArgs e)
-        /// {
-        ///     if (e.EventType == ZipProgressEventType.Extracting_BeforeExtractEntry)
-        ///         Console.WriteLine("extract {0} ", e.CurrentEntry.FileName);
-        ///
-        ///     else if (e.EventType == ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite)
-        ///     {
-        ///         ZipEntry entry = e.CurrentEntry;
-        ///         string response = null;
-        ///         // Ask the user if he wants overwrite the file
-        ///         do
-        ///         {
-        ///             Console.Write("Overwrite {0} in {1} ? (y/n/C) ", entry.FileName, e.ExtractLocation);
-        ///             response = Console.ReadLine();
-        ///             Console.WriteLine();
-        ///
-        ///         } while (response != null &amp;&amp; response[0]!='Y' &amp;&amp;
-        ///                  response[0]!='N' &amp;&amp; response[0]!='C');
-        ///
-        ///         if  (response[0]=='C')
-        ///             e.Cancel = true;
-        ///         else if (response[0]=='Y')
-        ///             entry.ExtractExistingFile = ExtractExistingFileAction.OverwriteSilently;
-        ///         else
-        ///             entry.ExtractExistingFile= ExtractExistingFileAction.DoNotOverwrite;
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        internal ExtractExistingFileAction ExtractExistingFile
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The action to take when an error is encountered while
-        ///   opening or reading files as they are saved into a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///     Errors can occur within a call to <see
-        ///     cref="ZipFile.Save()">ZipFile.Save</see>, as the various files contained
-        ///     in a ZipFile are being saved into the zip archive.  During the
-        ///     <c>Save</c>, DotNetZip will perform a <c>File.Open</c> on the file
-        ///     associated to the ZipEntry, and then will read the entire contents of
-        ///     the file as it is zipped. Either the open or the Read may fail, because
-        ///     of lock conflicts or other reasons.  Using this property, you can
-        ///     specify the action to take when such errors occur.
-        ///  </para>
-        ///
-        ///  <para>
-        ///     Typically you will NOT set this property on individual ZipEntry
-        ///     instances.  Instead, you will set the <see
-        ///     cref="ZipFile.ZipErrorAction">ZipFile.ZipErrorAction</see> property on
-        ///     the ZipFile instance, before adding any entries to the
-        ///     <c>ZipFile</c>. If you do this, errors encountered on behalf of any of
-        ///     the entries in the ZipFile will be handled the same way.
-        ///  </para>
-        ///
-        ///  <para>
-        ///     But, if you use a <see cref="ZipFile.ZipError"/> handler, you will want
-        ///     to set this property on the <c>ZipEntry</c> within the handler, to
-        ///     communicate back to DotNetZip what you would like to do with the
-        ///     particular error.
-        ///  </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="Ionic.Zip.ZipFile.ZipErrorAction"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ZipError"/>
-        internal ZipErrorAction ZipErrorAction
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        /// Indicates whether the entry was included in the most recent save.
-        /// </summary>
-        /// <remarks>
-        /// An entry can be excluded or skipped from a save if there is an error
-        /// opening or reading the entry.
-        /// </remarks>
-        /// <seealso cref="ZipErrorAction"/>
-        internal bool IncludedInMostRecentSave
-        {
-            get
-            {
-                return !_skippedDuringSave;
-            }
-        }
-
-
-        /// <summary>
-        ///   A callback that allows the application to specify the compression to use
-        ///   for a given entry that is about to be added to the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See <see cref="ZipFile.SetCompression" />
-        /// </para>
-        /// </remarks>
-        public SetCompressionCallback SetCompression
-        {
-            get;
-            set;
-        }
-
-
-
-        /// <summary>
-        ///   Set to indicate whether to use UTF-8 encoding for filenames and comments.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If this flag is set, the comment and filename for the entry will be
-        ///   encoded with UTF-8, as described in <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip
-        ///   specification</see>, if necessary. "Necessary" means, the filename or
-        ///   entry comment (if any) cannot be reflexively encoded and decoded using the
-        ///   default code page, IBM437.
-        /// </para>
-        ///
-        /// <para>
-        ///   Setting this flag to true is equivalent to setting <see
-        ///   cref="ProvisionalAlternateEncoding"/> to <c>System.Text.Encoding.UTF8</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This flag has no effect or relation to the text encoding used within the
-        ///   file itself.
-        /// </para>
-        ///
-        /// </remarks>
-        [Obsolete("Beginning with v1.9.1.6 of DotNetZip, this property is obsolete.  It will be removed in a future version of the library. Your applications should  use AlternateEncoding and AlternateEncodingUsage instead.")]
-        public bool UseUnicodeAsNecessary
-        {
-            get
-            {
-                return (AlternateEncoding == System.Text.Encoding.GetEncoding("UTF-8")) &&
-                    (AlternateEncodingUsage == ZipOption.AsNecessary);
-            }
-            set
-            {
-                if (value)
-                {
-                    AlternateEncoding = System.Text.Encoding.GetEncoding("UTF-8");
-                    AlternateEncodingUsage = ZipOption.AsNecessary;
-
-                }
-                else
-                {
-                    AlternateEncoding = Ionic.Zip.ZipFile.DefaultEncoding;
-                    AlternateEncodingUsage = ZipOption.Never;
-                }
-            }
-        }
-
-        /// <summary>
-        ///   The text encoding to use for the FileName and Comment on this ZipEntry,
-        ///   when the default encoding is insufficient.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Don't use this property.  See <see cref='AlternateEncoding'/>.
-        /// </para>
-        ///
-        /// </remarks>
-        [Obsolete("This property is obsolete since v1.9.1.6. Use AlternateEncoding and AlternateEncodingUsage instead.", true)]
-        public System.Text.Encoding ProvisionalAlternateEncoding
-        {
-            get; set;
-        }
-
-        /// <summary>
-        ///   Specifies the alternate text encoding used by this ZipEntry
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The default text encoding used in Zip files for encoding filenames and
-        ///     comments is IBM437, which is something like a superset of ASCII.  In
-        ///     cases where this is insufficient, applications can specify an
-        ///     alternate encoding.
-        ///   </para>
-        ///   <para>
-        ///     When creating a zip file, the usage of the alternate encoding is
-        ///     governed by the <see cref="AlternateEncodingUsage"/> property.
-        ///     Typically you would set both properties to tell DotNetZip to employ an
-        ///     encoding that is not IBM437 in the zipfile you are creating.
-        ///   </para>
-        ///   <para>
-        ///     Keep in mind that because the ZIP specification states that the only
-        ///     valid encodings to use are IBM437 and UTF-8, if you use something
-        ///     other than that, then zip tools and libraries may not be able to
-        ///     successfully read the zip archive you generate.
-        ///   </para>
-        ///   <para>
-        ///     The zip specification states that applications should presume that
-        ///     IBM437 is in use, except when a special bit is set, which indicates
-        ///     UTF-8. There is no way to specify an arbitrary code page, within the
-        ///     zip file itself. When you create a zip file encoded with gb2312 or
-        ///     ibm861 or anything other than IBM437 or UTF-8, then the application
-        ///     that reads the zip file needs to "know" which code page to use. In
-        ///     some cases, the code page used when reading is chosen implicitly. For
-        ///     example, WinRar uses the ambient code page for the host desktop
-        ///     operating system. The pitfall here is that if you create a zip in
-        ///     Copenhagen and send it to Tokyo, the reader of the zipfile may not be
-        ///     able to decode successfully.
-        ///   </para>
-        /// </remarks>
-        /// <example>
-        ///   This example shows how to create a zipfile encoded with a
-        ///   language-specific encoding:
-        /// <code>
-        ///   using (var zip = new ZipFile())
-        ///   {
-        ///      zip.AlternateEnoding = System.Text.Encoding.GetEncoding("ibm861");
-        ///      zip.AlternateEnodingUsage = ZipOption.Always;
-        ///      zip.AddFileS(arrayOfFiles);
-        ///      zip.Save("Myarchive-Encoded-in-IBM861.zip");
-        ///   }
-        /// </code>
-        /// </example>
-        /// <seealso cref="ZipFile.AlternateEncodingUsage" />
-        public System.Text.Encoding AlternateEncoding
-        {
-            get; set;
-        }
-
-
-        /// <summary>
-        ///   Describes if and when this instance should apply
-        ///   AlternateEncoding to encode the FileName and Comment, when
-        ///   saving.
-        /// </summary>
-        /// <seealso cref="ZipFile.AlternateEncoding" />
-        internal ZipOption AlternateEncodingUsage
-        {
-            get; set;
-        }
-
-
-        // /// <summary>
-        // /// The text encoding actually used for this ZipEntry.
-        // /// </summary>
-        // ///
-        // /// <remarks>
-        // ///
-        // /// <para>
-        // ///   This read-only property describes the encoding used by the
-        // ///   <c>ZipEntry</c>.  If the entry has been read in from an existing ZipFile,
-        // ///   then it may take the value UTF-8, if the entry is coded to specify UTF-8.
-        // ///   If the entry does not specify UTF-8, the typical case, then the encoding
-        // ///   used is whatever the application specified in the call to
-        // ///   <c>ZipFile.Read()</c>. If the application has used one of the overloads of
-        // ///   <c>ZipFile.Read()</c> that does not accept an encoding parameter, then the
-        // ///   encoding used is IBM437, which is the default encoding described in the
-        // ///   ZIP specification.  </para>
-        // ///
-        // /// <para>
-        // ///   If the entry is being created, then the value of ActualEncoding is taken
-        // ///   according to the logic described in the documentation for <see
-        // ///   cref="ZipFile.ProvisionalAlternateEncoding" />.  </para>
-        // ///
-        // /// <para>
-        // ///   An application might be interested in retrieving this property to see if
-        // ///   an entry read in from a file has used Unicode (UTF-8).  </para>
-        // ///
-        // /// </remarks>
-        // ///
-        // /// <seealso cref="ZipFile.ProvisionalAlternateEncoding" />
-        // public System.Text.Encoding ActualEncoding
-        // {
-        //     get
-        //     {
-        //         return _actualEncoding;
-        //     }
-        // }
-
-
-
-
-        internal static string NameInArchive(String filename, string directoryPathInArchive)
-        {
-            string result = null;
-            if (directoryPathInArchive == null)
-                result = filename;
-
-            else
-            {
-                if (String.IsNullOrEmpty(directoryPathInArchive))
-                {
-                    result = Path.GetFileName(filename);
-                }
-                else
-                {
-                    // explicitly specify a pathname for this file
-                    result = Path.Combine(directoryPathInArchive, Path.GetFileName(filename));
-                }
-            }
-
-            //result = Path.GetFullPath(result);
-            result = SharedUtilities.NormalizePathForUseInZipFile(result);
-
-            return result;
-        }
-
-        // workitem 9073
-        internal static ZipEntry CreateFromNothing(String nameInArchive)
-        {
-            return Create(nameInArchive, ZipEntrySource.None, null, null);
-        }
-
-        internal static ZipEntry CreateFromFile(String filename, string nameInArchive)
-        {
-            return Create(nameInArchive, ZipEntrySource.FileSystem, filename, null);
-        }
-
-        internal static ZipEntry CreateForStream(String entryName, Stream s)
-        {
-            return Create(entryName, ZipEntrySource.Stream, s, null);
-        }
-
-        internal static ZipEntry CreateForWriter(String entryName, WriteDelegate d)
-        {
-            return Create(entryName, ZipEntrySource.WriteDelegate, d, null);
-        }
-
-        internal static ZipEntry CreateForJitStreamProvider(string nameInArchive, OpenDelegate opener, CloseDelegate closer)
-        {
-            return Create(nameInArchive, ZipEntrySource.JitStream, opener, closer);
-        }
-
-        internal static ZipEntry CreateForZipOutputStream(string nameInArchive)
-        {
-            return Create(nameInArchive, ZipEntrySource.ZipOutputStream, null, null);
-        }
-
-
-        private static ZipEntry Create(string nameInArchive, ZipEntrySource source, Object arg1, Object arg2)
-        {
-            if (String.IsNullOrEmpty(nameInArchive))
-                throw new Ionic.Zip.ZipException("The entry name must be non-null and non-empty.");
-
-            ZipEntry entry = new ZipEntry();
-
-            // workitem 7071
-            // workitem 7926 - "version made by" OS should be zero for compat with WinZip
-            entry._VersionMadeBy = (0 << 8) + 45; // indicates the attributes are FAT Attributes, and v4.5 of the spec
-            entry._Source = source;
-            entry._Mtime = entry._Atime = entry._Ctime = DateTime.UtcNow;
-
-            if (source == ZipEntrySource.Stream)
-            {
-                entry._sourceStream = (arg1 as Stream);         // may  or may not be null
-            }
-            else if (source == ZipEntrySource.WriteDelegate)
-            {
-                entry._WriteDelegate = (arg1 as WriteDelegate); // may  or may not be null
-            }
-            else if (source == ZipEntrySource.JitStream)
-            {
-                entry._OpenDelegate = (arg1 as OpenDelegate);   // may  or may not be null
-                entry._CloseDelegate = (arg2 as CloseDelegate); // may  or may not be null
-            }
-            else if (source == ZipEntrySource.ZipOutputStream)
-            {
-            }
-            // workitem 9073
-            else if (source == ZipEntrySource.None)
-            {
-                // make this a valid value, for later.
-                entry._Source = ZipEntrySource.FileSystem;
-            }
-            else
-            {
-                String filename = (arg1 as String);   // must not be null
-
-                if (String.IsNullOrEmpty(filename))
-                    throw new Ionic.Zip.ZipException("The filename must be non-null and non-empty.");
-
-                try
-                {
-                    // The named file may or may not exist at this time.  For
-                    // example, when adding a directory by name.  We test existence
-                    // when necessary: when saving the ZipFile, or when getting the
-                    // attributes, and so on.
-
-#if NETCF
-                    // workitem 6878
-                    // Ionic.Zip.SharedUtilities.AdjustTime_Win32ToDotNet
-                    entry._Mtime = File.GetLastWriteTime(filename).ToUniversalTime();
-                    entry._Ctime = File.GetCreationTime(filename).ToUniversalTime();
-                    entry._Atime = File.GetLastAccessTime(filename).ToUniversalTime();
-
-                    // workitem 7071
-                    // can only get attributes of files that exist.
-                    if (File.Exists(filename) || Directory.Exists(filename))
-                        entry._ExternalFileAttrs = (int)NetCfFile.GetAttributes(filename);
-
-#elif SILVERLIGHT
-                    entry._Mtime =
-                        entry._Ctime =
-                        entry._Atime = System.DateTime.UtcNow;
-                    entry._ExternalFileAttrs = (int)0;
-#else
-                    // workitem 6878??
-                    entry._Mtime = File.GetLastWriteTime(filename).ToUniversalTime();
-                    entry._Ctime = File.GetCreationTime(filename).ToUniversalTime();
-                    entry._Atime = File.GetLastAccessTime(filename).ToUniversalTime();
-
-                    // workitem 7071
-                    // can only get attributes on files that exist.
-                    if (File.Exists(filename) || Directory.Exists(filename))
-                        entry._ExternalFileAttrs = (int)File.GetAttributes(filename);
-
-#endif
-                    entry._ntfsTimesAreSet = true;
-
-                    entry._LocalFileName = Path.GetFullPath(filename); // workitem 8813
-
-                }
-                catch (System.IO.PathTooLongException ptle)
-                {
-                    // workitem 14035
-                    var msg = String.Format("The path is too long, filename={0}",
-                                            filename);
-                    throw new ZipException(msg, ptle);
-                }
-
-            }
-
-            entry._LastModified = entry._Mtime;
-            entry._FileNameInArchive = SharedUtilities.NormalizePathForUseInZipFile(nameInArchive);
-            // We don't actually slurp in the file data until the caller invokes Write on this entry.
-
-            return entry;
-        }
-
-
-
-
-        internal void MarkAsDirectory()
-        {
-            _IsDirectory = true;
-            // workitem 6279
-            if (!_FileNameInArchive.EndsWith("/"))
-                _FileNameInArchive += "/";
-        }
-
-
-
-        /// <summary>
-        ///   Indicates whether an entry is marked as a text file. Be careful when
-        ///   using on this property. Unless you have a good reason, you should
-        ///   probably ignore this property.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The ZIP format includes a provision for specifying whether an entry in
-        ///   the zip archive is a text or binary file.  This property exposes that
-        ///   metadata item. Be careful when using this property: It's not clear
-        ///   that this property as a firm meaning, across tools and libraries.
-        /// </para>
-        ///
-        /// <para>
-        ///   To be clear, when reading a zip file, the property value may or may
-        ///   not be set, and its value may or may not be valid.  Not all entries
-        ///   that you may think of as "text" entries will be so marked, and entries
-        ///   marked as "text" are not guaranteed in any way to be text entries.
-        ///   Whether the value is set and set correctly depends entirely on the
-        ///   application that produced the zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   There are many zip tools available, and when creating zip files, some
-        ///   of them "respect" the IsText metadata field, and some of them do not.
-        ///   Unfortunately, even when an application tries to do "the right thing",
-        ///   it's not always clear what "the right thing" is.
-        /// </para>
-        ///
-        /// <para>
-        ///   There's no firm definition of just what it means to be "a text file",
-        ///   and the zip specification does not help in this regard. Twenty years
-        ///   ago, text was ASCII, each byte was less than 127. IsText meant, all
-        ///   bytes in the file were less than 127.  These days, it is not the case
-        ///   that all text files have all bytes less than 127.  Any unicode file
-        ///   may have bytes that are above 0x7f.  The zip specification has nothing
-        ///   to say on this topic. Therefore, it's not clear what IsText really
-        ///   means.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property merely tells a reading application what is stored in the
-        ///   metadata for an entry, without guaranteeing its validity or its
-        ///   meaning.
-        /// </para>
-        ///
-        /// <para>
-        ///   When DotNetZip is used to create a zipfile, it attempts to set this
-        ///   field "correctly." For example, if a file ends in ".txt", this field
-        ///   will be set. Your application may override that default setting.  When
-        ///   writing a zip file, you must set the property before calling
-        ///   <c>Save()</c> on the ZipFile.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading a zip file, a more general way to decide just what kind
-        ///   of file is contained in a particular entry is to use the file type
-        ///   database stored in the operating system.  The operating system stores
-        ///   a table that says, a file with .jpg extension is a JPG image file, a
-        ///   file with a .xml extension is an XML document, a file with a .txt is a
-        ///   pure ASCII text document, and so on.  To get this information on
-        ///   Windows, <see
-        ///   href="http://www.codeproject.com/KB/cs/GetFileTypeAndIcon.aspx"> you
-        ///   need to read and parse the registry.</see> </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code>
-        /// using (var zip = new ZipFile())
-        /// {
-        ///     var e = zip.UpdateFile("Descriptions.mme", "");
-        ///     e.IsText = true;
-        ///     zip.Save(zipPath);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     Dim e2 as ZipEntry = zip.AddFile("Descriptions.mme", "")
-        ///     e.IsText= True
-        ///     zip.Save(zipPath)
-        /// End Using
-        /// </code>
-        /// </example>
-        public bool IsText
-        {
-            // workitem 7801
-            get { return _IsText; }
-            set { _IsText = value; }
-        }
-
-
-
-        /// <summary>Provides a string representation of the instance.</summary>
-        /// <returns>a string representation of the instance.</returns>
-        public override String ToString()
-        {
-            return String.Format("ZipEntry::{0}", FileName);
-        }
-
-
-        internal Stream ArchiveStream
-        {
-            get
-            {
-                if (_archiveStream == null)
-                {
-                    if (_container.ZipFile != null)
-                    {
-                        var zf = _container.ZipFile;
-                        zf.Reset(false);
-                        _archiveStream = zf.StreamForDiskNumber(_diskNumber);
-                    }
-                    else
-                    {
-                        _archiveStream = _container.ZipOutputStream.OutputStream;
-                    }
-                }
-                return _archiveStream;
-            }
-        }
-
-
-        private void SetFdpLoh()
-        {
-            // The value for FileDataPosition has not yet been set.
-            // Therefore, seek to the local header, and figure the start of file data.
-            // workitem 8098: ok (restore)
-            long origPosition = this.ArchiveStream.Position;
-            try
-            {
-                this.ArchiveStream.Seek(this._RelativeOffsetOfLocalHeader, SeekOrigin.Begin);
-
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-            }
-            catch (System.IO.IOException exc1)
-            {
-                string description = String.Format("Exception seeking  entry({0}) offset(0x{1:X8}) len(0x{2:X8})",
-                                                   this.FileName, this._RelativeOffsetOfLocalHeader,
-                                                   this.ArchiveStream.Length);
-                throw new BadStateException(description, exc1);
-            }
-
-            byte[] block = new byte[30];
-            this.ArchiveStream.Read(block, 0, block.Length);
-
-            // At this point we could verify the contents read from the local header
-            // with the contents read from the central header.  We could, but don't need to.
-            // So we won't.
-
-            Int16 filenameLength = (short)(block[26] + block[27] * 256);
-            Int16 extraFieldLength = (short)(block[28] + block[29] * 256);
-
-            // Console.WriteLine("  pos  0x{0:X8} ({0})", this.ArchiveStream.Position);
-            // Console.WriteLine("  seek 0x{0:X8} ({0})", filenameLength + extraFieldLength);
-
-            this.ArchiveStream.Seek(filenameLength + extraFieldLength, SeekOrigin.Current);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-
-            this._LengthOfHeader = 30 + extraFieldLength + filenameLength +
-                GetLengthOfCryptoHeaderBytes(_Encryption_FromZipFile);
-
-            // Console.WriteLine("  ROLH  0x{0:X8} ({0})", _RelativeOffsetOfLocalHeader);
-            // Console.WriteLine("  LOH   0x{0:X8} ({0})", _LengthOfHeader);
-            // workitem 8098: ok (arithmetic)
-            this.__FileDataPosition = _RelativeOffsetOfLocalHeader + _LengthOfHeader;
-            // Console.WriteLine("  FDP   0x{0:X8} ({0})", __FileDataPosition);
-
-            // restore file position:
-            // workitem 8098: ok (restore)
-            this.ArchiveStream.Seek(origPosition, SeekOrigin.Begin);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(this.ArchiveStream);
-        }
-
-
-
-#if AESCRYPTO
-        private static int GetKeyStrengthInBits(EncryptionAlgorithm a)
-        {
-            if (a == EncryptionAlgorithm.WinZipAes256) return 256;
-            else if (a == EncryptionAlgorithm.WinZipAes128) return 128;
-            return -1;
-        }
-#endif
-
-        internal static int GetLengthOfCryptoHeaderBytes(EncryptionAlgorithm a)
-        {
-            //if ((_BitField & 0x01) != 0x01) return 0;
-            if (a == EncryptionAlgorithm.None) return 0;
-
-#if AESCRYPTO
-            if (a == EncryptionAlgorithm.WinZipAes128 ||
-                a == EncryptionAlgorithm.WinZipAes256)
-            {
-                int KeyStrengthInBits = GetKeyStrengthInBits(a);
-                int sizeOfSaltAndPv = ((KeyStrengthInBits / 8 / 2) + 2);
-                return sizeOfSaltAndPv;
-            }
-#endif
-            if (a == EncryptionAlgorithm.PkzipWeak)
-                return 12;
-            throw new ZipException("internal error");
-        }
-
-
-        internal long FileDataPosition
-        {
-            get
-            {
-                if (__FileDataPosition == -1)
-                    SetFdpLoh();
-
-                return __FileDataPosition;
-            }
-        }
-
-        private int LengthOfHeader
-        {
-            get
-            {
-                if (_LengthOfHeader == 0)
-                    SetFdpLoh();
-
-                return _LengthOfHeader;
-            }
-        }
-
-
-
-        private ZipCrypto _zipCrypto_forExtract;
-        private ZipCrypto _zipCrypto_forWrite;
-#if AESCRYPTO
-        private WinZipAesCrypto _aesCrypto_forExtract;
-        private WinZipAesCrypto _aesCrypto_forWrite;
-        private Int16 _WinZipAesMethod;
-#endif
-
-        internal DateTime _LastModified;
-        private DateTime _Mtime, _Atime, _Ctime;  // workitem 6878: NTFS quantities
-        private bool _ntfsTimesAreSet;
-        private bool _emitNtfsTimes = true;
-        private bool _emitUnixTimes;  // by default, false
-        private bool _TrimVolumeFromFullyQualifiedPaths = true;  // by default, trim them.
-        internal string _LocalFileName;
-        private string _FileNameInArchive;
-        internal Int16 _VersionNeeded;
-        internal Int16 _BitField;
-        internal Int16 _CompressionMethod;
-        private Int16 _CompressionMethod_FromZipFile;
-        private Ionic.Zlib.CompressionLevel _CompressionLevel;
-        internal string _Comment;
-        private bool _IsDirectory;
-        private byte[] _CommentBytes;
-        internal Int64 _CompressedSize;
-        internal Int64 _CompressedFileDataSize; // CompressedSize less 12 bytes for the encryption header, if any
-        internal Int64 _UncompressedSize;
-        internal Int32 _TimeBlob;
-        private bool _crcCalculated;
-        internal Int32 _Crc32;
-        internal byte[] _Extra;
-        private bool _metadataChanged;
-        private bool _restreamRequiredOnSave;
-        private bool _sourceIsEncrypted;
-        private bool _skippedDuringSave;
-        private UInt32 _diskNumber;
-
-        private static System.Text.Encoding ibm437 = System.Text.Encoding.ASCII;
-        //private System.Text.Encoding _provisionalAlternateEncoding = System.Text.Encoding.ASCII;
-        private System.Text.Encoding _actualEncoding;
-
-        internal ZipContainer _container;
-
-        private long __FileDataPosition = -1;
-        private byte[] _EntryHeader;
-        internal Int64 _RelativeOffsetOfLocalHeader;
-        private Int64 _future_ROLH;
-        private Int64 _TotalEntrySize;
-        private int _LengthOfHeader;
-        private int _LengthOfTrailer;
-        internal bool _InputUsesZip64;
-        private UInt32 _UnsupportedAlgorithmId;
-
-        internal string _Password;
-        internal ZipEntrySource _Source;
-        internal EncryptionAlgorithm _Encryption;
-        internal EncryptionAlgorithm _Encryption_FromZipFile;
-        internal byte[] _WeakEncryptionHeader;
-        internal Stream _archiveStream;
-        private Stream _sourceStream;
-        private Nullable<Int64> _sourceStreamOriginalPosition;
-        private bool _sourceWasJitProvided;
-        private bool _ioOperationCanceled;
-        private bool _presumeZip64;
-        private Nullable<bool> _entryRequiresZip64;
-        private Nullable<bool> _OutputUsesZip64;
-        private bool _IsText; // workitem 7801
-        private ZipEntryTimestamp _timestamp;
-
-        private static System.DateTime _unixEpoch = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        private static System.DateTime _win32Epoch = System.DateTime.FromFileTimeUtc(0L);
-        private static System.DateTime _zeroHour = new System.DateTime(1, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        private WriteDelegate _WriteDelegate;
-        private OpenDelegate _OpenDelegate;
-        private CloseDelegate _CloseDelegate;
-
-
-        // summary
-        // The default size of the IO buffer for ZipEntry instances. Currently it is 8192 bytes.
-        // summary
-        //public const int IO_BUFFER_SIZE_DEFAULT = 8192; // 0x8000; // 0x4400
-
-    }
-
-
-
-    /// <summary>
-    ///   An enum that specifies the type of timestamp available on the ZipEntry.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///
-    /// <para>
-    ///   The last modified time of a file can be stored in multiple ways in
-    ///   a zip file, and they are not mutually exclusive:
-    /// </para>
-    ///
-    /// <list type="bullet">
-    ///   <item>
-    ///     In the so-called "DOS" format, which has a 2-second precision. Values
-    ///     are rounded to the nearest even second. For example, if the time on the
-    ///     file is 12:34:43, then it will be stored as 12:34:44. This first value
-    ///     is accessible via the <c>LastModified</c> property. This value is always
-    ///     present in the metadata for each zip entry.  In some cases the value is
-    ///     invalid, or zero.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     In the so-called "Windows" or "NTFS" format, as an 8-byte integer
-    ///     quantity expressed as the number of 1/10 milliseconds (in other words
-    ///     the number of 100 nanosecond units) since January 1, 1601 (UTC).  This
-    ///     format is how Windows represents file times.  This time is accessible
-    ///     via the <c>ModifiedTime</c> property.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     In the "Unix" format, a 4-byte quantity specifying the number of seconds since
-    ///     January 1, 1970 UTC.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     In an older format, now deprecated but still used by some current
-    ///     tools. This format is also a 4-byte quantity specifying the number of
-    ///     seconds since January 1, 1970 UTC.
-    ///   </item>
-    ///
-    /// </list>
-    ///
-    /// <para>
-    ///   This bit field describes which of the formats were found in a <c>ZipEntry</c> that was read.
-    /// </para>
-    ///
-    /// </remarks>
-    [Flags]
-    internal enum ZipEntryTimestamp
-    {
-        /// <summary>
-        /// Default value.
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// A DOS timestamp with 2-second precision.
-        /// </summary>
-        DOS = 1,
-
-        /// <summary>
-        /// A Windows timestamp with 100-ns precision.
-        /// </summary>
-        Windows = 2,
-
-        /// <summary>
-        /// A Unix timestamp with 1-second precision.
-        /// </summary>
-        Unix = 4,
-
-        /// <summary>
-        /// A Unix timestamp with 1-second precision, stored in InfoZip v1 format.  This
-        /// format is outdated and is supported for reading archives only.
-        /// </summary>
-        InfoZip1 = 8,
-    }
-
-
-
-    /// <summary>
-    ///   The method of compression to use for a particular ZipEntry.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///   <see
-    ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWare's
-    ///   ZIP Specification</see> describes a number of distinct
-    ///   cmopression methods that can be used within a zip
-    ///   file. DotNetZip supports a subset of them.
-    /// </remarks>
-    internal enum CompressionMethod
-    {
-        /// <summary>
-        /// No compression at all. For COM environments, the value is 0 (zero).
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        ///   DEFLATE compression, as described in <see
-        ///   href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC
-        ///   1951</see>.  This is the "normal" compression used in zip
-        ///   files. For COM environments, the value is 8.
-        /// </summary>
-        Deflate = 8,
-
-#if BZIP
-        /// <summary>
-        ///   BZip2 compression, a compression algorithm developed by Julian Seward.
-        ///   For COM environments, the value is 12.
-        /// </summary>
-        BZip2 = 12,
-#endif
-    }
-
-
-#if NETCF
-    internal class NetCfFile
-    {
-        public static int SetTimes(string filename, DateTime ctime, DateTime atime, DateTime mtime)
-        {
-            IntPtr hFile  = (IntPtr) CreateFileCE(filename,
-                                                  (uint)0x40000000L, // (uint)FileAccess.Write,
-                                                  (uint)0x00000002L, // (uint)FileShare.Write,
-                                                  0,
-                                                  (uint) 3,  // == open existing
-                                                  (uint)0, // flagsAndAttributes
-                                                  0);
-
-            if((int)hFile == -1)
-            {
-                // workitem 7944: don't throw on failure to set file times
-                // throw new ZipException("CreateFileCE Failed");
-                return Interop.Marshal.GetLastWin32Error();
-            }
-
-            SetFileTime(hFile,
-                        BitConverter.GetBytes(ctime.ToFileTime()),
-                        BitConverter.GetBytes(atime.ToFileTime()),
-                        BitConverter.GetBytes(mtime.ToFileTime()));
-
-            CloseHandle(hFile);
-            return 0;
-        }
-
-
-        public static int SetLastWriteTime(string filename, DateTime mtime)
-        {
-            IntPtr hFile  = (IntPtr) CreateFileCE(filename,
-                                                  (uint)0x40000000L, // (uint)FileAccess.Write,
-                                                  (uint)0x00000002L, // (uint)FileShare.Write,
-                                                  0,
-                                                  (uint) 3,  // == open existing
-                                                  (uint)0, // flagsAndAttributes
-                                                  0);
-
-            if((int)hFile == -1)
-            {
-                // workitem 7944: don't throw on failure to set file time
-                // throw new ZipException(String.Format("CreateFileCE Failed ({0})",
-                //                                      Interop.Marshal.GetLastWin32Error()));
-                return Interop.Marshal.GetLastWin32Error();
-            }
-
-            SetFileTime(hFile, null, null,
-                        BitConverter.GetBytes(mtime.ToFileTime()));
-
-            CloseHandle(hFile);
-            return 0;
-        }
-
-
-        [Interop.DllImport("coredll.dll", EntryPoint="CreateFile", SetLastError=true)]
-        internal static extern int CreateFileCE(string lpFileName,
-                                                uint dwDesiredAccess,
-                                                uint dwShareMode,
-                                                int lpSecurityAttributes,
-                                                uint dwCreationDisposition,
-                                                uint dwFlagsAndAttributes,
-                                                int hTemplateFile);
-
-
-        [Interop.DllImport("coredll", EntryPoint="GetFileAttributes", SetLastError=true)]
-        internal static extern uint GetAttributes(string lpFileName);
-
-        [Interop.DllImport("coredll", EntryPoint="SetFileAttributes", SetLastError=true)]
-        internal static extern bool SetAttributes(string lpFileName, uint dwFileAttributes);
-
-        [Interop.DllImport("coredll", EntryPoint="SetFileTime", SetLastError=true)]
-        internal static extern bool SetFileTime(IntPtr hFile, byte[] lpCreationTime, byte[] lpLastAccessTime, byte[] lpLastWriteTime);
-
-        [Interop.DllImport("coredll.dll", SetLastError=true)]
-        internal static extern bool CloseHandle(IntPtr hObject);
-
-    }
-#endif
-
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipEntrySource.cs b/EPPlus/Packaging/DotNetZip/ZipEntrySource.cs
deleted file mode 100644
index eb90a18..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipEntrySource.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// ZipEntrySource.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-November-19 11:18:42>
-//
-// ------------------------------------------------------------------
-//
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// An enum that specifies the source of the ZipEntry. 
-    /// </summary>
-    internal enum ZipEntrySource
-    {
-        /// <summary>
-        /// Default value.  Invalid on a bonafide ZipEntry.
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// The entry was instantiated by calling AddFile() or another method that 
-        /// added an entry from the filesystem.
-        /// </summary>
-        FileSystem,
-
-        /// <summary>
-        /// The entry was instantiated via <see cref="Ionic.Zip.ZipFile.AddEntry(string,string)"/> or
-        /// <see cref="Ionic.Zip.ZipFile.AddEntry(string,System.IO.Stream)"/> .
-        /// </summary>
-        Stream,
-
-        /// <summary>
-        /// The ZipEntry was instantiated by reading a zipfile.
-        /// </summary>
-        ZipFile,
-        
-        /// <summary>
-        /// The content for the ZipEntry will be or was provided by the WriteDelegate.
-        /// </summary>
-        WriteDelegate,
-        
-        /// <summary>
-        /// The content for the ZipEntry will be obtained from the stream dispensed by the <c>OpenDelegate</c>.
-        /// The entry was instantiated via <see cref="Ionic.Zip.ZipFile.AddEntry(string,OpenDelegate,CloseDelegate)"/>.
-        /// </summary>
-        JitStream,
-        
-        /// <summary>
-        /// The content for the ZipEntry will be or was obtained from a <c>ZipOutputStream</c>.
-        /// </summary>
-        ZipOutputStream,
-    }
-    
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/ZipErrorAction.cs b/EPPlus/Packaging/DotNetZip/ZipErrorAction.cs
deleted file mode 100644
index f8894dd..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipErrorAction.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// ZipErrorAction.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c)  2009 Dino Chiesa
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-September-01 18:43:20>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZipErrorAction enum, which provides
-// an action to take when errors occur when opening or reading
-// files to be added to a zip file. 
-// 
-// ------------------------------------------------------------------
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    /// An enum providing the options when an error occurs during opening or reading
-    /// of a file or directory that is being saved to a zip file. 
-    /// </summary>
-    ///
-    /// <remarks>
-    ///  <para>
-    ///    This enum describes the actions that the library can take when an error occurs
-    ///    opening or reading a file, as it is being saved into a Zip archive. 
-    ///  </para>
-    ///
-    ///  <para>
-    ///     In some cases an error will occur when DotNetZip tries to open a file to be
-    ///     added to the zip archive.  In other cases, an error might occur after the
-    ///     file has been successfully opened, while DotNetZip is reading the file.
-    ///  </para>
-    /// 
-    ///  <para>
-    ///    The first problem might occur when calling AddDirectory() on a directory
-    ///    that contains a Clipper .dbf file; the file is locked by Clipper and
-    ///    cannot be opened by another process. An example of the second problem is
-    ///    the ERROR_LOCK_VIOLATION that results when a file is opened by another
-    ///    process, but not locked, and a range lock has been taken on the file.
-    ///    Microsoft Outlook takes range locks on .PST files.
-    ///  </para>
-    /// </remarks>
-    internal enum ZipErrorAction
-    {
-        /// <summary>
-        /// Throw an exception when an error occurs while zipping.  This is the default
-        /// behavior.  (For COM clients, this is a 0 (zero).)
-        /// </summary>
-        Throw,
-
-        /// <summary>
-        /// When an error occurs during zipping, for example a file cannot be opened,
-        /// skip the file causing the error, and continue zipping.  (For COM clients,
-        /// this is a 1.)
-        /// </summary>
-        Skip,
-        
-        /// <summary>
-        /// When an error occurs during zipping, for example a file cannot be opened,
-        /// retry the operation that caused the error. Be careful with this option. If
-        /// the error is not temporary, the library will retry forever.  (For COM
-        /// clients, this is a 2.)
-        /// </summary>
-        Retry,
-
-        /// <summary>
-        /// When an error occurs, invoke the zipError event.  The event type used is
-        /// <see cref="ZipProgressEventType.Error_Saving"/>.  A typical use of this option:
-        /// a GUI application may wish to pop up a dialog to allow the user to view the
-        /// error that occurred, and choose an appropriate action.  After your
-        /// processing in the error event, if you want to skip the file, set <see
-        /// cref="ZipEntry.ZipErrorAction"/> on the
-        /// <c>ZipProgressEventArgs.CurrentEntry</c> to <c>Skip</c>.  If you want the
-        /// exception to be thrown, set <c>ZipErrorAction</c> on the <c>CurrentEntry</c>
-        /// to <c>Throw</c>.  If you want to cancel the zip, set
-        /// <c>ZipProgressEventArgs.Cancel</c> to true.  Cancelling differs from using
-        /// Skip in that a cancel will not save any further entries, if there are any.
-        /// (For COM clients, the value of this enum is a 3.)
-        /// </summary>
-        InvokeErrorEvent,
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.AddUpdate.cs b/EPPlus/Packaging/DotNetZip/ZipFile.AddUpdate.cs
deleted file mode 100644
index 46e9588..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.AddUpdate.cs
+++ /dev/null
@@ -1,2182 +0,0 @@
-// ZipFile.AddUpdate.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-November-01 13:56:58>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for Adding and Updating entries in
-// the ZipFile.
-//
-// ------------------------------------------------------------------
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal partial class ZipFile
-    {
-        /// <summary>
-        ///   Adds an item, either a file or a directory, to a zip file archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method is handy if you are adding things to zip archive and don't
-        ///   want to bother distinguishing between directories or files.  Any files are
-        ///   added as single entries.  A directory added through this method is added
-        ///   recursively: all files and subdirectories contained within the directory
-        ///   are added to the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   The name of the item may be a relative path or a fully-qualified
-        ///   path. Remember, the items contained in <c>ZipFile</c> instance get written
-        ///   to the disk only when you call <see cref="ZipFile.Save()"/> or a similar
-        ///   save method.
-        /// </para>
-        ///
-        /// <para>
-        ///   The directory name used for the file within the archive is the same
-        ///   as the directory name (potentially a relative path) specified in the
-        ///   <paramref name="fileOrDirectoryName"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string)"/>
-        ///
-        /// <overloads>This method has two overloads.</overloads>
-        /// <param name="fileOrDirectoryName">
-        /// the name of the file or directory to add.</param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddItem(string fileOrDirectoryName)
-        {
-            return AddItem(fileOrDirectoryName, null);
-        }
-
-
-        /// <summary>
-        ///   Adds an item, either a file or a directory, to a zip file archive,
-        ///   explicitly specifying the directory path to be used in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   If adding a directory, the add is recursive on all files and
-        ///   subdirectories contained within it.
-        /// </para>
-        /// <para>
-        ///   The name of the item may be a relative path or a fully-qualified path.
-        ///   The item added by this call to the <c>ZipFile</c> is not read from the
-        ///   disk nor written to the zip file archive until the application calls
-        ///   Save() on the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the method allows the caller to explicitly specify the
-        ///   directory path to be used in the archive, which would override the
-        ///   "natural" path of the filesystem file.
-        /// </para>
-        ///
-        /// <para>
-        ///   Encryption will be used on the file data if the <c>Password</c> has
-        ///   been set on the <c>ZipFile</c> object, prior to calling this method.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="System.IO.FileNotFoundException">
-        ///   Thrown if the file or directory passed in does not exist.
-        /// </exception>
-        ///
-        /// <param name="fileOrDirectoryName">the name of the file or directory to add.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   The name of the directory path to use within the zip archive.  This path
-        ///   need not refer to an extant directory in the current filesystem.  If the
-        ///   files within the zip are later extracted, this is the path used for the
-        ///   extracted file.  Passing <c>null</c> (<c>Nothing</c> in VB) will use the
-        ///   path on the fileOrDirectoryName.  Passing the empty string ("") will
-        ///   insert the item at the root path within the archive.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string, string)"/>
-        ///
-        /// <example>
-        ///   This example shows how to zip up a set of files into a flat hierarchy,
-        ///   regardless of where in the filesystem the files originated. The resulting
-        ///   zip archive will contain a toplevel directory named "flat", which itself
-        ///   will contain files Readme.txt, MyProposal.docx, and Image1.jpg.  A
-        ///   subdirectory under "flat" called SupportFiles will contain all the files
-        ///   in the "c:\SupportFiles" directory on disk.
-        ///
-        /// <code>
-        /// String[] itemnames= {
-        ///   "c:\\fixedContent\\Readme.txt",
-        ///   "MyProposal.docx",
-        ///   "c:\\SupportFiles",  // a directory
-        ///   "images\\Image1.jpg"
-        /// };
-        ///
-        /// try
-        /// {
-        ///   using (ZipFile zip = new ZipFile())
-        ///   {
-        ///     for (int i = 1; i &lt; itemnames.Length; i++)
-        ///     {
-        ///       // will add Files or Dirs, recurses and flattens subdirectories
-        ///       zip.AddItem(itemnames[i],"flat");
-        ///     }
-        ///     zip.Save(ZipToCreate);
-        ///   }
-        /// }
-        /// catch (System.Exception ex1)
-        /// {
-        ///   System.Console.Error.WriteLine("exception: {0}", ex1);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///   Dim itemnames As String() = _
-        ///     New String() { "c:\fixedContent\Readme.txt", _
-        ///                    "MyProposal.docx", _
-        ///                    "SupportFiles", _
-        ///                    "images\Image1.jpg" }
-        ///   Try
-        ///       Using zip As New ZipFile
-        ///           Dim i As Integer
-        ///           For i = 1 To itemnames.Length - 1
-        ///               ' will add Files or Dirs, recursing and flattening subdirectories.
-        ///               zip.AddItem(itemnames(i), "flat")
-        ///           Next i
-        ///           zip.Save(ZipToCreate)
-        ///       End Using
-        ///   Catch ex1 As Exception
-        ///       Console.Error.WriteLine("exception: {0}", ex1.ToString())
-        ///   End Try
-        /// </code>
-        /// </example>
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddItem(String fileOrDirectoryName, String directoryPathInArchive)
-        {
-            if (File.Exists(fileOrDirectoryName))
-                return AddFile(fileOrDirectoryName, directoryPathInArchive);
-
-            if (Directory.Exists(fileOrDirectoryName))
-                return AddDirectory(fileOrDirectoryName, directoryPathInArchive);
-
-            throw new FileNotFoundException(String.Format("That file or directory ({0}) does not exist!",
-                                                          fileOrDirectoryName));
-        }
-
-        /// <summary>
-        ///   Adds a File to a Zip file archive.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This call collects metadata for the named file in the filesystem,
-        ///   including the file attributes and the timestamp, and inserts that metadata
-        ///   into the resulting ZipEntry.  Only when the application calls Save() on
-        ///   the <c>ZipFile</c>, does DotNetZip read the file from the filesystem and
-        ///   then write the content to the zip file archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method will throw an exception if an entry with the same name already
-        ///   exists in the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   In this example, three files are added to a Zip archive. The ReadMe.txt
-        ///   file will be placed in the root of the archive. The .png file will be
-        ///   placed in a folder within the zip called photos\personal.  The pdf file
-        ///   will be included into a folder within the zip called Desktop.
-        /// </para>
-        /// <code>
-        ///    try
-        ///    {
-        ///      using (ZipFile zip = new ZipFile())
-        ///      {
-        ///        zip.AddFile("c:\\photos\\personal\\7440-N49th.png");
-        ///        zip.AddFile("c:\\Desktop\\2008-Regional-Sales-Report.pdf");
-        ///        zip.AddFile("ReadMe.txt");
-        ///
-        ///        zip.Save("Package.zip");
-        ///      }
-        ///    }
-        ///    catch (System.Exception ex1)
-        ///    {
-        ///      System.Console.Error.WriteLine("exception: " + ex1);
-        ///    }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///  Try
-        ///       Using zip As ZipFile = New ZipFile
-        ///           zip.AddFile("c:\photos\personal\7440-N49th.png")
-        ///           zip.AddFile("c:\Desktop\2008-Regional-Sales-Report.pdf")
-        ///           zip.AddFile("ReadMe.txt")
-        ///           zip.Save("Package.zip")
-        ///       End Using
-        ///   Catch ex1 As Exception
-        ///       Console.Error.WriteLine("exception: {0}", ex1.ToString)
-        ///   End Try
-        /// </code>
-        /// </example>
-        ///
-        /// <overloads>This method has two overloads.</overloads>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string)"/>
-        ///
-        /// <param name="fileName">
-        ///   The name of the file to add. It should refer to a file in the filesystem.
-        ///   The name of the file may be a relative path or a fully-qualified path.
-        /// </param>
-        /// <returns>The <c>ZipEntry</c> corresponding to the File added.</returns>
-        public ZipEntry AddFile(string fileName)
-        {
-            return AddFile(fileName, null);
-        }
-
-
-
-
-
-        /// <summary>
-        ///   Adds a File to a Zip file archive, potentially overriding the path to be
-        ///   used within the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The file added by this call to the <c>ZipFile</c> is not written to the
-        ///   zip file archive until the application calls Save() on the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method will throw an exception if an entry with the same name already
-        ///   exists in the <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the method allows the caller to explicitly specify the
-        ///   directory path to be used in the archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   In this example, three files are added to a Zip archive. The ReadMe.txt
-        ///   file will be placed in the root of the archive. The .png file will be
-        ///   placed in a folder within the zip called images.  The pdf file will be
-        ///   included into a folder within the zip called files\docs, and will be
-        ///   encrypted with the given password.
-        /// </para>
-        /// <code>
-        /// try
-        /// {
-        ///   using (ZipFile zip = new ZipFile())
-        ///   {
-        ///     // the following entry will be inserted at the root in the archive.
-        ///     zip.AddFile("c:\\datafiles\\ReadMe.txt", "");
-        ///     // this image file will be inserted into the "images" directory in the archive.
-        ///     zip.AddFile("c:\\photos\\personal\\7440-N49th.png", "images");
-        ///     // the following will result in a password-protected file called
-        ///     // files\\docs\\2008-Regional-Sales-Report.pdf  in the archive.
-        ///     zip.Password = "EncryptMe!";
-        ///     zip.AddFile("c:\\Desktop\\2008-Regional-Sales-Report.pdf", "files\\docs");
-        ///     zip.Save("Archive.zip");
-        ///   }
-        /// }
-        /// catch (System.Exception ex1)
-        /// {
-        ///   System.Console.Error.WriteLine("exception: {0}", ex1);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///   Try
-        ///       Using zip As ZipFile = New ZipFile
-        ///           ' the following entry will be inserted at the root in the archive.
-        ///           zip.AddFile("c:\datafiles\ReadMe.txt", "")
-        ///           ' this image file will be inserted into the "images" directory in the archive.
-        ///           zip.AddFile("c:\photos\personal\7440-N49th.png", "images")
-        ///           ' the following will result in a password-protected file called
-        ///           ' files\\docs\\2008-Regional-Sales-Report.pdf  in the archive.
-        ///           zip.Password = "EncryptMe!"
-        ///           zip.AddFile("c:\Desktop\2008-Regional-Sales-Report.pdf", "files\documents")
-        ///           zip.Save("Archive.zip")
-        ///       End Using
-        ///   Catch ex1 As Exception
-        ///       Console.Error.WriteLine("exception: {0}", ex1)
-        ///   End Try
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string,string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string,string)"/>
-        ///
-        /// <param name="fileName">
-        ///   The name of the file to add.  The name of the file may be a relative path
-        ///   or a fully-qualified path.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the fileName.
-        ///   This path may, or may not, correspond to a real directory in the current
-        ///   filesystem.  If the files within the zip are later extracted, this is the
-        ///   path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in
-        ///   VB) will use the path on the fileName, if any.  Passing the empty string
-        ///   ("") will insert the item at the root path within the archive.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> corresponding to the file added.</returns>
-        public ZipEntry AddFile(string fileName, String directoryPathInArchive)
-        {
-            string nameInArchive = ZipEntry.NameInArchive(fileName, directoryPathInArchive);
-            ZipEntry ze = ZipEntry.CreateFromFile(fileName, nameInArchive);
-            if (Verbose) StatusMessageTextWriter.WriteLine("adding {0}...", fileName);
-            return _InternalAddEntry(ze);
-        }
-
-
-        /// <summary>
-        ///   This method removes a collection of entries from the <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <param name="entriesToRemove">
-        ///   A collection of ZipEntry instances from this zip file to be removed. For
-        ///   example, you can pass in an array of ZipEntry instances; or you can call
-        ///   SelectEntries(), and then add or remove entries from that
-        ///   ICollection&lt;ZipEntry&gt; (ICollection(Of ZipEntry) in VB), and pass
-        ///   that ICollection to this method.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.SelectEntries(String)" />
-        /// <seealso cref="Ionic.Zip.ZipFile.RemoveSelectedEntries(String)" />
-        public void RemoveEntries(System.Collections.Generic.ICollection<ZipEntry> entriesToRemove)
-        {
-            if (entriesToRemove == null)
-                throw new ArgumentNullException("entriesToRemove");
-
-            foreach (ZipEntry e in entriesToRemove)
-            {
-                this.RemoveEntry(e);
-            }
-        }
-
-
-        /// <summary>
-        ///   This method removes a collection of entries from the <c>ZipFile</c>, by name.
-        /// </summary>
-        ///
-        /// <param name="entriesToRemove">
-        ///   A collection of strings that refer to names of entries to be removed
-        ///   from the <c>ZipFile</c>.  For example, you can pass in an array or a
-        ///   List of Strings that provide the names of entries to be removed.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.SelectEntries(String)" />
-        /// <seealso cref="Ionic.Zip.ZipFile.RemoveSelectedEntries(String)" />
-        public void RemoveEntries(System.Collections.Generic.ICollection<String> entriesToRemove)
-        {
-            if (entriesToRemove == null)
-                throw new ArgumentNullException("entriesToRemove");
-
-            foreach (String e in entriesToRemove)
-            {
-                this.RemoveEntry(e);
-            }
-        }
-
-
-        /// <summary>
-        ///   This method adds a set of files to the <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Use this method to add a set of files to the zip archive, in one call.
-        ///   For example, a list of files received from
-        ///   <c>System.IO.Directory.GetFiles()</c> can be added to a zip archive in one
-        ///   call.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="fileNames">
-        ///   The collection of names of the files to add. Each string should refer to a
-        ///   file in the filesystem. The name of the file may be a relative path or a
-        ///   fully-qualified path.
-        /// </param>
-        ///
-        /// <example>
-        ///   This example shows how to create a zip file, and add a few files into it.
-        /// <code>
-        /// String ZipFileToCreate = "archive1.zip";
-        /// String DirectoryToZip = "c:\\reports";
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///   // Store all files found in the top level directory, into the zip archive.
-        ///   String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
-        ///   zip.AddFiles(filenames);
-        ///   zip.Save(ZipFileToCreate);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim ZipFileToCreate As String = "archive1.zip"
-        /// Dim DirectoryToZip As String = "c:\reports"
-        /// Using zip As ZipFile = New ZipFile
-        ///     ' Store all files found in the top level directory, into the zip archive.
-        ///     Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
-        ///     zip.AddFiles(filenames)
-        ///     zip.Save(ZipFileToCreate)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddSelectedFiles(String, String)" />
-        public void AddFiles(System.Collections.Generic.IEnumerable<String> fileNames)
-        {
-            this.AddFiles(fileNames, null);
-        }
-
-
-        /// <summary>
-        ///   Adds or updates a set of files in the <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Any files that already exist in the archive are updated. Any files that
-        ///   don't yet exist in the archive are added.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="fileNames">
-        ///   The collection of names of the files to update. Each string should refer to a file in
-        ///   the filesystem. The name of the file may be a relative path or a fully-qualified path.
-        /// </param>
-        ///
-        public void UpdateFiles(System.Collections.Generic.IEnumerable<String> fileNames)
-        {
-            this.UpdateFiles(fileNames, null);
-        }
-
-
-        /// <summary>
-        ///   Adds a set of files to the <c>ZipFile</c>, using the
-        ///   specified directory path in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Any directory structure that may be present in the
-        ///   filenames contained in the list is "flattened" in the
-        ///   archive.  Each file in the list is added to the archive in
-        ///   the specified top-level directory.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see
-        ///   cref="Encryption"/>, <see cref="Password"/>, <see
-        ///   cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see
-        ///   cref="ExtractExistingFile"/>, <see
-        ///   cref="ZipErrorAction"/>, and <see
-        ///   cref="CompressionLevel"/>, their respective values at the
-        ///   time of this call will be applied to each ZipEntry added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="fileNames">
-        ///   The names of the files to add. Each string should refer to
-        ///   a file in the filesystem.  The name of the file may be a
-        ///   relative path or a fully-qualified path.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the file name.
-        ///   Th is path may, or may not, correspond to a real directory in the current
-        ///   filesystem.  If the files within the zip are later extracted, this is the
-        ///   path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in
-        ///   VB) will use the path on each of the <c>fileNames</c>, if any.  Passing
-        ///   the empty string ("") will insert the item at the root path within the
-        ///   archive.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddSelectedFiles(String, String)" />
-        public void AddFiles(System.Collections.Generic.IEnumerable<String> fileNames, String directoryPathInArchive)
-        {
-            AddFiles(fileNames, false, directoryPathInArchive);
-        }
-
-
-
-        /// <summary>
-        ///   Adds a set of files to the <c>ZipFile</c>, using the specified directory
-        ///   path in the archive, and preserving the full directory structure in the
-        ///   filenames.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Think of the <paramref name="directoryPathInArchive"/> as a "root" or
-        ///   base directory used in the archive for the files that get added.  when
-        ///   <paramref name="preserveDirHierarchy"/> is true, the hierarchy of files
-        ///   found in the filesystem will be placed, with the hierarchy intact,
-        ///   starting at that root in the archive. When <c>preserveDirHierarchy</c>
-        ///   is false, the path hierarchy of files is flattned, and the flattened
-        ///   set of files gets placed in the root within the archive as specified in
-        ///   <c>directoryPathInArchive</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="fileNames">
-        ///   The names of the files to add. Each string should refer to a file in the
-        ///   filesystem.  The name of the file may be a relative path or a
-        ///   fully-qualified path.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use as a prefix for each entry name.
-        ///   This path may, or may not, correspond to a real directory in the current
-        ///   filesystem.  If the files within the zip are later extracted, this is the
-        ///   path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in
-        ///   VB) will use the path on each of the <c>fileNames</c>, if any.  Passing
-        ///   the empty string ("") will insert the item at the root path within the
-        ///   archive.
-        /// </param>
-        ///
-        /// <param name="preserveDirHierarchy">
-        ///   whether the entries in the zip archive will reflect the directory
-        ///   hierarchy that is present in the various filenames.  For example, if
-        ///   <paramref name="fileNames"/> includes two paths,
-        ///   \Animalia\Chordata\Mammalia\Info.txt and
-        ///   \Plantae\Magnoliophyta\Dicotyledon\Info.txt, then calling this method
-        ///   with <paramref name="preserveDirHierarchy"/> = <c>false</c> will
-        ///   result in an exception because of a duplicate entry name, while
-        ///   calling this method with <paramref name="preserveDirHierarchy"/> =
-        ///   <c>true</c> will result in the full direcory paths being included in
-        ///   the entries added to the ZipFile.
-        /// </param>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddSelectedFiles(String, String)" />
-        public void AddFiles(System.Collections.Generic.IEnumerable<String> fileNames,
-                             bool preserveDirHierarchy,
-                             String directoryPathInArchive)
-        {
-            if (fileNames == null)
-                throw new ArgumentNullException("fileNames");
-
-            _addOperationCanceled = false;
-            OnAddStarted();
-            if (preserveDirHierarchy)
-            {
-                foreach (var f in fileNames)
-                {
-                    if (_addOperationCanceled) break;
-                    if (directoryPathInArchive != null)
-                    {
-                        //string s = SharedUtilities.NormalizePath(Path.Combine(directoryPathInArchive, Path.GetDirectoryName(f)));
-                        string s = Path.GetFullPath(Path.Combine(directoryPathInArchive, Path.GetDirectoryName(f)));
-                        this.AddFile(f, s);
-                    }
-                    else
-                        this.AddFile(f, null);
-                }
-            }
-            else
-            {
-                foreach (var f in fileNames)
-                {
-                    if (_addOperationCanceled) break;
-                    this.AddFile(f, directoryPathInArchive);
-                }
-            }
-            if (!_addOperationCanceled)
-                OnAddCompleted();
-        }
-
-
-        /// <summary>
-        ///   Adds or updates a set of files to the <c>ZipFile</c>, using the specified
-        ///   directory path in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Any files that already exist in the archive are updated. Any files that
-        ///   don't yet exist in the archive are added.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="fileNames">
-        ///   The names of the files to add or update. Each string should refer to a
-        ///   file in the filesystem.  The name of the file may be a relative path or a
-        ///   fully-qualified path.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the file name.
-        ///   This path may, or may not, correspond to a real directory in the current
-        ///   filesystem.  If the files within the zip are later extracted, this is the
-        ///   path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in
-        ///   VB) will use the path on each of the <c>fileNames</c>, if any.  Passing
-        ///   the empty string ("") will insert the item at the root path within the
-        ///   archive.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddSelectedFiles(String, String)" />
-        public void UpdateFiles(System.Collections.Generic.IEnumerable<String> fileNames, String directoryPathInArchive)
-        {
-            if (fileNames == null)
-                throw new ArgumentNullException("fileNames");
-
-            OnAddStarted();
-            foreach (var f in fileNames)
-                this.UpdateFile(f, directoryPathInArchive);
-            OnAddCompleted();
-        }
-
-
-
-
-        /// <summary>
-        ///   Adds or Updates a File in a Zip file archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method adds a file to a zip archive, or, if the file already exists
-        ///   in the zip archive, this method Updates the content of that given filename
-        ///   in the zip archive.  The <c>UpdateFile</c> method might more accurately be
-        ///   called "AddOrUpdateFile".
-        /// </para>
-        ///
-        /// <para>
-        ///   Upon success, there is no way for the application to learn whether the file
-        ///   was added versus updated.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to Update an existing entry in a zipfile. The first
-        ///   call to UpdateFile adds the file to the newly-created zip archive.  The
-        ///   second call to UpdateFile updates the content for that file in the zip
-        ///   archive.
-        ///
-        /// <code>
-        /// using (ZipFile zip1 = new ZipFile())
-        /// {
-        ///   // UpdateFile might more accurately be called "AddOrUpdateFile"
-        ///   zip1.UpdateFile("MyDocuments\\Readme.txt");
-        ///   zip1.UpdateFile("CustomerList.csv");
-        ///   zip1.Comment = "This zip archive has been created.";
-        ///   zip1.Save("Content.zip");
-        /// }
-        ///
-        /// using (ZipFile zip2 = ZipFile.Read("Content.zip"))
-        /// {
-        ///   zip2.UpdateFile("Updates\\Readme.txt");
-        ///   zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed.";
-        ///   zip2.Save();
-        /// }
-        ///
-        /// </code>
-        /// <code lang="VB">
-        ///   Using zip1 As New ZipFile
-        ///       ' UpdateFile might more accurately be called "AddOrUpdateFile"
-        ///       zip1.UpdateFile("MyDocuments\Readme.txt")
-        ///       zip1.UpdateFile("CustomerList.csv")
-        ///       zip1.Comment = "This zip archive has been created."
-        ///       zip1.Save("Content.zip")
-        ///   End Using
-        ///
-        ///   Using zip2 As ZipFile = ZipFile.Read("Content.zip")
-        ///       zip2.UpdateFile("Updates\Readme.txt")
-        ///       zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed."
-        ///       zip2.Save
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string)"/>
-        ///
-        /// <param name="fileName">
-        ///   The name of the file to add or update. It should refer to a file in the
-        ///   filesystem.  The name of the file may be a relative path or a
-        ///   fully-qualified path.
-        /// </param>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> corresponding to the File that was added or updated.
-        /// </returns>
-        public ZipEntry UpdateFile(string fileName)
-        {
-            return UpdateFile(fileName, null);
-        }
-
-
-
-        /// <summary>
-        ///   Adds or Updates a File in a Zip file archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method adds a file to a zip archive, or, if the file already exists
-        ///   in the zip archive, this method Updates the content of that given filename
-        ///   in the zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the method allows the caller to explicitly specify the
-        ///   directory path to be used in the archive.  The entry to be added or
-        ///   updated is found by using the specified directory path, combined with the
-        ///   basename of the specified filename.
-        /// </para>
-        ///
-        /// <para>
-        ///   Upon success, there is no way for the application to learn if the file was
-        ///   added versus updated.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string,string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string,string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string,string)"/>
-        ///
-        /// <param name="fileName">
-        ///   The name of the file to add or update. It should refer to a file in the
-        ///   filesystem.  The name of the file may be a relative path or a
-        ///   fully-qualified path.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the
-        ///   <c>fileName</c>.  This path may, or may not, correspond to a real
-        ///   directory in the current filesystem.  If the files within the zip are
-        ///   later extracted, this is the path used for the extracted file.  Passing
-        ///   <c>null</c> (<c>Nothing</c> in VB) will use the path on the
-        ///   <c>fileName</c>, if any.  Passing the empty string ("") will insert the
-        ///   item at the root path within the archive.
-        /// </param>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> corresponding to the File that was added or updated.
-        /// </returns>
-        public ZipEntry UpdateFile(string fileName, String directoryPathInArchive)
-        {
-            // ideally this would all be transactional!
-            var key = ZipEntry.NameInArchive(fileName, directoryPathInArchive);
-            if (this[key] != null)
-                this.RemoveEntry(key);
-            return this.AddFile(fileName, directoryPathInArchive);
-        }
-
-
-
-
-
-        /// <summary>
-        ///   Add or update a directory in a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   If the specified directory does not exist in the archive, then this method
-        ///   is equivalent to calling <c>AddDirectory()</c>.  If the specified
-        ///   directory already exists in the archive, then this method updates any
-        ///   existing entries, and adds any new entries. Any entries that are in the
-        ///   zip archive but not in the specified directory, are left alone.  In other
-        ///   words, the contents of the zip file will be a union of the previous
-        ///   contents and the new files.
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string)"/>
-        ///
-        /// <param name="directoryName">
-        ///   The path to the directory to be added to the zip archive, or updated in
-        ///   the zip archive.
-        /// </param>
-        ///
-        /// <returns>
-        /// The <c>ZipEntry</c> corresponding to the Directory that was added or updated.
-        /// </returns>
-        public ZipEntry UpdateDirectory(string directoryName)
-        {
-            return UpdateDirectory(directoryName, null);
-        }
-
-
-        /// <summary>
-        ///   Add or update a directory in the zip archive at the specified root
-        ///   directory in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   If the specified directory does not exist in the archive, then this method
-        ///   is equivalent to calling <c>AddDirectory()</c>.  If the specified
-        ///   directory already exists in the archive, then this method updates any
-        ///   existing entries, and adds any new entries. Any entries that are in the
-        ///   zip archive but not in the specified directory, are left alone.  In other
-        ///   words, the contents of the zip file will be a union of the previous
-        ///   contents and the new files.
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string,string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string,string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string,string)"/>
-        ///
-        /// <param name="directoryName">
-        ///   The path to the directory to be added to the zip archive, or updated
-        ///   in the zip archive.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the
-        ///   <c>directoryName</c>.  This path may, or may not, correspond to a real
-        ///   directory in the current filesystem.  If the files within the zip are
-        ///   later extracted, this is the path used for the extracted file.  Passing
-        ///   <c>null</c> (<c>Nothing</c> in VB) will use the path on the
-        ///   <c>directoryName</c>, if any.  Passing the empty string ("") will insert
-        ///   the item at the root path within the archive.
-        /// </param>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> corresponding to the Directory that was added or updated.
-        /// </returns>
-        public ZipEntry UpdateDirectory(string directoryName, String directoryPathInArchive)
-        {
-            return this.AddOrUpdateDirectoryImpl(directoryName, directoryPathInArchive, AddOrUpdateAction.AddOrUpdate);
-        }
-
-
-
-
-
-        /// <summary>
-        ///   Add or update a file or directory in the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is useful when the application is not sure or does not care if the
-        ///   item to be added is a file or directory, and does not know or does not
-        ///   care if the item already exists in the <c>ZipFile</c>. Calling this method
-        ///   is equivalent to calling <c>RemoveEntry()</c> if an entry by the same name
-        ///   already exists, followed calling by <c>AddItem()</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string)"/>
-        ///
-        /// <param name="itemName">
-        ///  the path to the file or directory to be added or updated.
-        /// </param>
-        public void UpdateItem(string itemName)
-        {
-            UpdateItem(itemName, null);
-        }
-
-
-        /// <summary>
-        ///   Add or update a file or directory.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method is useful when the application is not sure or does not care if
-        ///   the item to be added is a file or directory, and does not know or does not
-        ///   care if the item already exists in the <c>ZipFile</c>. Calling this method
-        ///   is equivalent to calling <c>RemoveEntry()</c>, if an entry by that name
-        ///   exists, and then calling <c>AddItem()</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the method allows the caller to explicitly specify the
-        ///   directory path to be used for the item being added to the archive.  The
-        ///   entry or entries that are added or updated will use the specified
-        ///   <c>DirectoryPathInArchive</c>. Extracting the entry from the archive will
-        ///   result in a file stored in that directory path.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string, string)"/>
-        ///
-        /// <param name="itemName">
-        ///   The path for the File or Directory to be added or updated.
-        /// </param>
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the
-        ///   <c>itemName</c>.  This path may, or may not, correspond to a real
-        ///   directory in the current filesystem.  If the files within the zip are
-        ///   later extracted, this is the path used for the extracted file.  Passing
-        ///   <c>null</c> (<c>Nothing</c> in VB) will use the path on the
-        ///   <c>itemName</c>, if any.  Passing the empty string ("") will insert the
-        ///   item at the root path within the archive.
-        /// </param>
-        public void UpdateItem(string itemName, string directoryPathInArchive)
-        {
-            if (File.Exists(itemName))
-                UpdateFile(itemName, directoryPathInArchive);
-
-            else if (Directory.Exists(itemName))
-                UpdateDirectory(itemName, directoryPathInArchive);
-
-            else
-                throw new FileNotFoundException(String.Format("That file or directory ({0}) does not exist!", itemName));
-        }
-
-
-
-
-        /// <summary>
-        ///   Adds a named entry into the zip archive, taking content for the entry
-        ///   from a string.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Calling this method creates an entry using the given fileName and
-        ///   directory path within the archive.  There is no need for a file by the
-        ///   given name to exist in the filesystem; the name is used within the zip
-        ///   archive only. The content for the entry is encoded using the default text
-        ///   encoding for the machine, or on Silverlight, using UTF-8.
-        /// </remarks>
-        ///
-        /// <param name="content">
-        ///   The content of the file, should it be extracted from the zip.
-        /// </param>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use for the entry within the archive.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        /// <example>
-        ///
-        /// This example shows how to add an entry to the zipfile, using a string as
-        /// content for that entry.
-        ///
-        /// <code lang="C#">
-        /// string Content = "This string will be the content of the Readme.txt file in the zip archive.";
-        /// using (ZipFile zip1 = new ZipFile())
-        /// {
-        ///   zip1.AddFile("MyDocuments\\Resume.doc", "files");
-        ///   zip1.AddEntry("Readme.txt", Content);
-        ///   zip1.Comment = "This zip file was created at " + System.DateTime.Now.ToString("G");
-        ///   zip1.Save("Content.zip");
-        /// }
-        ///
-        /// </code>
-        /// <code lang="VB">
-        /// Public Sub Run()
-        ///   Dim Content As String = "This string will be the content of the Readme.txt file in the zip archive."
-        ///   Using zip1 As ZipFile = New ZipFile
-        ///     zip1.AddEntry("Readme.txt", Content)
-        ///     zip1.AddFile("MyDocuments\Resume.doc", "files")
-        ///     zip1.Comment = ("This zip file was created at " &amp; DateTime.Now.ToString("G"))
-        ///     zip1.Save("Content.zip")
-        ///   End Using
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipEntry AddEntry(string entryName, string content)
-        {
-#if SILVERLIGHT
-            return AddEntry(entryName, content, System.Text.Encoding.UTF8);
-#else
-            return AddEntry(entryName, content, System.Text.Encoding.Default);
-#endif
-        }
-
-
-
-        /// <summary>
-        ///   Adds a named entry into the zip archive, taking content for the entry
-        ///   from a string, and using the specified text encoding.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Calling this method creates an entry using the given fileName and
-        ///   directory path within the archive.  There is no need for a file by the
-        ///   given name to exist in the filesystem; the name is used within the zip
-        ///   archive only.
-        /// </para>
-        ///
-        /// <para>
-        ///   The content for the entry, a string value, is encoded using the given
-        ///   text encoding. A BOM (byte-order-mark) is emitted into the file, if the
-        ///   Encoding parameter is set for that.
-        /// </para>
-        ///
-        /// <para>
-        ///   Most Encoding classes support a constructor that accepts a boolean,
-        ///   indicating whether to emit a BOM or not. For example see <see
-        ///   cref="System.Text.UTF8Encoding(bool)"/>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="content">
-        ///   The content of the file, should it be extracted from the zip.
-        /// </param>
-        ///
-        /// <param name="encoding">
-        ///   The text encoding to use when encoding the string. Be aware: This is
-        ///   distinct from the text encoding used to encode the fileName, as specified
-        ///   in <see cref="ProvisionalAlternateEncoding" />.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        public ZipEntry AddEntry(string entryName, string content, System.Text.Encoding encoding)
-        {
-            // cannot employ a using clause here.  We need the stream to
-            // persist after exit from this method.
-            var ms = new MemoryStream();
-
-            // cannot use a using clause here; StreamWriter takes
-            // ownership of the stream and Disposes it before we are ready.
-            var sw = new StreamWriter(ms, encoding);
-            sw.Write(content);
-            sw.Flush();
-
-            // reset to allow reading later
-            ms.Seek(0, SeekOrigin.Begin);
-
-            return AddEntry(entryName, ms);
-
-            // must not dispose the MemoryStream - it will be used later.
-        }
-
-
-        /// <summary>
-        ///   Create an entry in the <c>ZipFile</c> using the given <c>Stream</c>
-        ///   as input.  The entry will have the given filename.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The application should provide an open, readable stream; in this case it
-        ///   will be read during the call to <see cref="ZipFile.Save()"/> or one of
-        ///   its overloads.
-        /// </para>
-        ///
-        /// <para>
-        ///   The passed stream will be read from its current position. If
-        ///   necessary, callers should set the position in the stream before
-        ///   calling AddEntry(). This might be appropriate when using this method
-        ///   with a MemoryStream, for example.
-        /// </para>
-        ///
-        /// <para>
-        ///   In cases where a large number of streams will be added to the
-        ///   <c>ZipFile</c>, the application may wish to avoid maintaining all of the
-        ///   streams open simultaneously.  To handle this situation, the application
-        ///   should use the <see cref="AddEntry(string, OpenDelegate, CloseDelegate)"/>
-        ///   overload.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example adds a single entry to a <c>ZipFile</c> via a <c>Stream</c>.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// String zipToCreate = "Content.zip";
-        /// String fileNameInArchive = "Content-From-Stream.bin";
-        /// using (System.IO.Stream streamToRead = MyStreamOpener())
-        /// {
-        ///   using (ZipFile zip = new ZipFile())
-        ///   {
-        ///     ZipEntry entry= zip.AddEntry(fileNameInArchive, streamToRead);
-        ///     zip.AddFile("Readme.txt");
-        ///     zip.Save(zipToCreate);  // the stream is read implicitly here
-        ///   }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim zipToCreate As String = "Content.zip"
-        /// Dim fileNameInArchive As String = "Content-From-Stream.bin"
-        /// Using streamToRead as System.IO.Stream = MyStreamOpener()
-        ///   Using zip As ZipFile = New ZipFile()
-        ///     Dim entry as ZipEntry = zip.AddEntry(fileNameInArchive, streamToRead)
-        ///     zip.AddFile("Readme.txt")
-        ///     zip.Save(zipToCreate)  '' the stream is read implicitly, here
-        ///   End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateEntry(string, System.IO.Stream)"/>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, which is shown in the zip file for the added
-        ///   entry.
-        /// </param>
-        /// <param name="stream">
-        ///   The input stream from which to grab content for the file
-        /// </param>
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddEntry(string entryName, Stream stream)
-        {
-            ZipEntry ze = ZipEntry.CreateForStream(entryName, stream);
-            ze.SetEntryTimes(DateTime.Now,DateTime.Now,DateTime.Now);
-            if (Verbose) StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
-            return _InternalAddEntry(ze);
-        }
-
-
-
-        /// <summary>
-        ///   Add a ZipEntry for which content is written directly by the application.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   When the application needs to write the zip entry data, use this
-        ///   method to add the ZipEntry. For example, in the case that the
-        ///   application wishes to write the XML representation of a DataSet into
-        ///   a ZipEntry, the application can use this method to do so.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// <para>
-        ///   About progress events: When using the WriteDelegate, DotNetZip does
-        ///   not issue any SaveProgress events with <c>EventType</c> = <see
-        ///   cref="ZipProgressEventType.Saving_EntryBytesRead">
-        ///   Saving_EntryBytesRead</see>. (This is because it is the
-        ///   application's code that runs in WriteDelegate - there's no way for
-        ///   DotNetZip to know when to issue a EntryBytesRead event.)
-        ///   Applications that want to update a progress bar or similar status
-        ///   indicator should do so from within the WriteDelegate
-        ///   itself. DotNetZip will issue the other SaveProgress events,
-        ///   including <see cref="ZipProgressEventType.Saving_Started">
-        ///   Saving_Started</see>,
-        ///   <see cref="ZipProgressEventType.Saving_BeforeWriteEntry">
-        ///   Saving_BeforeWriteEntry</see>, and <see
-        ///   cref="ZipProgressEventType.Saving_AfterWriteEntry">
-        ///   Saving_AfterWriteEntry</see>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Note: When you use PKZip encryption, it's normally necessary to
-        ///   compute the CRC of the content to be encrypted, before compressing or
-        ///   encrypting it. Therefore, when using PKZip encryption with a
-        ///   WriteDelegate, the WriteDelegate CAN BE called twice: once to compute
-        ///   the CRC, and the second time to potentially compress and
-        ///   encrypt. Surprising, but true. This is because PKWARE specified that
-        ///   the encryption initialization data depends on the CRC.
-        ///   If this happens, for each call of the delegate, your
-        ///   application must stream the same entry data in its entirety. If your
-        ///   application writes different data during the second call, it will
-        ///   result in a corrupt zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   The double-read behavior happens with all types of entries, not only
-        ///   those that use WriteDelegate. It happens if you add an entry from a
-        ///   filesystem file, or using a string, or a stream, or an opener/closer
-        ///   pair. But in those cases, DotNetZip takes care of reading twice; in
-        ///   the case of the WriteDelegate, the application code gets invoked
-        ///   twice. Be aware.
-        /// </para>
-        ///
-        /// <para>
-        ///   As you can imagine, this can cause performance problems for large
-        ///   streams, and it can lead to correctness problems when you use a
-        ///   <c>WriteDelegate</c>. This is a pretty big pitfall.  There are two
-        ///   ways to avoid it.  First, and most preferred: don't use PKZIP
-        ///   encryption.  If you use the WinZip AES encryption, this problem
-        ///   doesn't occur, because the encryption protocol doesn't require the CRC
-        ///   up front. Second: if you do choose to use PKZIP encryption, write out
-        ///   to a non-seekable stream (like standard output, or the
-        ///   Response.OutputStream in an ASP.NET application).  In this case,
-        ///   DotNetZip will use an alternative encryption protocol that does not
-        ///   rely on the CRC of the content.  This also implies setting bit 3 in
-        ///   the zip entry, which still presents problems for some zip tools.
-        /// </para>
-        ///
-        /// <para>
-        ///   In the future I may modify DotNetZip to *always* use bit 3 when PKZIP
-        ///   encryption is in use.  This seems like a win overall, but there will
-        ///   be some work involved.  If you feel strongly about it, visit the
-        ///   DotNetZip forums and vote up <see
-        ///   href="http://dotnetzip.codeplex.com/workitem/13686">the Workitem
-        ///   tracking this issue</see>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="entryName">the name of the entry to add</param>
-        /// <param name="writer">the delegate which will write the entry content</param>
-        /// <returns>the ZipEntry added</returns>
-        ///
-        /// <example>
-        ///
-        ///   This example shows an application filling a DataSet, then saving the
-        ///   contents of that DataSet as XML, into a ZipEntry in a ZipFile, using an
-        ///   anonymous delegate in C#. The DataSet XML is never saved to a disk file.
-        ///
-        /// <code lang="C#">
-        /// var c1= new System.Data.SqlClient.SqlConnection(connstring1);
-        /// var da = new System.Data.SqlClient.SqlDataAdapter()
-        ///     {
-        ///         SelectCommand=  new System.Data.SqlClient.SqlCommand(strSelect, c1)
-        ///     };
-        ///
-        /// DataSet ds1 = new DataSet();
-        /// da.Fill(ds1, "Invoices");
-        ///
-        /// using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
-        /// {
-        ///     zip.AddEntry(zipEntryName, (name,stream) => ds1.WriteXml(stream) );
-        ///     zip.Save(zipFileName);
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        ///
-        /// This example uses an anonymous method in C# as the WriteDelegate to provide
-        /// the data for the ZipEntry. The example is a bit contrived - the
-        /// <c>AddFile()</c> method is a simpler way to insert the contents of a file
-        /// into an entry in a zip file. On the other hand, if there is some sort of
-        /// processing or transformation of the file contents required before writing,
-        /// the application could use the <c>WriteDelegate</c> to do it, in this way.
-        ///
-        /// <code lang="C#">
-        /// using (var input = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ))
-        /// {
-        ///     using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
-        ///     {
-        ///         zip.AddEntry(zipEntryName, (name,output) =>
-        ///             {
-        ///                 byte[] buffer = new byte[BufferSize];
-        ///                 int n;
-        ///                 while ((n = input.Read(buffer, 0, buffer.Length)) != 0)
-        ///                 {
-        ///                     // could transform the data here...
-        ///                     output.Write(buffer, 0, n);
-        ///                     // could update a progress bar here
-        ///                 }
-        ///             });
-        ///
-        ///         zip.Save(zipFileName);
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        ///
-        /// This example uses a named delegate in VB to write data for the given
-        /// ZipEntry (VB9 does not have anonymous delegates). The example here is a bit
-        /// contrived - a simpler way to add the contents of a file to a ZipEntry is to
-        /// simply use the appropriate <c>AddFile()</c> method.  The key scenario for
-        /// which the <c>WriteDelegate</c> makes sense is saving a DataSet, in XML
-        /// format, to the zip file. The DataSet can write XML to a stream, and the
-        /// WriteDelegate is the perfect place to write into the zip file.  There may be
-        /// other data structures that can write to a stream, but cannot be read as a
-        /// stream.  The <c>WriteDelegate</c> would be appropriate for those cases as
-        /// well.
-        ///
-        /// <code lang="VB">
-        /// Private Sub WriteEntry (ByVal name As String, ByVal output As Stream)
-        ///     Using input As FileStream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
-        ///         Dim n As Integer = -1
-        ///         Dim buffer As Byte() = New Byte(BufferSize){}
-        ///         Do While n &lt;&gt; 0
-        ///             n = input.Read(buffer, 0, buffer.Length)
-        ///             output.Write(buffer, 0, n)
-        ///         Loop
-        ///     End Using
-        /// End Sub
-        ///
-        /// Public Sub Run()
-        ///     Using zip = New ZipFile
-        ///         zip.AddEntry(zipEntryName, New WriteDelegate(AddressOf WriteEntry))
-        ///         zip.Save(zipFileName)
-        ///     End Using
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipEntry AddEntry(string entryName, WriteDelegate writer)
-        {
-            ZipEntry ze = ZipEntry.CreateForWriter(entryName, writer);
-            if (Verbose) StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
-            return _InternalAddEntry(ze);
-        }
-
-
-        /// <summary>
-        ///   Add an entry, for which the application will provide a stream
-        ///   containing the entry data, on a just-in-time basis.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   In cases where the application wishes to open the stream that
-        ///   holds the content for the ZipEntry, on a just-in-time basis, the
-        ///   application can use this method.  The application provides an
-        ///   opener delegate that will be called by the DotNetZip library to
-        ///   obtain a readable stream that can be read to get the bytes for
-        ///   the given entry.  Typically, this delegate opens a stream.
-        ///   Optionally, the application can provide a closer delegate as
-        ///   well, which will be called by DotNetZip when all bytes have been
-        ///   read from the entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   These delegates are called from within the scope of the call to
-        ///   ZipFile.Save().
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example uses anonymous methods in C# to open and close the
-        ///   source stream for the content for a zip entry.
-        ///
-        /// <code lang="C#">
-        /// using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
-        /// {
-        ///     zip.AddEntry(zipEntryName,
-        ///                  (name) =>  File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ),
-        ///                  (name, stream) =>  stream.Close()
-        ///                  );
-        ///
-        ///     zip.Save(zipFileName);
-        /// }
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <example>
-        ///
-        ///   This example uses delegates in VB.NET to open and close the
-        ///   the source stream for the content for a zip entry.  VB 9.0 lacks
-        ///   support for "Sub" lambda expressions, and so the CloseDelegate must
-        ///   be an actual, named Sub.
-        ///
-        /// <code lang="VB">
-        ///
-        /// Function MyStreamOpener(ByVal entryName As String) As Stream
-        ///     '' This simply opens a file.  You probably want to do somethinig
-        ///     '' more involved here: open a stream to read from a database,
-        ///     '' open a stream on an HTTP connection, and so on.
-        ///     Return File.OpenRead(entryName)
-        /// End Function
-        ///
-        /// Sub MyStreamCloser(entryName As String, stream As Stream)
-        ///     stream.Close()
-        /// End Sub
-        ///
-        /// Public Sub Run()
-        ///     Dim dirToZip As String = "fodder"
-        ///     Dim zipFileToCreate As String = "Archive.zip"
-        ///     Dim opener As OpenDelegate = AddressOf MyStreamOpener
-        ///     Dim closer As CloseDelegate = AddressOf MyStreamCloser
-        ///     Dim numFilestoAdd As Int32 = 4
-        ///     Using zip As ZipFile = New ZipFile
-        ///         Dim i As Integer
-        ///         For i = 0 To numFilesToAdd - 1
-        ///             zip.AddEntry(String.Format("content-{0:000}.txt"), opener, closer)
-        ///         Next i
-        ///         zip.Save(zipFileToCreate)
-        ///     End Using
-        /// End Sub
-        ///
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="entryName">the name of the entry to add</param>
-        /// <param name="opener">
-        ///  the delegate that will be invoked by ZipFile.Save() to get the
-        ///  readable stream for the given entry. ZipFile.Save() will call
-        ///  read on this stream to obtain the data for the entry. This data
-        ///  will then be compressed and written to the newly created zip
-        ///  file.
-        /// </param>
-        /// <param name="closer">
-        ///  the delegate that will be invoked to close the stream. This may
-        ///  be null (Nothing in VB), in which case no call is makde to close
-        ///  the stream.
-        /// </param>
-        /// <returns>the ZipEntry added</returns>
-        ///
-        public ZipEntry AddEntry(string entryName, OpenDelegate opener, CloseDelegate closer)
-        {
-            ZipEntry ze = ZipEntry.CreateForJitStreamProvider(entryName, opener, closer);
-            ze.SetEntryTimes(DateTime.Now,DateTime.Now,DateTime.Now);
-            if (Verbose) StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
-            return _InternalAddEntry(ze);
-        }
-
-
-
-        private ZipEntry _InternalAddEntry(ZipEntry ze)
-        {
-            // stamp all the props onto the entry
-            ze._container = new ZipContainer(this);
-            ze.CompressionMethod = this.CompressionMethod;
-            ze.CompressionLevel = this.CompressionLevel;
-            ze.ExtractExistingFile = this.ExtractExistingFile;
-            ze.ZipErrorAction = this.ZipErrorAction;
-            ze.SetCompression = this.SetCompression;
-            ze.AlternateEncoding = this.AlternateEncoding;
-            ze.AlternateEncodingUsage = this.AlternateEncodingUsage;
-            ze.Password = this._Password;
-            ze.Encryption = this.Encryption;
-            ze.EmitTimesInWindowsFormatWhenSaving = this._emitNtfsTimes;
-            ze.EmitTimesInUnixFormatWhenSaving = this._emitUnixTimes;
-            //string key = DictionaryKeyForEntry(ze);
-            InternalAddEntry(ze.FileName,ze);
-            AfterAddEntry(ze);
-            return ze;
-        }
-
-
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given
-        ///   string as content for the <c>ZipEntry</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Calling this method is equivalent to removing the <c>ZipEntry</c> for
-        ///   the given file name and directory path, if it exists, and then calling
-        ///   <see cref="AddEntry(String,String)" />.  See the documentation for
-        ///   that method for further explanation. The string content is encoded
-        ///   using the default encoding for the machine, or on Silverlight, using
-        ///   UTF-8. This encoding is distinct from the encoding used for the
-        ///   filename itself.  See <see cref="AlternateEncoding"/>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="content">
-        ///   The content of the file, should it be extracted from the zip.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        public ZipEntry UpdateEntry(string entryName, string content)
-        {
-#if SILVERLIGHT
-            return UpdateEntry(entryName, content, System.Text.Encoding.UTF8);
-#else
-            return UpdateEntry(entryName, content, System.Text.Encoding.Default);
-#endif
-        }
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given string as
-        ///   content for the <c>ZipEntry</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Calling this method is equivalent to removing the <c>ZipEntry</c> for the
-        ///   given file name and directory path, if it exists, and then calling <see
-        ///   cref="AddEntry(String,String, System.Text.Encoding)" />.  See the
-        ///   documentation for that method for further explanation.
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="content">
-        ///   The content of the file, should it be extracted from the zip.
-        /// </param>
-        ///
-        /// <param name="encoding">
-        ///   The text encoding to use when encoding the string. Be aware: This is
-        ///   distinct from the text encoding used to encode the filename. See <see
-        ///   cref="AlternateEncoding" />.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        public ZipEntry UpdateEntry(string entryName, string content, System.Text.Encoding encoding)
-        {
-            RemoveEntryForUpdate(entryName);
-            return AddEntry(entryName, content, encoding);
-        }
-
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given delegate
-        ///   as the source for content for the <c>ZipEntry</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Calling this method is equivalent to removing the <c>ZipEntry</c> for the
-        ///   given file name and directory path, if it exists, and then calling <see
-        ///   cref="AddEntry(String,WriteDelegate)" />.  See the
-        ///   documentation for that method for further explanation.
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="writer">the delegate which will write the entry content.</param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        public ZipEntry UpdateEntry(string entryName, WriteDelegate writer)
-        {
-            RemoveEntryForUpdate(entryName);
-            return AddEntry(entryName, writer);
-        }
-
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given delegates
-        ///   to open and close the stream that provides the content for the <c>ZipEntry</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Calling this method is equivalent to removing the <c>ZipEntry</c> for the
-        ///   given file name and directory path, if it exists, and then calling <see
-        ///   cref="AddEntry(String,OpenDelegate, CloseDelegate)" />.  See the
-        ///   documentation for that method for further explanation.
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="opener">
-        ///  the delegate that will be invoked to open the stream
-        /// </param>
-        /// <param name="closer">
-        ///  the delegate that will be invoked to close the stream
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added or updated.</returns>
-        ///
-        public ZipEntry UpdateEntry(string entryName, OpenDelegate opener, CloseDelegate closer)
-        {
-            RemoveEntryForUpdate(entryName);
-            return AddEntry(entryName, opener, closer);
-        }
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given stream as
-        ///   input, and the given filename and given directory Path.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Calling the method is equivalent to calling <c>RemoveEntry()</c> if an
-        ///   entry by the same name already exists, and then calling <c>AddEntry()</c>
-        ///   with the given <c>fileName</c> and stream.
-        /// </para>
-        ///
-        /// <para>
-        ///   The stream must be open and readable during the call to
-        ///   <c>ZipFile.Save</c>.  You can dispense the stream on a just-in-time basis
-        ///   using the <see cref="ZipEntry.InputStream"/> property. Check the
-        ///   documentation of that property for more information.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to the
-        ///   <c>ZipEntry</c> added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(string, System.IO.Stream)"/>
-        /// <seealso cref="ZipEntry.InputStream"/>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="stream">The input stream from which to read file data.</param>
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry UpdateEntry(string entryName, Stream stream)
-        {
-            RemoveEntryForUpdate(entryName);
-            return AddEntry(entryName, stream);
-        }
-
-
-        private void RemoveEntryForUpdate(string entryName)
-        {
-            if (String.IsNullOrEmpty(entryName))
-                throw new ArgumentNullException("entryName");
-
-            string directoryPathInArchive = null;
-            if (entryName.IndexOf('\\') != -1)
-            {
-                directoryPathInArchive = Path.GetDirectoryName(entryName);
-                entryName = Path.GetFileName(entryName);
-            }
-            var key = ZipEntry.NameInArchive(entryName, directoryPathInArchive);
-            if (this[key] != null)
-                this.RemoveEntry(key);
-        }
-
-
-
-
-        /// <summary>
-        ///   Add an entry into the zip archive using the given filename and
-        ///   directory path within the archive, and the given content for the
-        ///   file. No file is created in the filesystem.
-        /// </summary>
-        ///
-        /// <param name="byteContent">The data to use for the entry.</param>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddEntry(string entryName, byte[] byteContent)
-        {
-            if (byteContent == null) throw new ArgumentException("bad argument", "byteContent");
-            var ms = new MemoryStream(byteContent);
-            return AddEntry(entryName, ms);
-        }
-
-
-        /// <summary>
-        ///   Updates the given entry in the <c>ZipFile</c>, using the given byte
-        ///   array as content for the entry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Calling this method is equivalent to removing the <c>ZipEntry</c>
-        ///   for the given filename and directory path, if it exists, and then
-        ///   calling <see cref="AddEntry(String,byte[])" />.  See the
-        ///   documentation for that method for further explanation.
-        /// </remarks>
-        ///
-        /// <param name="entryName">
-        ///   The name, including any path, to use within the archive for the entry.
-        /// </param>
-        ///
-        /// <param name="byteContent">The content to use for the <c>ZipEntry</c>.</param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        ///
-        public ZipEntry UpdateEntry(string entryName, byte[] byteContent)
-        {
-            RemoveEntryForUpdate(entryName);
-            return AddEntry(entryName, byteContent);
-        }
-
-
-//         private string DictionaryKeyForEntry(ZipEntry ze1)
-//         {
-//             var filename = SharedUtilities.NormalizePathForUseInZipFile(ze1.FileName);
-//             return filename;
-//         }
-
-
-        /// <summary>
-        ///   Adds the contents of a filesystem directory to a Zip file archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The name of the directory may be a relative path or a fully-qualified
-        ///   path. Any files within the named directory are added to the archive.  Any
-        ///   subdirectories within the named directory are also added to the archive,
-        ///   recursively.
-        /// </para>
-        ///
-        /// <para>
-        ///   Top-level entries in the named directory will appear as top-level entries
-        ///   in the zip archive.  Entries in subdirectories in the named directory will
-        ///   result in entries in subdirectories in the zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you want the entries to appear in a containing directory in the zip
-        ///   archive itself, then you should call the AddDirectory() overload that
-        ///   allows you to explicitly specify a directory path for use in the archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string, string)"/>
-        ///
-        /// <overloads>This method has 2 overloads.</overloads>
-        ///
-        /// <param name="directoryName">The name of the directory to add.</param>
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddDirectory(string directoryName)
-        {
-            return AddDirectory(directoryName, null);
-        }
-
-
-        /// <summary>
-        ///   Adds the contents of a filesystem directory to a Zip file archive,
-        ///   overriding the path to be used for entries in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The name of the directory may be a relative path or a fully-qualified
-        ///   path. The add operation is recursive, so that any files or subdirectories
-        ///   within the name directory are also added to the archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   Top-level entries in the named directory will appear as top-level entries
-        ///   in the zip archive.  Entries in subdirectories in the named directory will
-        ///   result in entries in subdirectories in the zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
-        ///   cref="Password"/>, <see cref="SetCompression"/>, <see
-        ///   cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
-        ///   <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
-        ///   respective values at the time of this call will be applied to each
-        ///   ZipEntry added.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   In this code, calling the ZipUp() method with a value of "c:\reports" for
-        ///   the directory parameter will result in a zip file structure in which all
-        ///   entries are contained in a toplevel "reports" directory.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// public void ZipUp(string targetZip, string directory)
-        /// {
-        ///   using (var zip = new ZipFile())
-        ///   {
-        ///     zip.AddDirectory(directory, System.IO.Path.GetFileName(directory));
-        ///     zip.Save(targetZip);
-        ///   }
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddItem(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddFile(string, string)"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string, string)"/>
-        ///
-        /// <param name="directoryName">The name of the directory to add.</param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to override any path in the
-        ///   DirectoryName.  This path may, or may not, correspond to a real directory
-        ///   in the current filesystem.  If the zip is later extracted, this is the
-        ///   path used for the extracted file or directory.  Passing <c>null</c>
-        ///   (<c>Nothing</c> in VB) or the empty string ("") will insert the items at
-        ///   the root path within the archive.
-        /// </param>
-        ///
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddDirectory(string directoryName, string directoryPathInArchive)
-        {
-            return AddOrUpdateDirectoryImpl(directoryName, directoryPathInArchive, AddOrUpdateAction.AddOnly);
-        }
-
-
-        /// <summary>
-        ///   Creates a directory in the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Use this when you want to create a directory in the archive but there is
-        ///   no corresponding filesystem representation for that directory.
-        /// </para>
-        ///
-        /// <para>
-        ///   You will probably not need to do this in your code. One of the only times
-        ///   you will want to do this is if you want an empty directory in the zip
-        ///   archive.  The reason: if you add a file to a zip archive that is stored
-        ///   within a multi-level directory, all of the directory tree is implicitly
-        ///   created in the zip archive.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="directoryNameInArchive">
-        ///   The name of the directory to create in the archive.
-        /// </param>
-        /// <returns>The <c>ZipEntry</c> added.</returns>
-        public ZipEntry AddDirectoryByName(string directoryNameInArchive)
-        {
-            // workitem 9073
-            ZipEntry dir = ZipEntry.CreateFromNothing(directoryNameInArchive);
-            dir._container = new ZipContainer(this);
-            dir.MarkAsDirectory();
-            dir.AlternateEncoding = this.AlternateEncoding;  // workitem 8984
-            dir.AlternateEncodingUsage = this.AlternateEncodingUsage;
-            dir.SetEntryTimes(DateTime.Now,DateTime.Now,DateTime.Now);
-            dir.EmitTimesInWindowsFormatWhenSaving = _emitNtfsTimes;
-            dir.EmitTimesInUnixFormatWhenSaving = _emitUnixTimes;
-            dir._Source = ZipEntrySource.Stream;
-            //string key = DictionaryKeyForEntry(dir);
-            InternalAddEntry(dir.FileName,dir);
-            AfterAddEntry(dir);
-            return dir;
-        }
-
-
-
-        private ZipEntry AddOrUpdateDirectoryImpl(string directoryName,
-                                                  string rootDirectoryPathInArchive,
-                                                  AddOrUpdateAction action)
-        {
-            if (rootDirectoryPathInArchive == null)
-            {
-                rootDirectoryPathInArchive = "";
-            }
-
-            return AddOrUpdateDirectoryImpl(directoryName, rootDirectoryPathInArchive, action, true, 0);
-        }
-
-
-        internal void InternalAddEntry(String name, ZipEntry entry)
-        {
-            _entries.Add(name, entry);
-            _zipEntriesAsList = null;
-            _contentsChanged = true;
-        }
-
-
-
-        private ZipEntry AddOrUpdateDirectoryImpl(string directoryName,
-                                                  string rootDirectoryPathInArchive,
-                                                  AddOrUpdateAction action,
-                                                  bool recurse,
-                                                  int level)
-        {
-            if (Verbose)
-                StatusMessageTextWriter.WriteLine("{0} {1}...",
-                                                  (action == AddOrUpdateAction.AddOnly) ? "adding" : "Adding or updating",
-                                                  directoryName);
-
-            if (level == 0)
-            {
-                _addOperationCanceled = false;
-                OnAddStarted();
-            }
-
-            // workitem 13371
-            if (_addOperationCanceled)
-                return null;
-
-            string dirForEntries = rootDirectoryPathInArchive;
-            ZipEntry baseDir = null;
-
-            if (level > 0)
-            {
-                int f = directoryName.Length;
-                for (int i = level; i > 0; i--)
-                    f = directoryName.LastIndexOfAny("/\\".ToCharArray(), f - 1, f - 1);
-
-                dirForEntries = directoryName.Substring(f + 1);
-                dirForEntries = Path.Combine(rootDirectoryPathInArchive, dirForEntries);
-            }
-
-            // if not top level, or if the root is non-empty, then explicitly add the directory
-            if (level > 0 || rootDirectoryPathInArchive != "")
-            {
-                baseDir = ZipEntry.CreateFromFile(directoryName, dirForEntries);
-                baseDir._container = new ZipContainer(this);
-                baseDir.AlternateEncoding = this.AlternateEncoding;  // workitem 6410
-                baseDir.AlternateEncodingUsage = this.AlternateEncodingUsage;
-                baseDir.MarkAsDirectory();
-                baseDir.EmitTimesInWindowsFormatWhenSaving = _emitNtfsTimes;
-                baseDir.EmitTimesInUnixFormatWhenSaving = _emitUnixTimes;
-
-                // add the directory only if it does not exist.
-                // It's not an error if it already exists.
-                if (!_entries.ContainsKey(baseDir.FileName))
-                {
-                    InternalAddEntry(baseDir.FileName,baseDir);
-                    AfterAddEntry(baseDir);
-                }
-                dirForEntries = baseDir.FileName;
-            }
-
-            if (!_addOperationCanceled)
-            {
-
-                String[] filenames = Directory.GetFiles(directoryName);
-
-                if (recurse)
-                {
-                    // add the files:
-                    foreach (String filename in filenames)
-                    {
-                        if (_addOperationCanceled) break;
-                        if (action == AddOrUpdateAction.AddOnly)
-                            AddFile(filename, dirForEntries);
-                        else
-                            UpdateFile(filename, dirForEntries);
-                    }
-
-                    if (!_addOperationCanceled)
-                    {
-                        // add the subdirectories:
-                        String[] dirnames = Directory.GetDirectories(directoryName);
-                        foreach (String dir in dirnames)
-                        {
-                            // workitem 8617: Optionally traverse reparse points
-#if SILVERLIGHT
-#elif NETCF
-                            FileAttributes fileAttrs = (FileAttributes) NetCfFile.GetAttributes(dir);
-#else
-                            FileAttributes fileAttrs = System.IO.File.GetAttributes(dir);
-#endif
-                            if (this.AddDirectoryWillTraverseReparsePoints
-#if !SILVERLIGHT
-                                || ((fileAttrs & FileAttributes.ReparsePoint) == 0)
-#endif
-                                )
-                                AddOrUpdateDirectoryImpl(dir, rootDirectoryPathInArchive, action, recurse, level + 1);
-
-                        }
-
-                    }
-                }
-            }
-
-            if (level == 0)
-                OnAddCompleted();
-
-            return baseDir;
-        }
-
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Check.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Check.cs
deleted file mode 100644
index 3870556..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Check.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-// ZipFile.Check.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-31 14:40:50>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for doing Checks on zip files.
-// These are not necessary to include in the Reduced or CF
-// version of the library.
-//
-// ------------------------------------------------------------------
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal partial class ZipFile
-    {
-        /// <summary>
-        ///   Checks a zip file to see if its directory is consistent.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   In cases of data error, the directory within a zip file can get out
-        ///   of synch with the entries in the zip file.  This method checks the
-        ///   given zip file and returns true if this has occurred.
-        /// </para>
-        ///
-        /// <para> This method may take a long time to run for large zip files.  </para>
-        ///
-        /// <para>
-        ///   This method is not supported in the Reduced or Compact Framework
-        ///   versions of DotNetZip.
-        /// </para>
-        ///
-        /// <para>
-        ///   Developers using COM can use the <see
-        ///   cref="ComHelper.CheckZip(String)">ComHelper.CheckZip(String)</see>
-        ///   method.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="zipFileName">The filename to of the zip file to check.</param>
-        ///
-        /// <returns>true if the named zip file checks OK. Otherwise, false. </returns>
-        ///
-        /// <seealso cref="FixZipDirectory(string)"/>
-        /// <seealso cref="CheckZip(string,bool,System.IO.TextWriter)"/>
-        public static bool CheckZip(string zipFileName)
-        {
-            return CheckZip(zipFileName, false, null);
-        }
-
-
-        /// <summary>
-        ///   Checks a zip file to see if its directory is consistent,
-        ///   and optionally fixes the directory if necessary.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   In cases of data error, the directory within a zip file can get out of
-        ///   synch with the entries in the zip file.  This method checks the given
-        ///   zip file, and returns true if this has occurred. It also optionally
-        ///   fixes the zipfile, saving the fixed copy in <em>Name</em>_Fixed.zip.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method may take a long time to run for large zip files.  It
-        ///   will take even longer if the file actually needs to be fixed, and if
-        ///   <c>fixIfNecessary</c> is true.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method is not supported in the Reduced or Compact
-        ///   Framework versions of DotNetZip.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="zipFileName">The filename to of the zip file to check.</param>
-        ///
-        /// <param name="fixIfNecessary">If true, the method will fix the zip file if
-        ///     necessary.</param>
-        ///
-        /// <param name="writer">
-        /// a TextWriter in which messages generated while checking will be written.
-        /// </param>
-        ///
-        /// <returns>true if the named zip is OK; false if the file needs to be fixed.</returns>
-        ///
-        /// <seealso cref="CheckZip(string)"/>
-        /// <seealso cref="FixZipDirectory(string)"/>
-        public static bool CheckZip(string zipFileName, bool fixIfNecessary,
-                                    TextWriter writer)
-
-        {
-            ZipFile zip1 = null, zip2 = null;
-            bool isOk = true;
-            try
-            {
-                zip1 = new ZipFile();
-                zip1.FullScan = true;
-                zip1.Initialize(zipFileName);
-
-                zip2 = ZipFile.Read(zipFileName);
-
-                foreach (var e1 in zip1)
-                {
-                    foreach (var e2 in zip2)
-                    {
-                        if (e1.FileName == e2.FileName)
-                        {
-                            if (e1._RelativeOffsetOfLocalHeader != e2._RelativeOffsetOfLocalHeader)
-                            {
-                                isOk = false;
-                                if (writer != null)
-                                writer.WriteLine("{0}: mismatch in RelativeOffsetOfLocalHeader  (0x{1:X16} != 0x{2:X16})",
-                                                        e1.FileName, e1._RelativeOffsetOfLocalHeader,
-                                                        e2._RelativeOffsetOfLocalHeader);
-                            }
-                            if (e1._CompressedSize != e2._CompressedSize)
-                            {
-                                isOk = false;
-                                if (writer != null)
-                                writer.WriteLine("{0}: mismatch in CompressedSize  (0x{1:X16} != 0x{2:X16})",
-                                                        e1.FileName, e1._CompressedSize,
-                                                        e2._CompressedSize);
-                            }
-                            if (e1._UncompressedSize != e2._UncompressedSize)
-                            {
-                                isOk = false;
-                                if (writer != null)
-                                writer.WriteLine("{0}: mismatch in UncompressedSize  (0x{1:X16} != 0x{2:X16})",
-                                                        e1.FileName, e1._UncompressedSize,
-                                                        e2._UncompressedSize);
-                            }
-                            if (e1.CompressionMethod != e2.CompressionMethod)
-                            {
-                                isOk = false;
-                                if (writer != null)
-                                writer.WriteLine("{0}: mismatch in CompressionMethod  (0x{1:X4} != 0x{2:X4})",
-                                                        e1.FileName, e1.CompressionMethod,
-                                                        e2.CompressionMethod);
-                            }
-                            if (e1.Crc != e2.Crc)
-                            {
-                                isOk = false;
-                                if (writer != null)
-                                writer.WriteLine("{0}: mismatch in Crc32  (0x{1:X4} != 0x{2:X4})",
-                                                        e1.FileName, e1.Crc,
-                                                        e2.Crc);
-                            }
-
-                            // found a match, so stop the inside loop
-                            break;
-                        }
-                    }
-                }
-
-                zip2.Dispose();
-                zip2 = null;
-
-                if (!isOk && fixIfNecessary)
-                {
-                    string newFileName = Path.GetFileNameWithoutExtension(zipFileName);
-                    newFileName = System.String.Format("{0}_fixed.zip", newFileName);
-                    zip1.Save(newFileName);
-                }
-            }
-            finally
-            {
-                if (zip1 != null) zip1.Dispose();
-                if (zip2 != null) zip2.Dispose();
-            }
-            return isOk;
-        }
-
-
-
-        /// <summary>
-        ///   Rewrite the directory within a zipfile.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   In cases of data error, the directory in a zip file can get out of
-        ///   synch with the entries in the zip file.  This method attempts to fix
-        ///   the zip file if this has occurred.
-        /// </para>
-        ///
-        /// <para> This can take a long time for large zip files. </para>
-        ///
-        /// <para> This won't work if the zip file uses a non-standard
-        /// code page - neither IBM437 nor UTF-8. </para>
-        ///
-        /// <para>
-        ///   This method is not supported in the Reduced or Compact Framework
-        ///   versions of DotNetZip.
-        /// </para>
-        ///
-        /// <para>
-        ///   Developers using COM can use the <see
-        ///   cref="ComHelper.FixZipDirectory(String)">ComHelper.FixZipDirectory(String)</see>
-        ///   method.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="zipFileName">The filename to of the zip file to fix.</param>
-        ///
-        /// <seealso cref="CheckZip(string)"/>
-        /// <seealso cref="CheckZip(string,bool,System.IO.TextWriter)"/>
-        public static void FixZipDirectory(string zipFileName)
-        {
-            using (var zip = new ZipFile())
-            {
-                zip.FullScan = true;
-                zip.Initialize(zipFileName);
-                zip.Save(zipFileName);
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Verify the password on a zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     Keep in mind that passwords in zipfiles are applied to
-        ///     zip entries, not to the entire zip file. So testing a
-        ///     zipfile for a particular password doesn't work in the
-        ///     general case. On the other hand, it's often the case
-        ///     that a single password will be used on all entries in a
-        ///     zip file. This method works for that case.
-        ///   </para>
-        ///   <para>
-        ///     There is no way to check a password without doing the
-        ///     decryption. So this code decrypts and extracts the given
-        ///     zipfile into <see cref="System.IO.Stream.Null"/>
-        ///   </para>
-        /// </remarks>
-        ///
-        /// <param name="zipFileName">The filename to of the zip file to fix.</param>
-        ///
-        /// <param name="password">The password to check.</param>
-        ///
-        /// <returns>a bool indicating whether the password matches.</returns>
-        public static bool CheckZipPassword(string zipFileName, string password)
-        {
-            // workitem 13664
-            bool success = false;
-            try
-            {
-                using (ZipFile zip1 = ZipFile.Read(zipFileName))
-                {
-                    foreach (var e in zip1)
-                    {
-                        if (!e.IsDirectory && e.UsesEncryption)
-                        {
-                            e.ExtractWithPassword(System.IO.Stream.Null, password);
-                        }
-                    }
-                }
-                success = true;
-            }
-            catch(Ionic.Zip.BadPasswordException) { }
-            return success;
-        }
-
-
-        /// <summary>
-        ///   Provides a human-readable string with information about the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     The information string contains 10 lines or so, about each ZipEntry,
-        ///     describing whether encryption is in use, the compressed and uncompressed
-        ///     length of the entry, the offset of the entry, and so on. As a result the
-        ///     information string can be very long for zip files that contain many
-        ///     entries.
-        ///   </para>
-        ///   <para>
-        ///     This information is mostly useful for diagnostic purposes.
-        ///   </para>
-        /// </remarks>
-        public string Info
-        {
-            get
-            {
-                var builder = new System.Text.StringBuilder();
-                builder.Append(string.Format("          ZipFile: {0}\n", this.Name));
-                if (!string.IsNullOrEmpty(this._Comment))
-                {
-                    builder.Append(string.Format("          Comment: {0}\n", this._Comment));
-                }
-                if (this._versionMadeBy != 0)
-                {
-                    builder.Append(string.Format("  version made by: 0x{0:X4}\n", this._versionMadeBy));
-                }
-                if (this._versionNeededToExtract != 0)
-                {
-                    builder.Append(string.Format("needed to extract: 0x{0:X4}\n", this._versionNeededToExtract));
-                }
-
-                builder.Append(string.Format("       uses ZIP64: {0}\n", this.InputUsesZip64));
-
-                builder.Append(string.Format("     disk with CD: {0}\n", this._diskNumberWithCd));
-                if (this._OffsetOfCentralDirectory == 0xFFFFFFFF)
-                    builder.Append(string.Format("      CD64 offset: 0x{0:X16}\n", this._OffsetOfCentralDirectory64));
-                else
-                    builder.Append(string.Format("        CD offset: 0x{0:X8}\n", this._OffsetOfCentralDirectory));
-                builder.Append("\n");
-                foreach (ZipEntry entry in this._entries.Values)
-                {
-                    builder.Append(entry.Info);
-                }
-                return builder.ToString();
-            }
-        }
-
-
-    }
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Events.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Events.cs
deleted file mode 100644
index 573e076..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Events.cs
+++ /dev/null
@@ -1,1219 +0,0 @@
-// ZipFile.Events.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2008, 2009, 2011 Dino Chiesa .
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-09 08:42:35>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for issuing events from the ZipFile class.
-//
-// ------------------------------------------------------------------
-//
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal partial class ZipFile
-    {
-        private string ArchiveNameForEvent
-        {
-            get
-            {
-                return (_name != null) ? _name : "(stream)";
-            }
-        }
-
-        #region Save
-
-        /// <summary>
-        ///   An event handler invoked when a Save() starts, before and after each
-        ///   entry has been written to the archive, when a Save() completes, and
-        ///   during other Save events.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Depending on the particular event, different properties on the <see
-        ///   cref="SaveProgressEventArgs"/> parameter are set.  The following
-        ///   table summarizes the available EventTypes and the conditions under
-        ///   which this event handler is invoked with a
-        ///   <c>SaveProgressEventArgs</c> with the given EventType.
-        /// </para>
-        ///
-        /// <list type="table">
-        /// <listheader>
-        /// <term>value of EntryType</term>
-        /// <description>Meaning and conditions</description>
-        /// </listheader>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_Started</term>
-        /// <description>Fired when ZipFile.Save() begins.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_BeforeSaveEntry</term>
-        /// <description>
-        ///   Fired within ZipFile.Save(), just before writing data for each
-        ///   particular entry.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_AfterSaveEntry</term>
-        /// <description>
-        ///   Fired within ZipFile.Save(), just after having finished writing data
-        ///   for each particular entry.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_Completed</term>
-        /// <description>Fired when ZipFile.Save() has completed.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_AfterSaveTempArchive</term>
-        /// <description>
-        ///   Fired after the temporary file has been created.  This happens only
-        ///   when saving to a disk file.  This event will not be invoked when
-        ///   saving to a stream.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_BeforeRenameTempArchive</term>
-        /// <description>
-        ///   Fired just before renaming the temporary file to the permanent
-        ///   location.  This happens only when saving to a disk file.  This event
-        ///   will not be invoked when saving to a stream.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_AfterRenameTempArchive</term>
-        /// <description>
-        ///   Fired just after renaming the temporary file to the permanent
-        ///   location.  This happens only when saving to a disk file.  This event
-        ///   will not be invoked when saving to a stream.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_AfterCompileSelfExtractor</term>
-        /// <description>
-        ///   Fired after a self-extracting archive has finished compiling.  This
-        ///   EventType is used only within SaveSelfExtractor().
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Saving_BytesRead</term>
-        /// <description>
-        ///   Set during the save of a particular entry, to update progress of the
-        ///   Save().  When this EventType is set, the BytesTransferred is the
-        ///   number of bytes that have been read from the source stream.  The
-        ///   TotalBytesToTransfer is the number of bytes in the uncompressed
-        ///   file.
-        /// </description>
-        /// </item>
-        ///
-        /// </list>
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///    This example uses an anonymous method to handle the
-        ///    SaveProgress event, by updating a progress bar.
-        ///
-        /// <code lang="C#">
-        /// progressBar1.Value = 0;
-        /// progressBar1.Max = listbox1.Items.Count;
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///    // listbox1 contains a list of filenames
-        ///    zip.AddFiles(listbox1.Items);
-        ///
-        ///    // do the progress bar:
-        ///    zip.SaveProgress += (sender, e) => {
-        ///       if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry) {
-        ///          progressBar1.PerformStep();
-        ///       }
-        ///    };
-        ///
-        ///    zip.Save(fs);
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        ///   This example uses a named method as the
-        ///   <c>SaveProgress</c> event handler, to update the user, in a
-        ///   console-based application.
-        ///
-        /// <code lang="C#">
-        /// static bool justHadByteUpdate= false;
-        /// public static void SaveProgress(object sender, SaveProgressEventArgs e)
-        /// {
-        ///     if (e.EventType == ZipProgressEventType.Saving_Started)
-        ///         Console.WriteLine("Saving: {0}", e.ArchiveName);
-        ///
-        ///     else if (e.EventType == ZipProgressEventType.Saving_Completed)
-        ///     {
-        ///         justHadByteUpdate= false;
-        ///         Console.WriteLine();
-        ///         Console.WriteLine("Done: {0}", e.ArchiveName);
-        ///     }
-        ///
-        ///     else if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry)
-        ///     {
-        ///         if (justHadByteUpdate)
-        ///             Console.WriteLine();
-        ///         Console.WriteLine("  Writing: {0} ({1}/{2})",
-        ///                           e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal);
-        ///         justHadByteUpdate= false;
-        ///     }
-        ///
-        ///     else if (e.EventType == ZipProgressEventType.Saving_EntryBytesRead)
-        ///     {
-        ///         if (justHadByteUpdate)
-        ///             Console.SetCursorPosition(0, Console.CursorTop);
-        ///          Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer,
-        ///                       e.BytesTransferred / (0.01 * e.TotalBytesToTransfer ));
-        ///         justHadByteUpdate= true;
-        ///     }
-        /// }
-        ///
-        /// public static ZipUp(string targetZip, string directory)
-        /// {
-        ///   using (var zip = new ZipFile()) {
-        ///     zip.SaveProgress += SaveProgress;
-        ///     zip.AddDirectory(directory);
-        ///     zip.Save(targetZip);
-        ///   }
-        /// }
-        ///
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Public Sub ZipUp(ByVal targetZip As String, ByVal directory As String)
-        ///     Using zip As ZipFile = New ZipFile
-        ///         AddHandler zip.SaveProgress, AddressOf MySaveProgress
-        ///         zip.AddDirectory(directory)
-        ///         zip.Save(targetZip)
-        ///     End Using
-        /// End Sub
-        ///
-        /// Private Shared justHadByteUpdate As Boolean = False
-        ///
-        /// Public Shared Sub MySaveProgress(ByVal sender As Object, ByVal e As SaveProgressEventArgs)
-        ///     If (e.EventType Is ZipProgressEventType.Saving_Started) Then
-        ///         Console.WriteLine("Saving: {0}", e.ArchiveName)
-        ///
-        ///     ElseIf (e.EventType Is ZipProgressEventType.Saving_Completed) Then
-        ///         justHadByteUpdate = False
-        ///         Console.WriteLine
-        ///         Console.WriteLine("Done: {0}", e.ArchiveName)
-        ///
-        ///     ElseIf (e.EventType Is ZipProgressEventType.Saving_BeforeWriteEntry) Then
-        ///         If justHadByteUpdate Then
-        ///             Console.WriteLine
-        ///         End If
-        ///         Console.WriteLine("  Writing: {0} ({1}/{2})", e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal)
-        ///         justHadByteUpdate = False
-        ///
-        ///     ElseIf (e.EventType Is ZipProgressEventType.Saving_EntryBytesRead) Then
-        ///         If justHadByteUpdate Then
-        ///             Console.SetCursorPosition(0, Console.CursorTop)
-        ///         End If
-        ///         Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, _
-        ///                       e.TotalBytesToTransfer, _
-        ///                       (CDbl(e.BytesTransferred) / (0.01 * e.TotalBytesToTransfer)))
-        ///         justHadByteUpdate = True
-        ///     End If
-        /// End Sub
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        ///
-        /// This is a more complete example of using the SaveProgress
-        /// events in a Windows Forms application, with a
-        /// Thread object.
-        ///
-        /// <code lang="C#">
-        /// delegate void SaveEntryProgress(SaveProgressEventArgs e);
-        /// delegate void ButtonClick(object sender, EventArgs e);
-        ///
-        /// internal class WorkerOptions
-        /// {
-        ///     public string ZipName;
-        ///     public string Folder;
-        ///     public string Encoding;
-        ///     public string Comment;
-        ///     public int ZipFlavor;
-        ///     public Zip64Option Zip64;
-        /// }
-        ///
-        /// private int _progress2MaxFactor;
-        /// private bool _saveCanceled;
-        /// private long _totalBytesBeforeCompress;
-        /// private long _totalBytesAfterCompress;
-        /// private Thread _workerThread;
-        ///
-        ///
-        /// private void btnZipup_Click(object sender, EventArgs e)
-        /// {
-        ///     KickoffZipup();
-        /// }
-        ///
-        /// private void btnCancel_Click(object sender, EventArgs e)
-        /// {
-        ///     if (this.lblStatus.InvokeRequired)
-        ///     {
-        ///         this.lblStatus.Invoke(new ButtonClick(this.btnCancel_Click), new object[] { sender, e });
-        ///     }
-        ///     else
-        ///     {
-        ///         _saveCanceled = true;
-        ///         lblStatus.Text = "Canceled...";
-        ///         ResetState();
-        ///     }
-        /// }
-        ///
-        /// private void KickoffZipup()
-        /// {
-        ///     _folderName = tbDirName.Text;
-        ///
-        ///     if (_folderName == null || _folderName == "") return;
-        ///     if (this.tbZipName.Text == null || this.tbZipName.Text == "") return;
-        ///
-        ///     // check for existence of the zip file:
-        ///     if (System.IO.File.Exists(this.tbZipName.Text))
-        ///     {
-        ///         var dlgResult = MessageBox.Show(String.Format("The file you have specified ({0}) already exists." +
-        ///                                                       "  Do you want to overwrite this file?", this.tbZipName.Text),
-        ///                                         "Confirmation is Required", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
-        ///         if (dlgResult != DialogResult.Yes) return;
-        ///         System.IO.File.Delete(this.tbZipName.Text);
-        ///     }
-        ///
-        ///      _saveCanceled = false;
-        ///     _nFilesCompleted = 0;
-        ///     _totalBytesAfterCompress = 0;
-        ///     _totalBytesBeforeCompress = 0;
-        ///     this.btnOk.Enabled = false;
-        ///     this.btnOk.Text = "Zipping...";
-        ///     this.btnCancel.Enabled = true;
-        ///     lblStatus.Text = "Zipping...";
-        ///
-        ///     var options = new WorkerOptions
-        ///     {
-        ///         ZipName = this.tbZipName.Text,
-        ///         Folder = _folderName,
-        ///         Encoding = "ibm437"
-        ///     };
-        ///
-        ///     if (this.comboBox1.SelectedIndex != 0)
-        ///     {
-        ///         options.Encoding = this.comboBox1.SelectedItem.ToString();
-        ///     }
-        ///
-        ///     if (this.radioFlavorSfxCmd.Checked)
-        ///         options.ZipFlavor = 2;
-        ///     else if (this.radioFlavorSfxGui.Checked)
-        ///         options.ZipFlavor = 1;
-        ///     else options.ZipFlavor = 0;
-        ///
-        ///     if (this.radioZip64AsNecessary.Checked)
-        ///         options.Zip64 = Zip64Option.AsNecessary;
-        ///     else if (this.radioZip64Always.Checked)
-        ///         options.Zip64 = Zip64Option.Always;
-        ///     else options.Zip64 = Zip64Option.Never;
-        ///
-        ///     options.Comment = String.Format("Encoding:{0} || Flavor:{1} || ZIP64:{2}\r\nCreated at {3} || {4}\r\n",
-        ///                 options.Encoding,
-        ///                 FlavorToString(options.ZipFlavor),
-        ///                 options.Zip64.ToString(),
-        ///                 System.DateTime.Now.ToString("yyyy-MMM-dd HH:mm:ss"),
-        ///                 this.Text);
-        ///
-        ///     if (this.tbComment.Text != TB_COMMENT_NOTE)
-        ///         options.Comment += this.tbComment.Text;
-        ///
-        ///     _workerThread = new Thread(this.DoSave);
-        ///     _workerThread.Name = "Zip Saver thread";
-        ///     _workerThread.Start(options);
-        ///     this.Cursor = Cursors.WaitCursor;
-        ///  }
-        ///
-        ///
-        /// private void DoSave(Object p)
-        /// {
-        ///     WorkerOptions options = p as WorkerOptions;
-        ///     try
-        ///     {
-        ///         using (var zip1 = new ZipFile())
-        ///         {
-        ///             zip1.ProvisionalAlternateEncoding = System.Text.Encoding.GetEncoding(options.Encoding);
-        ///             zip1.Comment = options.Comment;
-        ///             zip1.AddDirectory(options.Folder);
-        ///             _entriesToZip = zip1.EntryFileNames.Count;
-        ///             SetProgressBars();
-        ///             zip1.SaveProgress += this.zip1_SaveProgress;
-        ///
-        ///             zip1.UseZip64WhenSaving = options.Zip64;
-        ///
-        ///             if (options.ZipFlavor == 1)
-        ///                 zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.WinFormsApplication);
-        ///             else if (options.ZipFlavor == 2)
-        ///                 zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.ConsoleApplication);
-        ///             else
-        ///                 zip1.Save(options.ZipName);
-        ///         }
-        ///     }
-        ///     catch (System.Exception exc1)
-        ///     {
-        ///         MessageBox.Show(String.Format("Exception while zipping: {0}", exc1.Message));
-        ///         btnCancel_Click(null, null);
-        ///     }
-        /// }
-        ///
-        ///
-        ///
-        /// void zip1_SaveProgress(object sender, SaveProgressEventArgs e)
-        /// {
-        ///     switch (e.EventType)
-        ///     {
-        ///         case ZipProgressEventType.Saving_AfterWriteEntry:
-        ///             StepArchiveProgress(e);
-        ///             break;
-        ///         case ZipProgressEventType.Saving_EntryBytesRead:
-        ///             StepEntryProgress(e);
-        ///             break;
-        ///         case ZipProgressEventType.Saving_Completed:
-        ///             SaveCompleted();
-        ///             break;
-        ///         case ZipProgressEventType.Saving_AfterSaveTempArchive:
-        ///             // this event only occurs when saving an SFX file
-        ///             TempArchiveSaved();
-        ///             break;
-        ///     }
-        ///     if (_saveCanceled)
-        ///         e.Cancel = true;
-        /// }
-        ///
-        ///
-        ///
-        /// private void StepArchiveProgress(SaveProgressEventArgs e)
-        /// {
-        ///     if (this.progressBar1.InvokeRequired)
-        ///     {
-        ///         this.progressBar1.Invoke(new SaveEntryProgress(this.StepArchiveProgress), new object[] { e });
-        ///     }
-        ///     else
-        ///     {
-        ///         if (!_saveCanceled)
-        ///         {
-        ///             _nFilesCompleted++;
-        ///             this.progressBar1.PerformStep();
-        ///             _totalBytesAfterCompress += e.CurrentEntry.CompressedSize;
-        ///             _totalBytesBeforeCompress += e.CurrentEntry.UncompressedSize;
-        ///
-        ///             // reset the progress bar for the entry:
-        ///             this.progressBar2.Value = this.progressBar2.Maximum = 1;
-        ///
-        ///             this.Update();
-        ///         }
-        ///     }
-        /// }
-        ///
-        ///
-        /// private void StepEntryProgress(SaveProgressEventArgs e)
-        /// {
-        ///     if (this.progressBar2.InvokeRequired)
-        ///     {
-        ///         this.progressBar2.Invoke(new SaveEntryProgress(this.StepEntryProgress), new object[] { e });
-        ///     }
-        ///     else
-        ///     {
-        ///         if (!_saveCanceled)
-        ///         {
-        ///             if (this.progressBar2.Maximum == 1)
-        ///             {
-        ///                 // reset
-        ///                 Int64 max = e.TotalBytesToTransfer;
-        ///                 _progress2MaxFactor = 0;
-        ///                 while (max > System.Int32.MaxValue)
-        ///                 {
-        ///                     max /= 2;
-        ///                     _progress2MaxFactor++;
-        ///                 }
-        ///                 this.progressBar2.Maximum = (int)max;
-        ///                 lblStatus.Text = String.Format("{0} of {1} files...({2})",
-        ///                     _nFilesCompleted + 1, _entriesToZip, e.CurrentEntry.FileName);
-        ///             }
-        ///
-        ///              int xferred = e.BytesTransferred >> _progress2MaxFactor;
-        ///
-        ///              this.progressBar2.Value = (xferred >= this.progressBar2.Maximum)
-        ///                 ? this.progressBar2.Maximum
-        ///                 : xferred;
-        ///
-        ///              this.Update();
-        ///         }
-        ///     }
-        /// }
-        ///
-        /// private void SaveCompleted()
-        /// {
-        ///     if (this.lblStatus.InvokeRequired)
-        ///     {
-        ///         this.lblStatus.Invoke(new MethodInvoker(this.SaveCompleted));
-        ///     }
-        ///     else
-        ///     {
-        ///         lblStatus.Text = String.Format("Done, Compressed {0} files, {1:N0}% of original.",
-        ///             _nFilesCompleted, (100.00 * _totalBytesAfterCompress) / _totalBytesBeforeCompress);
-        ///          ResetState();
-        ///     }
-        /// }
-        ///
-        /// private void ResetState()
-        /// {
-        ///     this.btnCancel.Enabled = false;
-        ///     this.btnOk.Enabled = true;
-        ///     this.btnOk.Text = "Zip it!";
-        ///     this.progressBar1.Value = 0;
-        ///     this.progressBar2.Value = 0;
-        ///     this.Cursor = Cursors.Default;
-        ///     if (!_workerThread.IsAlive)
-        ///         _workerThread.Join();
-        /// }
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.ReadProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractProgress"/>
-        internal event EventHandler<SaveProgressEventArgs> SaveProgress;
-
-
-        internal bool OnSaveBlock(ZipEntry entry, Int64 bytesXferred, Int64 totalBytesToXfer)
-        {
-            EventHandler<SaveProgressEventArgs> sp = SaveProgress;
-            if (sp != null)
-            {
-                var e = SaveProgressEventArgs.ByteUpdate(ArchiveNameForEvent, entry,
-                                                         bytesXferred, totalBytesToXfer);
-                sp(this, e);
-                if (e.Cancel)
-                    _saveOperationCanceled = true;
-            }
-            return _saveOperationCanceled;
-        }
-
-        private void OnSaveEntry(int current, ZipEntry entry, bool before)
-        {
-            EventHandler<SaveProgressEventArgs> sp = SaveProgress;
-            if (sp != null)
-            {
-                var e = new SaveProgressEventArgs(ArchiveNameForEvent, before, _entries.Count, current, entry);
-                sp(this, e);
-                if (e.Cancel)
-                    _saveOperationCanceled = true;
-            }
-        }
-
-        private void OnSaveEvent(ZipProgressEventType eventFlavor)
-        {
-            EventHandler<SaveProgressEventArgs> sp = SaveProgress;
-            if (sp != null)
-            {
-                var e = new SaveProgressEventArgs(ArchiveNameForEvent, eventFlavor);
-                sp(this, e);
-                if (e.Cancel)
-                    _saveOperationCanceled = true;
-            }
-        }
-
-        private void OnSaveStarted()
-        {
-            EventHandler<SaveProgressEventArgs> sp = SaveProgress;
-            if (sp != null)
-            {
-                var e = SaveProgressEventArgs.Started(ArchiveNameForEvent);
-                sp(this, e);
-                if (e.Cancel)
-                    _saveOperationCanceled = true;
-            }
-        }
-        private void OnSaveCompleted()
-        {
-            EventHandler<SaveProgressEventArgs> sp = SaveProgress;
-            if (sp != null)
-            {
-                var e = SaveProgressEventArgs.Completed(ArchiveNameForEvent);
-                sp(this, e);
-            }
-        }
-        #endregion
-
-
-        #region Read
-        /// <summary>
-        /// An event handler invoked before, during, and after the reading of a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// Depending on the particular event being signaled, different properties on the
-        /// <see cref="ReadProgressEventArgs"/> parameter are set.  The following table
-        /// summarizes the available EventTypes and the conditions under which this
-        /// event handler is invoked with a <c>ReadProgressEventArgs</c> with the given EventType.
-        /// </para>
-        ///
-        /// <list type="table">
-        /// <listheader>
-        /// <term>value of EntryType</term>
-        /// <description>Meaning and conditions</description>
-        /// </listheader>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Reading_Started</term>
-        /// <description>Fired just as ZipFile.Read() begins. Meaningful properties: ArchiveName.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Reading_Completed</term>
-        /// <description>Fired when ZipFile.Read() has completed. Meaningful properties: ArchiveName.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Reading_ArchiveBytesRead</term>
-        /// <description>Fired while reading, updates the number of bytes read for the entire archive.
-        /// Meaningful properties: ArchiveName, CurrentEntry, BytesTransferred, TotalBytesToTransfer.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Reading_BeforeReadEntry</term>
-        /// <description>Indicates an entry is about to be read from the archive.
-        /// Meaningful properties: ArchiveName, EntriesTotal.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Reading_AfterReadEntry</term>
-        /// <description>Indicates an entry has just been read from the archive.
-        /// Meaningful properties: ArchiveName, EntriesTotal, CurrentEntry.
-        /// </description>
-        /// </item>
-        ///
-        /// </list>
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.SaveProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractProgress"/>
-        internal event EventHandler<ReadProgressEventArgs> ReadProgress;
-
-        private void OnReadStarted()
-        {
-            EventHandler<ReadProgressEventArgs> rp = ReadProgress;
-            if (rp != null)
-            {
-                    var e = ReadProgressEventArgs.Started(ArchiveNameForEvent);
-                    rp(this, e);
-            }
-        }
-
-        private void OnReadCompleted()
-        {
-            EventHandler<ReadProgressEventArgs> rp = ReadProgress;
-            if (rp != null)
-            {
-                    var e = ReadProgressEventArgs.Completed(ArchiveNameForEvent);
-                    rp(this, e);
-            }
-        }
-
-        internal void OnReadBytes(ZipEntry entry)
-        {
-            EventHandler<ReadProgressEventArgs> rp = ReadProgress;
-            if (rp != null)
-            {
-                    var e = ReadProgressEventArgs.ByteUpdate(ArchiveNameForEvent,
-                                        entry,
-                                        ReadStream.Position,
-                                        LengthOfReadStream);
-                    rp(this, e);
-            }
-        }
-
-        internal void OnReadEntry(bool before, ZipEntry entry)
-        {
-            EventHandler<ReadProgressEventArgs> rp = ReadProgress;
-            if (rp != null)
-            {
-                ReadProgressEventArgs e = (before)
-                    ? ReadProgressEventArgs.Before(ArchiveNameForEvent, _entries.Count)
-                    : ReadProgressEventArgs.After(ArchiveNameForEvent, entry, _entries.Count);
-                rp(this, e);
-            }
-        }
-
-        private Int64 _lengthOfReadStream = -99;
-        private Int64 LengthOfReadStream
-        {
-            get
-            {
-                if (_lengthOfReadStream == -99)
-                {
-                    _lengthOfReadStream = (_ReadStreamIsOurs)
-                        ? SharedUtilities.GetFileLength(_name)
-                        : -1L;
-                }
-                return _lengthOfReadStream;
-            }
-        }
-        #endregion
-
-
-        #region Extract
-        /// <summary>
-        ///   An event handler invoked before, during, and after extraction of
-        ///   entries in the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Depending on the particular event, different properties on the <see
-        ///   cref="ExtractProgressEventArgs"/> parameter are set.  The following
-        ///   table summarizes the available EventTypes and the conditions under
-        ///   which this event handler is invoked with a
-        ///   <c>ExtractProgressEventArgs</c> with the given EventType.
-        /// </para>
-        ///
-        /// <list type="table">
-        /// <listheader>
-        /// <term>value of EntryType</term>
-        /// <description>Meaning and conditions</description>
-        /// </listheader>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_BeforeExtractAll</term>
-        /// <description>
-        ///   Set when ExtractAll() begins. The ArchiveName, Overwrite, and
-        ///   ExtractLocation properties are meaningful.</description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_AfterExtractAll</term>
-        /// <description>
-        ///   Set when ExtractAll() has completed.  The ArchiveName, Overwrite,
-        ///   and ExtractLocation properties are meaningful.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_BeforeExtractEntry</term>
-        /// <description>
-        ///   Set when an Extract() on an entry in the ZipFile has begun.
-        ///   Properties that are meaningful: ArchiveName, EntriesTotal,
-        ///   CurrentEntry, Overwrite, ExtractLocation, EntriesExtracted.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_AfterExtractEntry</term>
-        /// <description>
-        ///   Set when an Extract() on an entry in the ZipFile has completed.
-        ///   Properties that are meaningful: ArchiveName, EntriesTotal,
-        ///   CurrentEntry, Overwrite, ExtractLocation, EntriesExtracted.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_EntryBytesWritten</term>
-        /// <description>
-        ///   Set within a call to Extract() on an entry in the ZipFile, as data
-        ///   is extracted for the entry.  Properties that are meaningful:
-        ///   ArchiveName, CurrentEntry, BytesTransferred, TotalBytesToTransfer.
-        /// </description>
-        /// </item>
-        ///
-        /// <item>
-        /// <term>ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite</term>
-        /// <description>
-        ///   Set within a call to Extract() on an entry in the ZipFile, when the
-        ///   extraction would overwrite an existing file. This event type is used
-        ///   only when <c>ExtractExistingFileAction</c> on the <c>ZipFile</c> or
-        ///   <c>ZipEntry</c> is set to <c>InvokeExtractProgressEvent</c>.
-        /// </description>
-        /// </item>
-        ///
-        /// </list>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code>
-        /// private static bool justHadByteUpdate = false;
-        /// public static void ExtractProgress(object sender, ExtractProgressEventArgs e)
-        /// {
-        ///   if(e.EventType == ZipProgressEventType.Extracting_EntryBytesWritten)
-        ///   {
-        ///     if (justHadByteUpdate)
-        ///       Console.SetCursorPosition(0, Console.CursorTop);
-        ///
-        ///     Console.Write("   {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer,
-        ///                   e.BytesTransferred / (0.01 * e.TotalBytesToTransfer ));
-        ///     justHadByteUpdate = true;
-        ///   }
-        ///   else if(e.EventType == ZipProgressEventType.Extracting_BeforeExtractEntry)
-        ///   {
-        ///     if (justHadByteUpdate)
-        ///       Console.WriteLine();
-        ///     Console.WriteLine("Extracting: {0}", e.CurrentEntry.FileName);
-        ///     justHadByteUpdate= false;
-        ///   }
-        /// }
-        ///
-        /// public static ExtractZip(string zipToExtract, string directory)
-        /// {
-        ///   string TargetDirectory= "extract";
-        ///   using (var zip = ZipFile.Read(zipToExtract)) {
-        ///     zip.ExtractProgress += ExtractProgress;
-        ///     foreach (var e in zip1)
-        ///     {
-        ///       e.Extract(TargetDirectory, true);
-        ///     }
-        ///   }
-        /// }
-        ///
-        /// </code>
-        /// <code lang="VB">
-        /// Public Shared Sub Main(ByVal args As String())
-        ///     Dim ZipToUnpack As String = "C1P3SML.zip"
-        ///     Dim TargetDir As String = "ExtractTest_Extract"
-        ///     Console.WriteLine("Extracting file {0} to {1}", ZipToUnpack, TargetDir)
-        ///     Using zip1 As ZipFile = ZipFile.Read(ZipToUnpack)
-        ///         AddHandler zip1.ExtractProgress, AddressOf MyExtractProgress
-        ///         Dim e As ZipEntry
-        ///         For Each e In zip1
-        ///             e.Extract(TargetDir, True)
-        ///         Next
-        ///     End Using
-        /// End Sub
-        ///
-        /// Private Shared justHadByteUpdate As Boolean = False
-        ///
-        /// Public Shared Sub MyExtractProgress(ByVal sender As Object, ByVal e As ExtractProgressEventArgs)
-        ///     If (e.EventType = ZipProgressEventType.Extracting_EntryBytesWritten) Then
-        ///         If ExtractTest.justHadByteUpdate Then
-        ///             Console.SetCursorPosition(0, Console.CursorTop)
-        ///         End If
-        ///         Console.Write("   {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer, (CDbl(e.BytesTransferred) / (0.01 * e.TotalBytesToTransfer)))
-        ///         ExtractTest.justHadByteUpdate = True
-        ///     ElseIf (e.EventType = ZipProgressEventType.Extracting_BeforeExtractEntry) Then
-        ///         If ExtractTest.justHadByteUpdate Then
-        ///             Console.WriteLine
-        ///         End If
-        ///         Console.WriteLine("Extracting: {0}", e.CurrentEntry.FileName)
-        ///         ExtractTest.justHadByteUpdate = False
-        ///     End If
-        /// End Sub
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.SaveProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ReadProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.AddProgress"/>
-        internal event EventHandler<ExtractProgressEventArgs> ExtractProgress;
-
-
-
-        private void OnExtractEntry(int current, bool before, ZipEntry currentEntry, string path)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = new ExtractProgressEventArgs(ArchiveNameForEvent, before, _entries.Count, current, currentEntry, path);
-                ep(this, e);
-                if (e.Cancel)
-                    _extractOperationCanceled = true;
-            }
-        }
-
-
-        // Can be called from within ZipEntry._ExtractOne.
-        internal bool OnExtractBlock(ZipEntry entry, Int64 bytesWritten, Int64 totalBytesToWrite)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = ExtractProgressEventArgs.ByteUpdate(ArchiveNameForEvent, entry,
-                                                            bytesWritten, totalBytesToWrite);
-                ep(this, e);
-                if (e.Cancel)
-                    _extractOperationCanceled = true;
-            }
-            return _extractOperationCanceled;
-        }
-
-
-        // Can be called from within ZipEntry.InternalExtract.
-        internal bool OnSingleEntryExtract(ZipEntry entry, string path, bool before)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = (before)
-                    ? ExtractProgressEventArgs.BeforeExtractEntry(ArchiveNameForEvent, entry, path)
-                    : ExtractProgressEventArgs.AfterExtractEntry(ArchiveNameForEvent, entry, path);
-                ep(this, e);
-                if (e.Cancel)
-                    _extractOperationCanceled = true;
-            }
-            return _extractOperationCanceled;
-        }
-
-        internal bool OnExtractExisting(ZipEntry entry, string path)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = ExtractProgressEventArgs.ExtractExisting(ArchiveNameForEvent, entry, path);
-                ep(this, e);
-                if (e.Cancel)
-                    _extractOperationCanceled = true;
-            }
-            return _extractOperationCanceled;
-        }
-
-
-        private void OnExtractAllCompleted(string path)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = ExtractProgressEventArgs.ExtractAllCompleted(ArchiveNameForEvent,
-                                                                     path );
-                ep(this, e);
-            }
-        }
-
-
-        private void OnExtractAllStarted(string path)
-        {
-            EventHandler<ExtractProgressEventArgs> ep = ExtractProgress;
-            if (ep != null)
-            {
-                var e = ExtractProgressEventArgs.ExtractAllStarted(ArchiveNameForEvent,
-                                                                   path );
-                ep(this, e);
-            }
-        }
-
-
-        #endregion
-
-
-
-        #region Add
-        /// <summary>
-        /// An event handler invoked before, during, and after Adding entries to a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///     Adding a large number of entries to a zip file can take a long
-        ///     time.  For example, when calling <see cref="AddDirectory(string)"/> on a
-        ///     directory that contains 50,000 files, it could take 3 minutes or so.
-        ///     This event handler allws an application to track the progress of the Add
-        ///     operation, and to optionally cancel a lengthy Add operation.
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code lang="C#">
-        ///
-        /// int _numEntriesToAdd= 0;
-        /// int _numEntriesAdded= 0;
-        /// void AddProgressHandler(object sender, AddProgressEventArgs e)
-        /// {
-        ///     switch (e.EventType)
-        ///     {
-        ///         case ZipProgressEventType.Adding_Started:
-        ///             Console.WriteLine("Adding files to the zip...");
-        ///             break;
-        ///         case ZipProgressEventType.Adding_AfterAddEntry:
-        ///             _numEntriesAdded++;
-        ///             Console.WriteLine(String.Format("Adding file {0}/{1} :: {2}",
-        ///                                      _numEntriesAdded, _numEntriesToAdd, e.CurrentEntry.FileName));
-        ///             break;
-        ///         case ZipProgressEventType.Adding_Completed:
-        ///             Console.WriteLine("Added all files");
-        ///             break;
-        ///     }
-        /// }
-        ///
-        /// void CreateTheZip()
-        /// {
-        ///     using (ZipFile zip = new ZipFile())
-        ///     {
-        ///         zip.AddProgress += AddProgressHandler;
-        ///         zip.AddDirectory(System.IO.Path.GetFileName(DirToZip));
-        ///         zip.Save(ZipFileToCreate);
-        ///     }
-        /// }
-        ///
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///
-        /// Private Sub AddProgressHandler(ByVal sender As Object, ByVal e As AddProgressEventArgs)
-        ///     Select Case e.EventType
-        ///         Case ZipProgressEventType.Adding_Started
-        ///             Console.WriteLine("Adding files to the zip...")
-        ///             Exit Select
-        ///         Case ZipProgressEventType.Adding_AfterAddEntry
-        ///             Console.WriteLine(String.Format("Adding file {0}", e.CurrentEntry.FileName))
-        ///             Exit Select
-        ///         Case ZipProgressEventType.Adding_Completed
-        ///             Console.WriteLine("Added all files")
-        ///             Exit Select
-        ///     End Select
-        /// End Sub
-        ///
-        /// Sub CreateTheZip()
-        ///     Using zip as ZipFile = New ZipFile
-        ///         AddHandler zip.AddProgress, AddressOf AddProgressHandler
-        ///         zip.AddDirectory(System.IO.Path.GetFileName(DirToZip))
-        ///         zip.Save(ZipFileToCreate);
-        ///     End Using
-        /// End Sub
-        ///
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.SaveProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ReadProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractProgress"/>
-        internal event EventHandler<AddProgressEventArgs> AddProgress;
-
-        private void OnAddStarted()
-        {
-            EventHandler<AddProgressEventArgs> ap = AddProgress;
-            if (ap != null)
-            {
-                var e = AddProgressEventArgs.Started(ArchiveNameForEvent);
-                ap(this, e);
-                if (e.Cancel) // workitem 13371
-                    _addOperationCanceled = true;
-            }
-        }
-
-        private void OnAddCompleted()
-        {
-            EventHandler<AddProgressEventArgs> ap = AddProgress;
-            if (ap != null)
-            {
-                var e = AddProgressEventArgs.Completed(ArchiveNameForEvent);
-                ap(this, e);
-            }
-        }
-
-        internal void AfterAddEntry(ZipEntry entry)
-        {
-            EventHandler<AddProgressEventArgs> ap = AddProgress;
-            if (ap != null)
-            {
-                var e = AddProgressEventArgs.AfterEntry(ArchiveNameForEvent, entry, _entries.Count);
-                ap(this, e);
-                if (e.Cancel) // workitem 13371
-                    _addOperationCanceled = true;
-            }
-        }
-
-        #endregion
-
-
-
-        #region Error
-        /// <summary>
-        /// An event that is raised when an error occurs during open or read of files
-        /// while saving a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///     Errors can occur as a file is being saved to the zip archive.  For
-        ///     example, the File.Open may fail, or a File.Read may fail, because of
-        ///     lock conflicts or other reasons.  If you add a handler to this event,
-        ///     you can handle such errors in your own code.  If you don't add a
-        ///     handler, the library will throw an exception if it encounters an I/O
-        ///     error during a call to <c>Save()</c>.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    Setting a handler implicitly sets <see cref="ZipFile.ZipErrorAction"/> to
-        ///    <c>ZipErrorAction.InvokeErrorEvent</c>.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    The handler you add applies to all <see cref="ZipEntry"/> items that are
-        ///    subsequently added to the <c>ZipFile</c> instance. If you set this
-        ///    property after you have added items to the <c>ZipFile</c>, but before you
-        ///    have called <c>Save()</c>, errors that occur while saving those items
-        ///    will not cause the error handler to be invoked.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you want to handle any errors that occur with any entry in the zip
-        ///    file using the same error handler, then add your error handler once,
-        ///    before adding any entries to the zip archive.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    In the error handler method, you need to set the <see
-        ///    cref="ZipEntry.ZipErrorAction"/> property on the
-        ///    <c>ZipErrorEventArgs.CurrentEntry</c>.  This communicates back to
-        ///    DotNetZip what you would like to do with this particular error.  Within
-        ///    an error handler, if you set the <c>ZipEntry.ZipErrorAction</c> property
-        ///    on the <c>ZipEntry</c> to <c>ZipErrorAction.InvokeErrorEvent</c> or if
-        ///    you don't set it at all, the library will throw the exception. (It is the
-        ///    same as if you had set the <c>ZipEntry.ZipErrorAction</c> property on the
-        ///    <c>ZipEntry</c> to <c>ZipErrorAction.Throw</c>.) If you set the
-        ///    <c>ZipErrorEventArgs.Cancel</c> to true, the entire <c>Save()</c> will be
-        ///    canceled.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    In the case that you use <c>ZipErrorAction.Skip</c>, implying that
-        ///    you want to skip the entry for which there's been an error, DotNetZip
-        ///    tries to seek backwards in the output stream, and truncate all bytes
-        ///    written on behalf of that particular entry. This works only if the
-        ///    output stream is seekable.  It will not work, for example, when using
-        ///    ASPNET's Response.OutputStream.
-        ///  </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        /// This example shows how to use an event handler to handle
-        /// errors during save of the zip file.
-        /// <code lang="C#">
-        ///
-        /// public static void MyZipError(object sender, ZipErrorEventArgs e)
-        /// {
-        ///     Console.WriteLine("Error saving {0}...", e.FileName);
-        ///     Console.WriteLine("   Exception: {0}", e.exception);
-        ///     ZipEntry entry = e.CurrentEntry;
-        ///     string response = null;
-        ///     // Ask the user whether he wants to skip this error or not
-        ///     do
-        ///     {
-        ///         Console.Write("Retry, Skip, Throw, or Cancel ? (R/S/T/C) ");
-        ///         response = Console.ReadLine();
-        ///         Console.WriteLine();
-        ///
-        ///     } while (response != null &amp;&amp;
-        ///              response[0]!='S' &amp;&amp; response[0]!='s' &amp;&amp;
-        ///              response[0]!='R' &amp;&amp; response[0]!='r' &amp;&amp;
-        ///              response[0]!='T' &amp;&amp; response[0]!='t' &amp;&amp;
-        ///              response[0]!='C' &amp;&amp; response[0]!='c');
-        ///
-        ///     e.Cancel = (response[0]=='C' || response[0]=='c');
-        ///
-        ///     if (response[0]=='S' || response[0]=='s')
-        ///         entry.ZipErrorAction = ZipErrorAction.Skip;
-        ///     else if (response[0]=='R' || response[0]=='r')
-        ///         entry.ZipErrorAction = ZipErrorAction.Retry;
-        ///     else if (response[0]=='T' || response[0]=='t')
-        ///         entry.ZipErrorAction = ZipErrorAction.Throw;
-        /// }
-        ///
-        /// public void SaveTheFile()
-        /// {
-        ///   string directoryToZip = "fodder";
-        ///   string directoryInArchive = "files";
-        ///   string zipFileToCreate = "Archive.zip";
-        ///   using (var zip = new ZipFile())
-        ///   {
-        ///     // set the event handler before adding any entries
-        ///     zip.ZipError += MyZipError;
-        ///     zip.AddDirectory(directoryToZip, directoryInArchive);
-        ///     zip.Save(zipFileToCreate);
-        ///   }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub MyZipError(ByVal sender As Object, ByVal e As Ionic.Zip.ZipErrorEventArgs)
-        ///     ' At this point, the application could prompt the user for an action to take.
-        ///     ' But in this case, this application will simply automatically skip the file, in case of error.
-        ///     Console.WriteLine("Zip Error,  entry {0}", e.CurrentEntry.FileName)
-        ///     Console.WriteLine("   Exception: {0}", e.exception)
-        ///     ' set the desired ZipErrorAction on the CurrentEntry to communicate that to DotNetZip
-        ///     e.CurrentEntry.ZipErrorAction = Zip.ZipErrorAction.Skip
-        /// End Sub
-        ///
-        /// Public Sub SaveTheFile()
-        ///     Dim directoryToZip As String = "fodder"
-        ///     Dim directoryInArchive As String = "files"
-        ///     Dim zipFileToCreate as String = "Archive.zip"
-        ///     Using zipArchive As ZipFile = New ZipFile
-        ///         ' set the event handler before adding any entries
-        ///         AddHandler zipArchive.ZipError, AddressOf MyZipError
-        ///         zipArchive.AddDirectory(directoryToZip, directoryInArchive)
-        ///         zipArchive.Save(zipFileToCreate)
-        ///     End Using
-        /// End Sub
-        ///
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.ZipErrorAction"/>
-        internal event EventHandler<ZipErrorEventArgs> ZipError;
-
-        internal bool OnZipErrorSaving(ZipEntry entry, Exception exc)
-        {
-            if (ZipError != null)
-            {
-                lock (LOCK)
-                {
-                    var e = ZipErrorEventArgs.Saving(this.Name, entry, exc);
-                    ZipError(this, e);
-                    if (e.Cancel)
-                        _saveOperationCanceled = true;
-                }
-            }
-            return _saveOperationCanceled;
-        }
-        #endregion
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Extract.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Extract.cs
deleted file mode 100644
index 2fd8646..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Extract.cs
+++ /dev/null
@@ -1,298 +0,0 @@
-// ZipFile.Extract.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-31 14:45:18>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for Extract operations on zip files.
-//
-// ------------------------------------------------------------------
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    internal partial class ZipFile
-    {
-
-        /// <summary>
-        /// Extracts all of the items in the zip archive, to the specified path in the
-        /// filesystem.  The path can be relative or fully-qualified.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method will extract all entries in the <c>ZipFile</c> to the
-        ///   specified path.
-        /// </para>
-        ///
-        /// <para>
-        ///   If an extraction of a file from the zip archive would overwrite an
-        ///   existing file in the filesystem, the action taken is dictated by the
-        ///   ExtractExistingFile property, which overrides any setting you may have
-        ///   made on individual ZipEntry instances.  By default, if you have not
-        ///   set that property on the <c>ZipFile</c> instance, the entry will not
-        ///   be extracted, the existing file will not be overwritten and an
-        ///   exception will be thrown. To change this, set the property, or use the
-        ///   <see cref="ZipFile.ExtractAll(string,
-        ///   Ionic.Zip.ExtractExistingFileAction)" /> overload that allows you to
-        ///   specify an ExtractExistingFileAction parameter.
-        /// </para>
-        ///
-        /// <para>
-        ///   The action to take when an extract would overwrite an existing file
-        ///   applies to all entries.  If you want to set this on a per-entry basis,
-        ///   then you must use one of the <see
-        ///   cref="ZipEntry.Extract()">ZipEntry.Extract</see> methods.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method will send verbose output messages to the <see
-        ///   cref="StatusMessageTextWriter"/>, if it is set on the <c>ZipFile</c>
-        ///   instance.
-        /// </para>
-        ///
-        /// <para>
-        /// You may wish to take advantage of the <c>ExtractProgress</c> event.
-        /// </para>
-        ///
-        /// <para>
-        ///   About timestamps: When extracting a file entry from a zip archive, the
-        ///   extracted file gets the last modified time of the entry as stored in
-        ///   the archive. The archive may also store extended file timestamp
-        ///   information, including last accessed and created times. If these are
-        ///   present in the <c>ZipEntry</c>, then the extracted file will also get
-        ///   these times.
-        /// </para>
-        ///
-        /// <para>
-        ///   A Directory entry is somewhat different. It will get the times as
-        ///   described for a file entry, but, if there are file entries in the zip
-        ///   archive that, when extracted, appear in the just-created directory,
-        ///   then when those file entries are extracted, the last modified and last
-        ///   accessed times of the directory will change, as a side effect.  The
-        ///   result is that after an extraction of a directory and a number of
-        ///   files within the directory, the last modified and last accessed
-        ///   timestamps on the directory will reflect the time that the last file
-        ///   was extracted into the directory, rather than the time stored in the
-        ///   zip archive for the directory.
-        /// </para>
-        ///
-        /// <para>
-        ///   To compensate, when extracting an archive with <c>ExtractAll</c>,
-        ///   DotNetZip will extract all the file and directory entries as described
-        ///   above, but it will then make a second pass on the directories, and
-        ///   reset the times on the directories to reflect what is stored in the
-        ///   zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   This compensation is performed only within the context of an
-        ///   <c>ExtractAll</c>. If you call <c>ZipEntry.Extract</c> on a directory
-        ///   entry, the timestamps on directory in the filesystem will reflect the
-        ///   times stored in the zip.  If you then call <c>ZipEntry.Extract</c> on
-        ///   a file entry, which is extracted into the directory, the timestamps on
-        ///   the directory will be updated to the current time.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example extracts all the entries in a zip archive file, to the
-        ///   specified target directory.  The extraction will overwrite any
-        ///   existing files silently.
-        ///
-        /// <code>
-        /// String TargetDirectory= "unpack";
-        /// using(ZipFile zip= ZipFile.Read(ZipFileToExtract))
-        /// {
-        ///     zip.ExtractExistingFile= ExtractExistingFileAction.OverwriteSilently;
-        ///     zip.ExtractAll(TargetDirectory);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim TargetDirectory As String = "unpack"
-        /// Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
-        ///     zip.ExtractExistingFile= ExtractExistingFileAction.OverwriteSilently
-        ///     zip.ExtractAll(TargetDirectory)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractProgress"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ExtractExistingFile"/>
-        ///
-        /// <param name="path">
-        ///   The path to which the contents of the zipfile will be extracted.
-        ///   The path can be relative or fully-qualified.
-        /// </param>
-        ///
-        public void ExtractAll(string path)
-        {
-            _InternalExtractAll(path, true);
-        }
-
-
-
-        /// <summary>
-        /// Extracts all of the items in the zip archive, to the specified path in the
-        /// filesystem, using the specified behavior when extraction would overwrite an
-        /// existing file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        /// This method will extract all entries in the <c>ZipFile</c> to the specified
-        /// path.  For an extraction that would overwrite an existing file, the behavior
-        /// is dictated by <paramref name="extractExistingFile"/>, which overrides any
-        /// setting you may have made on individual ZipEntry instances.
-        /// </para>
-        ///
-        /// <para>
-        /// The action to take when an extract would overwrite an existing file
-        /// applies to all entries.  If you want to set this on a per-entry basis,
-        /// then you must use <see cref="ZipEntry.Extract(String,
-        /// ExtractExistingFileAction)" /> or one of the similar methods.
-        /// </para>
-        ///
-        /// <para>
-        /// Calling this method is equivalent to setting the <see
-        /// cref="ExtractExistingFile"/> property and then calling <see
-        /// cref="ExtractAll(String)"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// This method will send verbose output messages to the
-        /// <see cref="StatusMessageTextWriter"/>, if it is set on the <c>ZipFile</c> instance.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example extracts all the entries in a zip archive file, to the
-        /// specified target directory.  It does not overwrite any existing files.
-        /// <code>
-        /// String TargetDirectory= "c:\\unpack";
-        /// using(ZipFile zip= ZipFile.Read(ZipFileToExtract))
-        /// {
-        ///   zip.ExtractAll(TargetDirectory, ExtractExistingFileAction.DontOverwrite);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim TargetDirectory As String = "c:\unpack"
-        /// Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
-        ///     zip.ExtractAll(TargetDirectory, ExtractExistingFileAction.DontOverwrite)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="path">
-        /// The path to which the contents of the zipfile will be extracted.
-        /// The path can be relative or fully-qualified.
-        /// </param>
-        ///
-        /// <param name="extractExistingFile">
-        /// The action to take if extraction would overwrite an existing file.
-        /// </param>
-        /// <seealso cref="ExtractSelectedEntries(String,ExtractExistingFileAction)"/>
-        internal void ExtractAll(string path, ExtractExistingFileAction extractExistingFile)
-        {
-            ExtractExistingFile = extractExistingFile;
-            _InternalExtractAll(path, true);
-        }
-
-
-        private void _InternalExtractAll(string path, bool overrideExtractExistingProperty)
-        {
-            bool header = Verbose;
-            _inExtractAll = true;
-            try
-            {
-                OnExtractAllStarted(path);
-
-                int n = 0;
-                foreach (ZipEntry e in _entries.Values)
-                {
-                    if (header)
-                    {
-                        StatusMessageTextWriter.WriteLine("\n{1,-22} {2,-8} {3,4}   {4,-8}  {0}",
-                                  "Name", "Modified", "Size", "Ratio", "Packed");
-                        StatusMessageTextWriter.WriteLine(new System.String('-', 72));
-                        header = false;
-                    }
-                    if (Verbose)
-                    {
-                        StatusMessageTextWriter.WriteLine("{1,-22} {2,-8} {3,4:F0}%   {4,-8} {0}",
-                                  e.FileName,
-                                  e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
-                                  e.UncompressedSize,
-                                  e.CompressionRatio,
-                                  e.CompressedSize);
-                        if (!String.IsNullOrEmpty(e.Comment))
-                            StatusMessageTextWriter.WriteLine("  Comment: {0}", e.Comment);
-                    }
-                    e.Password = _Password;  // this may be null
-                    OnExtractEntry(n, true, e, path);
-                    if (overrideExtractExistingProperty)
-                        e.ExtractExistingFile = this.ExtractExistingFile;
-                    e.Extract(path);
-                    n++;
-                    OnExtractEntry(n, false, e, path);
-                    if (_extractOperationCanceled)
-                        break;
-                }
-
-                if (!_extractOperationCanceled)
-                {
-                    // workitem 8264:
-                    // now, set times on directory entries, again.
-                    // The problem is, extracting a file changes the times on the parent
-                    // directory.  So after all files have been extracted, we have to
-                    // run through the directories again.
-                    foreach (ZipEntry e in _entries.Values)
-                    {
-                        // check if it is a directory
-                        if ((e.IsDirectory) || (e.FileName.EndsWith("/")))
-                        {
-                            string outputFile = (e.FileName.StartsWith("/"))
-                                ? Path.Combine(path, e.FileName.Substring(1))
-                                : Path.Combine(path, e.FileName);
-
-                            e._SetTimes(outputFile, false);
-                        }
-                    }
-                    OnExtractAllCompleted(path);
-                }
-
-            }
-            finally
-            {
-
-                _inExtractAll = false;
-            }
-        }
-
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Read.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Read.cs
deleted file mode 100644
index a2ed0b4..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Read.cs
+++ /dev/null
@@ -1,1110 +0,0 @@
-// ZipFile.Read.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-05 11:38:59>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for Reading zip files.
-//
-// ------------------------------------------------------------------
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   A class for collecting the various options that can be used when
-    ///   Reading zip files for extraction or update.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///   <para>
-    ///     When reading a zip file, there are several options an
-    ///     application can set, to modify how the file is read, or what
-    ///     the library does while reading.  This class collects those
-    ///     options into one container.
-    ///   </para>
-    ///
-    ///   <para>
-    ///     Pass an instance of the <c>ReadOptions</c> class into the
-    ///     <c>ZipFile.Read()</c> method.
-    ///   </para>
-    ///
-    /// <seealso cref="ZipFile.Read(String, ReadOptions)"/>.
-    /// <seealso cref="ZipFile.Read(Stream, ReadOptions)"/>.
-    /// </remarks>
-    internal class ReadOptions
-    {
-        /// <summary>
-        /// An event handler for Read operations.  When opening large zip
-        /// archives, you may want to display a progress bar or other
-        /// indicator of status progress while reading.  This parameter
-        /// allows you to specify a ReadProgress Event Handler directly.
-        /// When you call <c>Read()</c>, the progress event is invoked as
-        /// necessary.
-        /// </summary>
-        public EventHandler<ReadProgressEventArgs> ReadProgress { get; set; }
-
-        /// <summary>
-        /// The <c>System.IO.TextWriter</c> to use for writing verbose status messages
-        /// during operations on the zip archive.  A console application may wish to
-        /// pass <c>System.Console.Out</c> to get messages on the Console. A graphical
-        /// or headless application may wish to capture the messages in a different
-        /// <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>.
-        /// </summary>
-        public TextWriter StatusMessageWriter { get; set; }
-
-        /// <summary>
-        /// The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be
-        /// careful specifying the encoding.  If the value you use here is not the same
-        /// as the Encoding used when the zip archive was created (possibly by a
-        /// different archiver) you will get unexpected results and possibly exceptions.
-        /// </summary>
-        ///
-        /// <seealso cref="ZipFile.ProvisionalAlternateEncoding"/>
-        ///
-        public System.Text.Encoding @Encoding { get; set; }
-    }
-
-
-    internal partial class ZipFile
-    {
-        /// <summary>
-        /// Reads a zip file archive and returns the instance.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The stream is read using the default <c>System.Text.Encoding</c>, which is the
-        /// <c>IBM437</c> codepage.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        /// Thrown if the <c>ZipFile</c> cannot be read. The implementation of this method
-        /// relies on <c>System.IO.File.OpenRead</c>, which can throw a variety of exceptions,
-        /// including specific exceptions if a file is not found, an unauthorized access
-        /// exception, exceptions for poorly formatted filenames, and so on.
-        /// </exception>
-        ///
-        /// <param name="fileName">
-        /// The name of the zip archive to open.  This can be a fully-qualified or relative
-        /// pathname.
-        /// </param>
-        ///
-        /// <seealso cref="ZipFile.Read(String, ReadOptions)"/>.
-        ///
-        /// <returns>The instance read from the zip archive.</returns>
-        ///
-        public static ZipFile Read(string fileName)
-        {
-            return ZipFile.Read(fileName, null, null, null);
-        }
-
-
-        /// <summary>
-        ///   Reads a zip file archive from the named filesystem file using the
-        ///   specified options.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This version of the <c>Read()</c> method allows the caller to pass
-        ///   in a <c>TextWriter</c> an <c>Encoding</c>, via an instance of the
-        ///   <c>ReadOptions</c> class.  The <c>ZipFile</c> is read in using the
-        ///   specified encoding for entries where UTF-8 encoding is not
-        ///   explicitly specified.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        /// <para>
-        ///   This example shows how to read a zip file using the Big-5 Chinese
-        ///   code page (950), and extract each entry in the zip file, while
-        ///   sending status messages out to the Console.
-        /// </para>
-        ///
-        /// <para>
-        ///   For this code to work as intended, the zipfile must have been
-        ///   created using the big5 code page (CP950). This is typical, for
-        ///   example, when using WinRar on a machine with CP950 set as the
-        ///   default code page.  In that case, the names of entries within the
-        ///   Zip archive will be stored in that code page, and reading the zip
-        ///   archive must be done using that code page.  If the application did
-        ///   not use the correct code page in ZipFile.Read(), then names of
-        ///   entries within the zip archive would not be correctly retrieved.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// string zipToExtract = "MyArchive.zip";
-        /// string extractDirectory = "extract";
-        /// var options = new ReadOptions
-        /// {
-        ///   StatusMessageWriter = System.Console.Out,
-        ///   Encoding = System.Text.Encoding.GetEncoding(950)
-        /// };
-        /// using (ZipFile zip = ZipFile.Read(zipToExtract, options))
-        /// {
-        ///   foreach (ZipEntry e in zip)
-        ///   {
-        ///      e.Extract(extractDirectory);
-        ///   }
-        /// }
-        /// </code>
-        ///
-        ///
-        /// <code lang="VB">
-        /// Dim zipToExtract as String = "MyArchive.zip"
-        /// Dim extractDirectory as String = "extract"
-        /// Dim options as New ReadOptions
-        /// options.Encoding = System.Text.Encoding.GetEncoding(950)
-        /// options.StatusMessageWriter = System.Console.Out
-        /// Using zip As ZipFile = ZipFile.Read(zipToExtract, options)
-        ///     Dim e As ZipEntry
-        ///     For Each e In zip
-        ///      e.Extract(extractDirectory)
-        ///     Next
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        ///
-        /// <example>
-        ///
-        /// <para>
-        ///   This example shows how to read a zip file using the default
-        ///   code page, to remove entries that have a modified date before a given threshold,
-        ///   sending status messages out to a <c>StringWriter</c>.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// var options = new ReadOptions
-        /// {
-        ///   StatusMessageWriter = new System.IO.StringWriter()
-        /// };
-        /// using (ZipFile zip =  ZipFile.Read("PackedDocuments.zip", options))
-        /// {
-        ///   var Threshold = new DateTime(2007,7,4);
-        ///   // We cannot remove the entry from the list, within the context of
-        ///   // an enumeration of said list.
-        ///   // So we add the doomed entry to a list to be removed later.
-        ///   // pass 1: mark the entries for removal
-        ///   var MarkedEntries = new System.Collections.Generic.List&lt;ZipEntry&gt;();
-        ///   foreach (ZipEntry e in zip)
-        ///   {
-        ///     if (e.LastModified &lt; Threshold)
-        ///       MarkedEntries.Add(e);
-        ///   }
-        ///   // pass 2: actually remove the entry.
-        ///   foreach (ZipEntry zombie in MarkedEntries)
-        ///      zip.RemoveEntry(zombie);
-        ///   zip.Comment = "This archive has been updated.";
-        ///   zip.Save();
-        /// }
-        /// // can now use contents of sw, eg store in an audit log
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim options as New ReadOptions
-        /// options.StatusMessageWriter = New System.IO.StringWriter
-        /// Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip", options)
-        ///     Dim Threshold As New DateTime(2007, 7, 4)
-        ///     ' We cannot remove the entry from the list, within the context of
-        ///     ' an enumeration of said list.
-        ///     ' So we add the doomed entry to a list to be removed later.
-        ///     ' pass 1: mark the entries for removal
-        ///     Dim MarkedEntries As New System.Collections.Generic.List(Of ZipEntry)
-        ///     Dim e As ZipEntry
-        ///     For Each e In zip
-        ///         If (e.LastModified &lt; Threshold) Then
-        ///             MarkedEntries.Add(e)
-        ///         End If
-        ///     Next
-        ///     ' pass 2: actually remove the entry.
-        ///     Dim zombie As ZipEntry
-        ///     For Each zombie In MarkedEntries
-        ///         zip.RemoveEntry(zombie)
-        ///     Next
-        ///     zip.Comment = "This archive has been updated."
-        ///     zip.Save
-        /// End Using
-        /// ' can now use contents of sw, eg store in an audit log
-        /// </code>
-        /// </example>
-        ///
-        /// <exception cref="System.Exception">
-        ///   Thrown if the zipfile cannot be read. The implementation of
-        ///   this method relies on <c>System.IO.File.OpenRead</c>, which
-        ///   can throw a variety of exceptions, including specific
-        ///   exceptions if a file is not found, an unauthorized access
-        ///   exception, exceptions for poorly formatted filenames, and so
-        ///   on.
-        /// </exception>
-        ///
-        /// <param name="fileName">
-        /// The name of the zip archive to open.
-        /// This can be a fully-qualified or relative pathname.
-        /// </param>
-        ///
-        /// <param name="options">
-        /// The set of options to use when reading the zip file.
-        /// </param>
-        ///
-        /// <returns>The ZipFile instance read from the zip archive.</returns>
-        ///
-        /// <seealso cref="ZipFile.Read(Stream, ReadOptions)"/>
-        ///
-        internal static ZipFile Read(string fileName,
-                                   ReadOptions options)
-        {
-            if (options == null)
-                throw new ArgumentNullException("options");
-            return Read(fileName,
-                        options.StatusMessageWriter,
-                        options.Encoding,
-                        options.ReadProgress);
-        }
-
-        /// <summary>
-        /// Reads a zip file archive using the specified text encoding,  the specified
-        /// TextWriter for status messages, and the specified ReadProgress event handler,
-        /// and returns the instance.
-        /// </summary>
-        ///
-        /// <param name="fileName">
-        /// The name of the zip archive to open.
-        /// This can be a fully-qualified or relative pathname.
-        /// </param>
-        ///
-        /// <param name="readProgress">
-        /// An event handler for Read operations.
-        /// </param>
-        ///
-        /// <param name="statusMessageWriter">
-        /// The <c>System.IO.TextWriter</c> to use for writing verbose status messages
-        /// during operations on the zip archive.  A console application may wish to
-        /// pass <c>System.Console.Out</c> to get messages on the Console. A graphical
-        /// or headless application may wish to capture the messages in a different
-        /// <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>.
-        /// </param>
-        ///
-        /// <param name="encoding">
-        /// The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be
-        /// careful specifying the encoding.  If the value you use here is not the same
-        /// as the Encoding used when the zip archive was created (possibly by a
-        /// different archiver) you will get unexpected results and possibly exceptions.
-        /// </param>
-        ///
-        /// <returns>The instance read from the zip archive.</returns>
-        ///
-        private static ZipFile Read(string fileName,
-                                   TextWriter statusMessageWriter,
-                                   System.Text.Encoding encoding,
-                                   EventHandler<ReadProgressEventArgs> readProgress)
-        {
-            ZipFile zf = new ZipFile();
-            zf.AlternateEncoding = encoding ?? DefaultEncoding;
-            zf.AlternateEncodingUsage = ZipOption.Always;
-            zf._StatusMessageTextWriter = statusMessageWriter;
-            zf._name = fileName;
-            if (readProgress != null)
-                zf.ReadProgress = readProgress;
-
-            if (zf.Verbose) zf._StatusMessageTextWriter.WriteLine("reading from {0}...", fileName);
-
-            ReadIntoInstance(zf);
-            zf._fileAlreadyExists = true;
-
-            return zf;
-        }
-
-        /// <summary>
-        ///   Reads a zip archive from a stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When reading from a file, it's probably easier to just use
-        ///   <see cref="ZipFile.Read(String,
-        ///   ReadOptions)">ZipFile.Read(String, ReadOptions)</see>.  This
-        ///   overload is useful when when the zip archive content is
-        ///   available from an already-open stream. The stream must be
-        ///   open and readable and seekable when calling this method.  The
-        ///   stream is left open when the reading is completed.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using this overload, the stream is read using the default
-        ///   <c>System.Text.Encoding</c>, which is the <c>IBM437</c>
-        ///   codepage. If you want to specify the encoding to use when
-        ///   reading the zipfile content, see
-        ///   <see cref="ZipFile.Read(Stream,
-        ///   ReadOptions)">ZipFile.Read(Stream, ReadOptions)</see>.  This
-        /// </para>
-        ///
-        /// <para>
-        ///   Reading of zip content begins at the current position in the
-        ///   stream.  This means if you have a stream that concatenates
-        ///   regular data and zip data, if you position the open, readable
-        ///   stream at the start of the zip data, you will be able to read
-        ///   the zip archive using this constructor, or any of the ZipFile
-        ///   constructors that accept a <see cref="System.IO.Stream" /> as
-        ///   input. Some examples of where this might be useful: the zip
-        ///   content is concatenated at the end of a regular EXE file, as
-        ///   some self-extracting archives do.  (Note: SFX files produced
-        ///   by DotNetZip do not work this way; they can be read as normal
-        ///   ZIP files). Another example might be a stream being read from
-        ///   a database, where the zip content is embedded within an
-        ///   aggregate stream of data.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example shows how to Read zip content from a stream, and
-        ///   extract one entry into a different stream. In this example,
-        ///   the filename "NameOfEntryInArchive.doc", refers only to the
-        ///   name of the entry within the zip archive.  A file by that
-        ///   name is not created in the filesystem.  The I/O is done
-        ///   strictly with the given streams.
-        /// </para>
-        ///
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(InputStream))
-        /// {
-        ///    zip.Extract("NameOfEntryInArchive.doc", OutputStream);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip as ZipFile = ZipFile.Read(InputStream)
-        ///    zip.Extract("NameOfEntryInArchive.doc", OutputStream)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="zipStream">the stream containing the zip data.</param>
-        ///
-        /// <returns>The ZipFile instance read from the stream</returns>
-        ///
-        public static ZipFile Read(Stream zipStream)
-        {
-            return Read(zipStream, null, null, null);
-        }
-
-        /// <summary>
-        ///   Reads a zip file archive from the given stream using the
-        ///   specified options.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When reading from a file, it's probably easier to just use
-        ///   <see cref="ZipFile.Read(String,
-        ///   ReadOptions)">ZipFile.Read(String, ReadOptions)</see>.  This
-        ///   overload is useful when when the zip archive content is
-        ///   available from an already-open stream. The stream must be
-        ///   open and readable and seekable when calling this method.  The
-        ///   stream is left open when the reading is completed.
-        /// </para>
-        ///
-        /// <para>
-        ///   Reading of zip content begins at the current position in the
-        ///   stream.  This means if you have a stream that concatenates
-        ///   regular data and zip data, if you position the open, readable
-        ///   stream at the start of the zip data, you will be able to read
-        ///   the zip archive using this constructor, or any of the ZipFile
-        ///   constructors that accept a <see cref="System.IO.Stream" /> as
-        ///   input. Some examples of where this might be useful: the zip
-        ///   content is concatenated at the end of a regular EXE file, as
-        ///   some self-extracting archives do.  (Note: SFX files produced
-        ///   by DotNetZip do not work this way; they can be read as normal
-        ///   ZIP files). Another example might be a stream being read from
-        ///   a database, where the zip content is embedded within an
-        ///   aggregate stream of data.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="zipStream">the stream containing the zip data.</param>
-        ///
-        /// <param name="options">
-        ///   The set of options to use when reading the zip file.
-        /// </param>
-        ///
-        /// <exception cref="System.Exception">
-        ///   Thrown if the zip archive cannot be read.
-        /// </exception>
-        ///
-        /// <returns>The ZipFile instance read from the stream.</returns>
-        ///
-        /// <seealso cref="ZipFile.Read(String, ReadOptions)"/>
-        ///
-        internal static ZipFile Read(Stream zipStream, ReadOptions options)
-        {
-            if (options == null)
-                throw new ArgumentNullException("options");
-
-            return Read(zipStream,
-                        options.StatusMessageWriter,
-                        options.Encoding,
-                        options.ReadProgress);
-        }
-
-
-
-        /// <summary>
-        /// Reads a zip archive from a stream, using the specified text Encoding, the
-        /// specified TextWriter for status messages,
-        /// and the specified ReadProgress event handler.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// Reading of zip content begins at the current position in the stream.  This
-        /// means if you have a stream that concatenates regular data and zip data, if
-        /// you position the open, readable stream at the start of the zip data, you
-        /// will be able to read the zip archive using this constructor, or any of the
-        /// ZipFile constructors that accept a <see cref="System.IO.Stream" /> as
-        /// input. Some examples of where this might be useful: the zip content is
-        /// concatenated at the end of a regular EXE file, as some self-extracting
-        /// archives do.  (Note: SFX files produced by DotNetZip do not work this
-        /// way). Another example might be a stream being read from a database, where
-        /// the zip content is embedded within an aggregate stream of data.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="zipStream">the stream containing the zip data.</param>
-        ///
-        /// <param name="statusMessageWriter">
-        /// The <c>System.IO.TextWriter</c> to which verbose status messages are written
-        /// during operations on the <c>ZipFile</c>.  For example, in a console
-        /// application, System.Console.Out works, and will get a message for each entry
-        /// added to the ZipFile.  If the TextWriter is <c>null</c>, no verbose messages
-        /// are written.
-        /// </param>
-        ///
-        /// <param name="encoding">
-        /// The text encoding to use when reading entries that do not have the UTF-8
-        /// encoding bit set.  Be careful specifying the encoding.  If the value you use
-        /// here is not the same as the Encoding used when the zip archive was created
-        /// (possibly by a different archiver) you will get unexpected results and
-        /// possibly exceptions.  See the <see cref="ProvisionalAlternateEncoding"/>
-        /// property for more information.
-        /// </param>
-        ///
-        /// <param name="readProgress">
-        /// An event handler for Read operations.
-        /// </param>
-        ///
-        /// <returns>an instance of ZipFile</returns>
-        private static ZipFile Read(Stream zipStream,
-                                   TextWriter statusMessageWriter,
-                                   System.Text.Encoding encoding,
-                                   EventHandler<ReadProgressEventArgs> readProgress)
-        {
-            if (zipStream == null)
-                throw new ArgumentNullException("zipStream");
-
-            ZipFile zf = new ZipFile();
-            zf._StatusMessageTextWriter = statusMessageWriter;
-            zf._alternateEncoding = encoding ?? ZipFile.DefaultEncoding;
-            zf._alternateEncodingUsage = ZipOption.Always;
-            if (readProgress != null)
-                zf.ReadProgress += readProgress;
-            zf._readstream = (zipStream.Position == 0L)
-                ? zipStream
-                : new OffsetStream(zipStream);
-            zf._ReadStreamIsOurs = false;
-            if (zf.Verbose) zf._StatusMessageTextWriter.WriteLine("reading from stream...");
-
-            ReadIntoInstance(zf);
-            return zf;
-        }
-
-
-
-        private static void ReadIntoInstance(ZipFile zf)
-        {
-            Stream s = zf.ReadStream;
-            try
-            {
-                zf._readName = zf._name; // workitem 13915
-                if (!s.CanSeek)
-                {
-                    ReadIntoInstance_Orig(zf);
-                    return;
-                }
-
-                zf.OnReadStarted();
-
-                // change for workitem 8098
-                //zf._originPosition = s.Position;
-
-                // Try reading the central directory, rather than scanning the file.
-
-                uint datum = ReadFirstFourBytes(s);
-
-                if (datum == ZipConstants.EndOfCentralDirectorySignature)
-                    return;
-
-
-                // start at the end of the file...
-                // seek backwards a bit, then look for the EoCD signature.
-                int nTries = 0;
-                bool success = false;
-
-                // The size of the end-of-central-directory-footer plus 2 bytes is 18.
-                // This implies an archive comment length of 0.  We'll add a margin of
-                // safety and start "in front" of that, when looking for the
-                // EndOfCentralDirectorySignature
-                long posn = s.Length - 64;
-                long maxSeekback = Math.Max(s.Length - 0x4000, 10);
-                do
-                {
-                    if (posn < 0) posn = 0;  // BOF
-                    s.Seek(posn, SeekOrigin.Begin);
-                    long bytesRead = SharedUtilities.FindSignature(s, (int)ZipConstants.EndOfCentralDirectorySignature);
-                    if (bytesRead != -1)
-                        success = true;
-                    else
-                    {
-                        if (posn==0) break; // started at the BOF and found nothing
-                        nTries++;
-                        // Weird: with NETCF, negative offsets from SeekOrigin.End DO
-                        // NOT WORK. So rather than seek a negative offset, we seek
-                        // from SeekOrigin.Begin using a smaller number.
-                        posn -= (32 * (nTries + 1) * nTries);
-                    }
-                }
-                while (!success && posn > maxSeekback);
-
-                if (success)
-                {
-                    // workitem 8299
-                    zf._locEndOfCDS = s.Position - 4;
-
-                    byte[] block = new byte[16];
-                    s.Read(block, 0, block.Length);
-
-                    zf._diskNumberWithCd = BitConverter.ToUInt16(block, 2);
-
-                    if (zf._diskNumberWithCd == 0xFFFF)
-                        throw new ZipException("Spanned archives with more than 65534 segments are not supported at this time.");
-
-                    zf._diskNumberWithCd++; // I think the number in the file differs from reality by 1
-
-                    int i = 12;
-
-                    uint offset32 = (uint) BitConverter.ToUInt32(block, i);
-                    if (offset32 == 0xFFFFFFFF)
-                    {
-                        Zip64SeekToCentralDirectory(zf);
-                    }
-                    else
-                    {
-                        zf._OffsetOfCentralDirectory = offset32;
-                        // change for workitem 8098
-                        s.Seek(offset32, SeekOrigin.Begin);
-                    }
-
-                    ReadCentralDirectory(zf);
-                }
-                else
-                {
-                    // Could not find the central directory.
-                    // Fallback to the old method.
-                    // workitem 8098: ok
-                    //s.Seek(zf._originPosition, SeekOrigin.Begin);
-                    s.Seek(0L, SeekOrigin.Begin);
-                    ReadIntoInstance_Orig(zf);
-                }
-            }
-            catch (Exception ex1)
-            {
-                if (zf._ReadStreamIsOurs && zf._readstream != null)
-                {
-                    try
-                    {
-#if NETCF
-                        zf._readstream.Close();
-#else
-                        zf._readstream.Dispose();
-#endif
-                        zf._readstream = null;
-                    }
-                    finally { }
-                }
-
-                throw new ZipException("Cannot read that as a ZipFile", ex1);
-            }
-
-            // the instance has been read in
-            zf._contentsChanged = false;
-        }
-
-
-
-        private static void Zip64SeekToCentralDirectory(ZipFile zf)
-        {
-            Stream s = zf.ReadStream;
-            byte[] block = new byte[16];
-
-            // seek back to find the ZIP64 EoCD.
-            // I think this might not work for .NET CF ?
-            s.Seek(-40, SeekOrigin.Current);
-            s.Read(block, 0, 16);
-
-            Int64 offset64 = BitConverter.ToInt64(block, 8);
-            zf._OffsetOfCentralDirectory = 0xFFFFFFFF;
-            zf._OffsetOfCentralDirectory64 = offset64;
-            // change for workitem 8098
-            s.Seek(offset64, SeekOrigin.Begin);
-            //zf.SeekFromOrigin(Offset64);
-
-            uint datum = (uint)Ionic.Zip.SharedUtilities.ReadInt(s);
-            if (datum != ZipConstants.Zip64EndOfCentralDirectoryRecordSignature)
-                throw new BadReadException(String.Format("  Bad signature (0x{0:X8}) looking for ZIP64 EoCD Record at position 0x{1:X8}", datum, s.Position));
-
-            s.Read(block, 0, 8);
-            Int64 Size = BitConverter.ToInt64(block, 0);
-
-            block = new byte[Size];
-            s.Read(block, 0, block.Length);
-
-            offset64 = BitConverter.ToInt64(block, 36);
-            // change for workitem 8098
-            s.Seek(offset64, SeekOrigin.Begin);
-            //zf.SeekFromOrigin(Offset64);
-        }
-
-
-        private static uint ReadFirstFourBytes(Stream s)
-        {
-            uint datum = (uint)Ionic.Zip.SharedUtilities.ReadInt(s);
-            return datum;
-        }
-
-
-
-        private static void ReadCentralDirectory(ZipFile zf)
-        {
-            // We must have the central directory footer record, in order to properly
-            // read zip dir entries from the central directory.  This because the logic
-            // knows when to open a spanned file when the volume number for the central
-            // directory differs from the volume number for the zip entry.  The
-            // _diskNumberWithCd was set when originally finding the offset for the
-            // start of the Central Directory.
-
-            // workitem 9214
-            bool inputUsesZip64 = false;
-            ZipEntry de;
-            // in lieu of hashset, use a dictionary
-            var previouslySeen = new Dictionary<String,object>();
-            while ((de = ZipEntry.ReadDirEntry(zf, previouslySeen)) != null)
-            {
-                de.ResetDirEntry();
-                zf.OnReadEntry(true, null);
-
-                if (zf.Verbose)
-                    zf.StatusMessageTextWriter.WriteLine("entry {0}", de.FileName);
-
-                zf._entries.Add(de.FileName,de);
-
-                // workitem 9214
-                if (de._InputUsesZip64) inputUsesZip64 = true;
-                previouslySeen.Add(de.FileName, null); // to prevent dupes
-            }
-
-            // workitem 9214; auto-set the zip64 flag
-            if (inputUsesZip64) zf.UseZip64WhenSaving = Zip64Option.Always;
-
-            // workitem 8299
-            if (zf._locEndOfCDS > 0)
-                zf.ReadStream.Seek(zf._locEndOfCDS, SeekOrigin.Begin);
-
-            ReadCentralDirectoryFooter(zf);
-
-            if (zf.Verbose && !String.IsNullOrEmpty(zf.Comment))
-                zf.StatusMessageTextWriter.WriteLine("Zip file Comment: {0}", zf.Comment);
-
-            // We keep the read stream open after reading.
-
-            if (zf.Verbose)
-                zf.StatusMessageTextWriter.WriteLine("read in {0} entries.", zf._entries.Count);
-
-            zf.OnReadCompleted();
-        }
-
-
-
-
-        // build the TOC by reading each entry in the file.
-        private static void ReadIntoInstance_Orig(ZipFile zf)
-        {
-            zf.OnReadStarted();
-            //zf._entries = new System.Collections.Generic.List<ZipEntry>();
-            zf._entries = new System.Collections.Generic.Dictionary<String,ZipEntry>();
-
-            ZipEntry e;
-            if (zf.Verbose)
-                if (zf.Name == null)
-                    zf.StatusMessageTextWriter.WriteLine("Reading zip from stream...");
-                else
-                    zf.StatusMessageTextWriter.WriteLine("Reading zip {0}...", zf.Name);
-
-            // work item 6647:  PK00 (packed to removable disk)
-            bool firstEntry = true;
-            ZipContainer zc = new ZipContainer(zf);
-            while ((e = ZipEntry.ReadEntry(zc, firstEntry)) != null)
-            {
-                if (zf.Verbose)
-                    zf.StatusMessageTextWriter.WriteLine("  {0}", e.FileName);
-
-                zf._entries.Add(e.FileName,e);
-                firstEntry = false;
-            }
-
-            // read the zipfile's central directory structure here.
-            // workitem 9912
-            // But, because it may be corrupted, ignore errors.
-            try
-            {
-                ZipEntry de;
-                // in lieu of hashset, use a dictionary
-                var previouslySeen = new Dictionary<String,Object>();
-                while ((de = ZipEntry.ReadDirEntry(zf, previouslySeen)) != null)
-                {
-                    // Housekeeping: Since ZipFile exposes ZipEntry elements in the enumerator,
-                    // we need to copy the comment that we grab from the ZipDirEntry
-                    // into the ZipEntry, so the application can access the comment.
-                    // Also since ZipEntry is used to Write zip files, we need to copy the
-                    // file attributes to the ZipEntry as appropriate.
-                    ZipEntry e1 = zf._entries[de.FileName];
-                    if (e1 != null)
-                    {
-                        e1._Comment = de.Comment;
-                        if (de.IsDirectory) e1.MarkAsDirectory();
-                    }
-                    previouslySeen.Add(de.FileName,null); // to prevent dupes
-                }
-
-                // workitem 8299
-                if (zf._locEndOfCDS > 0)
-                    zf.ReadStream.Seek(zf._locEndOfCDS, SeekOrigin.Begin);
-
-                ReadCentralDirectoryFooter(zf);
-
-                if (zf.Verbose && !String.IsNullOrEmpty(zf.Comment))
-                    zf.StatusMessageTextWriter.WriteLine("Zip file Comment: {0}", zf.Comment);
-            }
-            catch (ZipException) { }
-            catch (IOException) { }
-
-            zf.OnReadCompleted();
-        }
-
-
-
-
-        private static void ReadCentralDirectoryFooter(ZipFile zf)
-        {
-            Stream s = zf.ReadStream;
-            int signature = Ionic.Zip.SharedUtilities.ReadSignature(s);
-
-            byte[] block = null;
-            int j = 0;
-            if (signature == ZipConstants.Zip64EndOfCentralDirectoryRecordSignature)
-            {
-                // We have a ZIP64 EOCD
-                // This data block is 4 bytes sig, 8 bytes size, 44 bytes fixed data,
-                // followed by a variable-sized extension block.  We have read the sig already.
-                // 8 - datasize (64 bits)
-                // 2 - version made by
-                // 2 - version needed to extract
-                // 4 - number of this disk
-                // 4 - number of the disk with the start of the CD
-                // 8 - total number of entries in the CD on this disk
-                // 8 - total number of entries in the CD
-                // 8 - size of the CD
-                // 8 - offset of the CD
-                // -----------------------
-                // 52 bytes
-
-                block = new byte[8 + 44];
-                s.Read(block, 0, block.Length);
-
-                Int64 DataSize = BitConverter.ToInt64(block, 0);  // == 44 + the variable length
-
-                if (DataSize < 44)
-                    throw new ZipException("Bad size in the ZIP64 Central Directory.");
-
-                zf._versionMadeBy = BitConverter.ToUInt16(block, j);
-                j += 2;
-                zf._versionNeededToExtract = BitConverter.ToUInt16(block, j);
-                j += 2;
-                zf._diskNumberWithCd = BitConverter.ToUInt32(block, j);
-                j += 2;
-
-                //zf._diskNumberWithCd++; // hack!!
-
-                // read the extended block
-                block = new byte[DataSize - 44];
-                s.Read(block, 0, block.Length);
-                // discard the result
-
-                signature = Ionic.Zip.SharedUtilities.ReadSignature(s);
-                if (signature != ZipConstants.Zip64EndOfCentralDirectoryLocatorSignature)
-                    throw new ZipException("Inconsistent metadata in the ZIP64 Central Directory.");
-
-                block = new byte[16];
-                s.Read(block, 0, block.Length);
-                // discard the result
-
-                signature = Ionic.Zip.SharedUtilities.ReadSignature(s);
-            }
-
-            // Throw if this is not a signature for "end of central directory record"
-            // This is a sanity check.
-            if (signature != ZipConstants.EndOfCentralDirectorySignature)
-            {
-                s.Seek(-4, SeekOrigin.Current);
-                throw new BadReadException(String.Format("Bad signature ({0:X8}) at position 0x{1:X8}",
-                                                         signature, s.Position));
-            }
-
-            // read the End-of-Central-Directory-Record
-            block = new byte[16];
-            zf.ReadStream.Read(block, 0, block.Length);
-
-            // off sz  data
-            // -------------------------------------------------------
-            //  0   4  end of central dir signature (0x06054b50)
-            //  4   2  number of this disk
-            //  6   2  number of the disk with start of the central directory
-            //  8   2  total number of entries in the  central directory on this disk
-            // 10   2  total number of entries in  the central directory
-            // 12   4  size of the central directory
-            // 16   4  offset of start of central directory with respect to the starting disk number
-            // 20   2  ZIP file comment length
-            // 22  ??  ZIP file comment
-
-            if (zf._diskNumberWithCd == 0)
-            {
-                zf._diskNumberWithCd = BitConverter.ToUInt16(block, 2);
-                //zf._diskNumberWithCd++; // hack!!
-            }
-
-            // read the comment here
-            ReadZipFileComment(zf);
-        }
-
-
-
-        private static void ReadZipFileComment(ZipFile zf)
-        {
-            // read the comment here
-            byte[] block = new byte[2];
-            zf.ReadStream.Read(block, 0, block.Length);
-
-            Int16 commentLength = (short)(block[0] + block[1] * 256);
-            if (commentLength > 0)
-            {
-                block = new byte[commentLength];
-                zf.ReadStream.Read(block, 0, block.Length);
-
-                // workitem 10392 - prefer ProvisionalAlternateEncoding,
-                // first.  The fix for workitem 6513 tried to use UTF8
-                // only as necessary, but that is impossible to test
-                // for, in this direction. There's no way to know what
-                // characters the already-encoded bytes refer
-                // to. Therefore, must do what the user tells us.
-
-                string s1 = zf.AlternateEncoding.GetString(block, 0, block.Length);
-                zf.Comment = s1;
-            }
-        }
-
-
-        // private static bool BlocksAreEqual(byte[] a, byte[] b)
-        // {
-        //     if (a.Length != b.Length) return false;
-        //     for (int i = 0; i < a.Length; i++)
-        //     {
-        //         if (a[i] != b[i]) return false;
-        //     }
-        //     return true;
-        // }
-
-
-
-        /// <summary>
-        /// Checks the given file to see if it appears to be a valid zip file.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   Calling this method is equivalent to calling <see cref="IsZipFile(string,
-        ///   bool)"/> with the testExtract parameter set to false.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="fileName">The file to check.</param>
-        /// <returns>true if the file appears to be a zip file.</returns>
-        public static bool IsZipFile(string fileName)
-        {
-            return IsZipFile(fileName, false);
-        }
-
-
-        /// <summary>
-        /// Checks a file to see if it is a valid zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method opens the specified zip file, reads in the zip archive,
-        ///   verifying the ZIP metadata as it reads.
-        /// </para>
-        ///
-        /// <para>
-        ///   If everything succeeds, then the method returns true.  If anything fails -
-        ///   for example if an incorrect signature or CRC is found, indicating a
-        ///   corrupt file, the the method returns false.  This method also returns
-        ///   false for a file that does not exist.
-        /// </para>
-        ///
-        /// <para>
-        ///   If <paramref name="testExtract"/> is true, as part of its check, this
-        ///   method reads in the content for each entry, expands it, and checks CRCs.
-        ///   This provides an additional check beyond verifying the zip header and
-        ///   directory data.
-        /// </para>
-        ///
-        /// <para>
-        ///   If <paramref name="testExtract"/> is true, and if any of the zip entries
-        ///   are protected with a password, this method will return false.  If you want
-        ///   to verify a <c>ZipFile</c> that has entries which are protected with a
-        ///   password, you will need to do that manually.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="fileName">The zip file to check.</param>
-        /// <param name="testExtract">true if the caller wants to extract each entry.</param>
-        /// <returns>true if the file contains a valid zip file.</returns>
-        public static bool IsZipFile(string fileName, bool testExtract)
-        {
-            bool result = false;
-            try
-            {
-                if (!File.Exists(fileName)) return false;
-
-                using (var s = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
-                {
-                    result = IsZipFile(s, testExtract);
-                }
-            }
-            catch (IOException) { }
-            catch (ZipException) { }
-            return result;
-        }
-
-
-        /// <summary>
-        /// Checks a stream to see if it contains a valid zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method reads the zip archive contained in the specified stream, verifying
-        /// the ZIP metadata as it reads.  If testExtract is true, this method also extracts
-        /// each entry in the archive, dumping all the bits into <see cref="Stream.Null"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// If everything succeeds, then the method returns true.  If anything fails -
-        /// for example if an incorrect signature or CRC is found, indicating a corrupt
-        /// file, the the method returns false.  This method also returns false for a
-        /// file that does not exist.
-        /// </para>
-        ///
-        /// <para>
-        /// If <c>testExtract</c> is true, this method reads in the content for each
-        /// entry, expands it, and checks CRCs.  This provides an additional check
-        /// beyond verifying the zip header data.
-        /// </para>
-        ///
-        /// <para>
-        /// If <c>testExtract</c> is true, and if any of the zip entries are protected
-        /// with a password, this method will return false.  If you want to verify a
-        /// ZipFile that has entries which are protected with a password, you will need
-        /// to do that manually.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="IsZipFile(string, bool)"/>
-        ///
-        /// <param name="stream">The stream to check.</param>
-        /// <param name="testExtract">true if the caller wants to extract each entry.</param>
-        /// <returns>true if the stream contains a valid zip archive.</returns>
-        public static bool IsZipFile(Stream stream, bool testExtract)
-        {
-            if (stream == null)
-                throw new ArgumentNullException("stream");
-
-            bool result = false;
-            try
-            {
-                if (!stream.CanRead) return false;
-
-                var bitBucket = Stream.Null;
-
-                using (ZipFile zip1 = ZipFile.Read(stream, null, null, null))
-                {
-                    if (testExtract)
-                    {
-                        foreach (var e in zip1)
-                        {
-                            if (!e.IsDirectory)
-                            {
-                                e.Extract(bitBucket);
-                            }
-                        }
-                    }
-                }
-                result = true;
-            }
-            catch (IOException) { }
-            catch (ZipException) { }
-            return result;
-        }
-
-
-
-
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Save.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Save.cs
deleted file mode 100644
index b66c5c9..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Save.cs
+++ /dev/null
@@ -1,964 +0,0 @@
-// ZipFile.Save.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-05 13:31:23>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the methods for Save operations on zip files.
-//
-// ------------------------------------------------------------------
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    internal partial class ZipFile
-    {
-
-        /// <summary>
-        ///   Delete file with retry on UnauthorizedAccessException.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     When calling File.Delete() on a file that has been "recently"
-        ///     created, the call sometimes fails with
-        ///     UnauthorizedAccessException. This method simply retries the Delete 3
-        ///     times with a sleep between tries.
-        ///   </para>
-        /// </remarks>
-        ///
-        /// <param name='filename'>the name of the file to be deleted</param>
-        private void DeleteFileWithRetry(string filename)
-        {
-            bool done = false;
-            int nRetries = 3;
-            for (int i=0; i < nRetries && !done; i++)
-            {
-                try
-                {
-                    File.Delete(filename);
-                    done = true;
-                }
-                catch (System.UnauthorizedAccessException)
-                {
-                    Console.WriteLine("************************************************** Retry delete.");
-                    System.Threading.Thread.Sleep(200+i*200);
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///   Saves the Zip archive to a file, specified by the Name property of the
-        ///   <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The <c>ZipFile</c> instance is written to storage, typically a zip file
-        ///   in a filesystem, only when the caller calls <c>Save</c>.  In the typical
-        ///   case, the Save operation writes the zip content to a temporary file, and
-        ///   then renames the temporary file to the desired name. If necessary, this
-        ///   method will delete a pre-existing file before the rename.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="ZipFile.Name"/> property is specified either explicitly,
-        ///   or implicitly using one of the parameterized ZipFile constructors.  For
-        ///   COM Automation clients, the <c>Name</c> property must be set explicitly,
-        ///   because COM Automation clients cannot call parameterized constructors.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using a filesystem file for the Zip output, it is possible to call
-        ///   <c>Save</c> multiple times on the <c>ZipFile</c> instance. With each
-        ///   call the zip content is re-written to the same output file.
-        /// </para>
-        ///
-        /// <para>
-        ///   Data for entries that have been added to the <c>ZipFile</c> instance is
-        ///   written to the output when the <c>Save</c> method is called. This means
-        ///   that the input streams for those entries must be available at the time
-        ///   the application calls <c>Save</c>.  If, for example, the application
-        ///   adds entries with <c>AddEntry</c> using a dynamically-allocated
-        ///   <c>MemoryStream</c>, the memory stream must not have been disposed
-        ///   before the call to <c>Save</c>. See the <see
-        ///   cref="ZipEntry.InputStream"/> property for more discussion of the
-        ///   availability requirements of the input stream for an entry, and an
-        ///   approach for providing just-in-time stream lifecycle management.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(String, System.IO.Stream)"/>
-        ///
-        /// <exception cref="Ionic.Zip.BadStateException">
-        ///   Thrown if you haven't specified a location or stream for saving the zip,
-        ///   either in the constructor or by setting the Name property, or if you try
-        ///   to save a regular zip archive to a filename with a .exe extension.
-        /// </exception>
-        ///
-        /// <exception cref="System.OverflowException">
-        ///   Thrown if <see cref="MaxOutputSegmentSize"/> is non-zero, and the number
-        ///   of segments that would be generated for the spanned zip file during the
-        ///   save operation exceeds 99.  If this happens, you need to increase the
-        ///   segment size.
-        /// </exception>
-        ///
-        public void Save()
-        {
-            try
-            {
-                bool thisSaveUsedZip64 = false;
-                _saveOperationCanceled = false;
-                _numberOfSegmentsForMostRecentSave = 0;
-                OnSaveStarted();
-
-                if (WriteStream == null)
-                    throw new BadStateException("You haven't specified where to save the zip.");
-
-                if (_name != null && _name.EndsWith(".exe") && !_SavingSfx)
-                    throw new BadStateException("You specified an EXE for a plain zip file.");
-
-                // check if modified, before saving.
-                if (!_contentsChanged)
-                {
-                    OnSaveCompleted();
-                    if (Verbose) StatusMessageTextWriter.WriteLine("No save is necessary....");
-                    return;
-                }
-
-                Reset(true);
-
-                if (Verbose) StatusMessageTextWriter.WriteLine("saving....");
-
-                // validate the number of entries
-                if (_entries.Count >= 0xFFFF && _zip64 == Zip64Option.Never)
-                    throw new ZipException("The number of entries is 65535 or greater. Consider setting the UseZip64WhenSaving property on the ZipFile instance.");
-
-
-                // write an entry in the zip for each file
-                int n = 0;
-                // workitem 9831
-                ICollection<ZipEntry> c = (SortEntriesBeforeSaving) ? EntriesSorted : Entries;
-                foreach (ZipEntry e in c) // _entries.Values
-                {
-                    OnSaveEntry(n, e, true);
-                    e.Write(WriteStream);
-                    if (_saveOperationCanceled)
-                        break;
-
-                    n++;
-                    OnSaveEntry(n, e, false);
-                    if (_saveOperationCanceled)
-                        break;
-
-                    // Some entries can be skipped during the save.
-                    if (e.IncludedInMostRecentSave)
-                        thisSaveUsedZip64 |= e.OutputUsedZip64.Value;
-                }
-
-
-
-                if (_saveOperationCanceled)
-                    return;
-
-                var zss = WriteStream as ZipSegmentedStream;
-
-                _numberOfSegmentsForMostRecentSave = (zss!=null)
-                    ? zss.CurrentSegment
-                    : 1;
-
-                bool directoryNeededZip64 =
-                    ZipOutput.WriteCentralDirectoryStructure
-                    (WriteStream,
-                     c,
-                     _numberOfSegmentsForMostRecentSave,
-                     _zip64,
-                     Comment,
-                     new ZipContainer(this));
-
-                OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive);
-
-                _hasBeenSaved = true;
-                _contentsChanged = false;
-
-                thisSaveUsedZip64 |= directoryNeededZip64;
-                _OutputUsesZip64 = new Nullable<bool>(thisSaveUsedZip64);
-
-
-                // do the rename as necessary
-                if (_name != null &&
-                    (_temporaryFileName!=null || zss != null))
-                {
-                    // _temporaryFileName may remain null if we are writing to a stream.
-                    // only close the stream if there is a file behind it.
-#if NETCF
-                    WriteStream.Close();
-#else
-                    WriteStream.Dispose();
-#endif
-                    if (_saveOperationCanceled)
-                        return;
-
-                    if (_fileAlreadyExists && this._readstream != null)
-                    {
-                        // This means we opened and read a zip file.
-                        // If we are now saving to the same file, we need to close the
-                        // orig file, first.
-                        this._readstream.Close();
-                        this._readstream = null;
-                        // the archiveStream for each entry needs to be null
-                        foreach (var e in c)
-                        {
-                            var zss1 = e._archiveStream as ZipSegmentedStream;
-                            if (zss1 != null)
-#if NETCF
-                                zss1.Close();
-#else
-                                zss1.Dispose();
-#endif
-                            e._archiveStream = null;
-                        }
-                    }
-
-                    string tmpName = null;
-                    if (File.Exists(_name))
-                    {
-                        // the steps:
-                        //
-                        // 1. Delete tmpName
-                        // 2. move existing zip to tmpName
-                        // 3. rename (File.Move) working file to name of existing zip
-                        // 4. delete tmpName
-                        //
-                        // This series of steps avoids the exception,
-                        // System.IO.IOException:
-                        //   "Cannot create a file when that file already exists."
-                        //
-                        // Cannot just call File.Replace() here because
-                        // there is a possibility that the TEMP volume is different
-                        // that the volume for the final file (c:\ vs d:\).
-                        // So we need to do a Delete+Move pair.
-                        //
-                        // But, when doing the delete, Windows allows a process to
-                        // delete the file, even though it is held open by, say, a
-                        // virus scanner. It gets internally marked as "delete
-                        // pending". The file does not actually get removed from the
-                        // file system, it is still there after the File.Delete
-                        // call.
-                        //
-                        // Therefore, we need to move the existing zip, which may be
-                        // held open, to some other name. Then rename our working
-                        // file to the desired name, then delete (possibly delete
-                        // pending) the "other name".
-                        //
-                        // Ideally this would be transactional. It's possible that the
-                        // delete succeeds and the move fails. Lacking transactions, if
-                        // this kind of failure happens, we're hosed, and this logic will
-                        // throw on the next File.Move().
-                        //
-                        //File.Delete(_name);
-                        // workitem 10447
-#if NETCF || SILVERLIGHT
-                        tmpName = _name + "." + SharedUtilities.GenerateRandomStringImpl(8,0) + ".tmp";
-#else
-                        tmpName = _name + "." + Path.GetRandomFileName();
-#endif
-                        if (File.Exists(tmpName))
-                            DeleteFileWithRetry(tmpName);
-                        File.Move(_name, tmpName);
-                    }
-
-                    OnSaveEvent(ZipProgressEventType.Saving_BeforeRenameTempArchive);
-                    File.Move((zss != null) ? zss.CurrentTempName : _temporaryFileName,
-                              _name);
-
-                    OnSaveEvent(ZipProgressEventType.Saving_AfterRenameTempArchive);
-
-                    if (tmpName != null)
-                    {
-                        try
-                        {
-                            // not critical
-                            if (File.Exists(tmpName))
-                                File.Delete(tmpName);
-                        }
-                        catch
-                        {
-                            // don't care about exceptions here.
-                        }
-
-                    }
-                    _fileAlreadyExists = true;
-                }
-
-                NotifyEntriesSaveComplete(c);
-                OnSaveCompleted();
-                _JustSaved = true;
-            }
-
-            // workitem 5043
-            finally
-            {
-                CleanupAfterSaveOperation();
-            }
-
-            return;
-        }
-
-
-
-        private static void NotifyEntriesSaveComplete(ICollection<ZipEntry> c)
-        {
-            foreach (ZipEntry e in  c)
-            {
-                e.NotifySaveComplete();
-            }
-        }
-
-
-        private void RemoveTempFile()
-        {
-            try
-            {
-                if (File.Exists(_temporaryFileName))
-                {
-                    File.Delete(_temporaryFileName);
-                }
-            }
-            catch (IOException ex1)
-            {
-                if (Verbose)
-                    StatusMessageTextWriter.WriteLine("ZipFile::Save: could not delete temp file: {0}.", ex1.Message);
-            }
-        }
-
-
-        private void CleanupAfterSaveOperation()
-        {
-            if (_name != null)
-            {
-                // close the stream if there is a file behind it.
-                if (_writestream != null)
-                {
-                    try
-                    {
-                        // workitem 7704
-#if NETCF
-                        _writestream.Close();
-#else
-                        _writestream.Dispose();
-#endif
-                    }
-                    catch (System.IO.IOException) { }
-                }
-                _writestream = null;
-
-                if (_temporaryFileName != null)
-                {
-                    RemoveTempFile();
-                    _temporaryFileName = null;
-                }
-            }
-        }
-
-
-        /// <summary>
-        /// Save the file to a new zipfile, with the given name.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method allows the application to explicitly specify the name of the zip
-        /// file when saving. Use this when creating a new zip file, or when
-        /// updating a zip archive.
-        /// </para>
-        ///
-        /// <para>
-        /// An application can also save a zip archive in several places by calling this
-        /// method multiple times in succession, with different filenames.
-        /// </para>
-        ///
-        /// <para>
-        /// The <c>ZipFile</c> instance is written to storage, typically a zip file in a
-        /// filesystem, only when the caller calls <c>Save</c>.  The Save operation writes
-        /// the zip content to a temporary file, and then renames the temporary file
-        /// to the desired name. If necessary, this method will delete a pre-existing file
-        /// before the rename.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="System.ArgumentException">
-        /// Thrown if you specify a directory for the filename.
-        /// </exception>
-        ///
-        /// <param name="fileName">
-        /// The name of the zip archive to save to. Existing files will
-        /// be overwritten with great prejudice.
-        /// </param>
-        ///
-        /// <example>
-        /// This example shows how to create and Save a zip file.
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///   zip.AddDirectory(@"c:\reports\January");
-        ///   zip.Save("January.zip");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile()
-        ///   zip.AddDirectory("c:\reports\January")
-        ///   zip.Save("January.zip")
-        /// End Using
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <example>
-        /// This example shows how to update a zip file.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read("ExistingArchive.zip"))
-        /// {
-        ///   zip.AddFile("NewData.csv");
-        ///   zip.Save("UpdatedArchive.zip");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read("ExistingArchive.zip")
-        ///   zip.AddFile("NewData.csv")
-        ///   zip.Save("UpdatedArchive.zip")
-        /// End Using
-        /// </code>
-        ///
-        /// </example>
-        public void Save(String fileName)
-        {
-            // Check for the case where we are re-saving a zip archive
-            // that was originally instantiated with a stream.  In that case,
-            // the _name will be null. If so, we set _writestream to null,
-            // which insures that we'll cons up a new WriteStream (with a filesystem
-            // file backing it) in the Save() method.
-            if (_name == null)
-                _writestream = null;
-
-            else _readName = _name; // workitem 13915
-
-            _name = fileName;
-            if (Directory.Exists(_name))
-                throw new ZipException("Bad Directory", new System.ArgumentException("That name specifies an existing directory. Please specify a filename.", "fileName"));
-            _contentsChanged = true;
-            _fileAlreadyExists = File.Exists(_name);
-            Save();
-        }
-
-
-        /// <summary>
-        ///   Save the zip archive to the specified stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The <c>ZipFile</c> instance is written to storage - typically a zip file
-        ///   in a filesystem, but using this overload, the storage can be anything
-        ///   accessible via a writable stream - only when the caller calls <c>Save</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Use this method to save the zip content to a stream directly.  A common
-        ///   scenario is an ASP.NET application that dynamically generates a zip file
-        ///   and allows the browser to download it. The application can call
-        ///   <c>Save(Response.OutputStream)</c> to write a zipfile directly to the
-        ///   output stream, without creating a zip file on the disk on the ASP.NET
-        ///   server.
-        /// </para>
-        ///
-        /// <para>
-        ///   Be careful when saving a file to a non-seekable stream, including
-        ///   <c>Response.OutputStream</c>. When DotNetZip writes to a non-seekable
-        ///   stream, the zip archive is formatted in such a way that may not be
-        ///   compatible with all zip tools on all platforms.  It's a perfectly legal
-        ///   and compliant zip file, but some people have reported problems opening
-        ///   files produced this way using the Mac OS archive utility.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example saves the zipfile content into a MemoryStream, and
-        ///   then gets the array of bytes from that MemoryStream.
-        ///
-        /// <code lang="C#">
-        /// using (var zip = new Ionic.Zip.ZipFile())
-        /// {
-        ///     zip.CompressionLevel= Ionic.Zlib.CompressionLevel.BestCompression;
-        ///     zip.Password = "VerySecret.";
-        ///     zip.Encryption = EncryptionAlgorithm.WinZipAes128;
-        ///     zip.AddFile(sourceFileName);
-        ///     MemoryStream output = new MemoryStream();
-        ///     zip.Save(output);
-        ///
-        ///     byte[] zipbytes = output.ToArray();
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example shows a pitfall you should avoid. DO NOT read
-        ///   from a stream, then try to save to the same stream.  DO
-        ///   NOT DO THIS:
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// using (var fs = new FileSteeam(filename, FileMode.Open))
-        /// {
-        ///   using (var zip = Ionic.Zip.ZipFile.Read(inputStream))
-        ///   {
-        ///     zip.AddEntry("Name1.txt", "this is the content");
-        ///     zip.Save(inputStream);  // NO NO NO!!
-        ///   }
-        /// }
-        /// </code>
-        ///
-        /// <para>
-        ///   Better like this:
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// using (var zip = Ionic.Zip.ZipFile.Read(filename))
-        /// {
-        ///     zip.AddEntry("Name1.txt", "this is the content");
-        ///     zip.Save();  // YES!
-        /// }
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <param name="outputStream">
-        ///   The <c>System.IO.Stream</c> to write to. It must be
-        ///   writable. If you created the ZipFile instanct by calling
-        ///   ZipFile.Read(), this stream must not be the same stream
-        ///   you passed to ZipFile.Read().
-        /// </param>
-        public void Save(Stream outputStream)
-        {
-            if (outputStream == null)
-                throw new ArgumentNullException("outputStream");
-            if (!outputStream.CanWrite)
-                throw new ArgumentException("Must be a writable stream.", "outputStream");
-
-            // if we had a filename to save to, we are now obliterating it.
-            _name = null;
-
-            _writestream = new CountingStream(outputStream);
-
-            _contentsChanged = true;
-            _fileAlreadyExists = false;
-            Save();
-        }
-
-
-    }
-
-
-
-    internal static class ZipOutput
-    {
-        public static bool WriteCentralDirectoryStructure(Stream s,
-                                                          ICollection<ZipEntry> entries,
-                                                          uint numSegments,
-                                                          Zip64Option zip64,
-                                                          String comment,
-                                                          ZipContainer container)
-        {
-            var zss = s as ZipSegmentedStream;
-            if (zss != null)
-                zss.ContiguousWrite = true;
-
-            // write to a memory stream in order to keep the
-            // CDR contiguous
-            Int64 aLength = 0;
-            using (var ms = new MemoryStream())
-            {
-                foreach (ZipEntry e in entries)
-                {
-                    if (e.IncludedInMostRecentSave)
-                    {
-                        // this writes a ZipDirEntry corresponding to the ZipEntry
-                        e.WriteCentralDirectoryEntry(ms);
-                    }
-                }
-                var a = ms.ToArray();
-                s.Write(a, 0, a.Length);
-                aLength = a.Length;
-            }
-
-
-            // We need to keep track of the start and
-            // Finish of the Central Directory Structure.
-
-            // Cannot always use WriteStream.Length or Position; some streams do
-            // not support these. (eg, ASP.NET Response.OutputStream) In those
-            // cases we have a CountingStream.
-
-            // Also, we cannot just set Start as s.Position bfore the write, and Finish
-            // as s.Position after the write.  In a split zip, the write may actually
-            // flip to the next segment.  In that case, Start will be zero.  But we
-            // don't know that til after we know the size of the thing to write.  So the
-            // answer is to compute the directory, then ask the ZipSegmentedStream which
-            // segment that directory would fall in, it it were written.  Then, include
-            // that data into the directory, and finally, write the directory to the
-            // output stream.
-
-            var output = s as CountingStream;
-            long Finish = (output != null) ? output.ComputedPosition : s.Position;  // BytesWritten
-            long Start = Finish - aLength;
-
-            // need to know which segment the EOCD record starts in
-            UInt32 startSegment = (zss != null)
-                ? zss.CurrentSegment
-                : 0;
-
-            Int64 SizeOfCentralDirectory = Finish - Start;
-
-            int countOfEntries = CountEntries(entries);
-
-            bool needZip64CentralDirectory =
-                zip64 == Zip64Option.Always ||
-                countOfEntries >= 0xFFFF ||
-                SizeOfCentralDirectory > 0xFFFFFFFF ||
-                Start > 0xFFFFFFFF;
-
-            byte[] a2 = null;
-
-            // emit ZIP64 extensions as required
-            if (needZip64CentralDirectory)
-            {
-                if (zip64 == Zip64Option.Never)
-                {
-#if NETCF
-                    throw new ZipException("The archive requires a ZIP64 Central Directory. Consider enabling ZIP64 extensions.");
-#else
-                    System.Diagnostics.StackFrame sf = new System.Diagnostics.StackFrame(1);
-                    if (sf.GetMethod().DeclaringType == typeof(ZipFile))
-                        throw new ZipException("The archive requires a ZIP64 Central Directory. Consider setting the ZipFile.UseZip64WhenSaving property.");
-                    else
-                        throw new ZipException("The archive requires a ZIP64 Central Directory. Consider setting the ZipOutputStream.EnableZip64 property.");
-#endif
-
-                }
-
-                var a = GenZip64EndOfCentralDirectory(Start, Finish, countOfEntries, numSegments);
-                a2 = GenCentralDirectoryFooter(Start, Finish, zip64, countOfEntries, comment, container);
-                if (startSegment != 0)
-                {
-                    UInt32 thisSegment = zss.ComputeSegment(a.Length + a2.Length);
-                    int i = 16;
-                    // number of this disk
-                    Array.Copy(BitConverter.GetBytes(thisSegment), 0, a, i, 4);
-                    i += 4;
-                    // number of the disk with the start of the central directory
-                    //Array.Copy(BitConverter.GetBytes(startSegment), 0, a, i, 4);
-                    Array.Copy(BitConverter.GetBytes(thisSegment), 0, a, i, 4);
-
-                    i = 60;
-                    // offset 60
-                    // number of the disk with the start of the zip64 eocd
-                    Array.Copy(BitConverter.GetBytes(thisSegment), 0, a, i, 4);
-                    i += 4;
-                    i += 8;
-
-                    // offset 72
-                    // total number of disks
-                    Array.Copy(BitConverter.GetBytes(thisSegment), 0, a, i, 4);
-                }
-                s.Write(a, 0, a.Length);
-            }
-            else
-                a2 = GenCentralDirectoryFooter(Start, Finish, zip64, countOfEntries, comment, container);
-
-
-            // now, the regular footer
-            if (startSegment != 0)
-            {
-                // The assumption is the central directory is never split across
-                // segment boundaries.
-
-                UInt16 thisSegment = (UInt16) zss.ComputeSegment(a2.Length);
-                int i = 4;
-                // number of this disk
-                Array.Copy(BitConverter.GetBytes(thisSegment), 0, a2, i, 2);
-                i += 2;
-                // number of the disk with the start of the central directory
-                //Array.Copy(BitConverter.GetBytes((UInt16)startSegment), 0, a2, i, 2);
-                Array.Copy(BitConverter.GetBytes(thisSegment), 0, a2, i, 2);
-                i += 2;
-            }
-
-            s.Write(a2, 0, a2.Length);
-
-            // reset the contiguous write property if necessary
-            if (zss != null)
-                zss.ContiguousWrite = false;
-
-            return needZip64CentralDirectory;
-        }
-
-
-        private static System.Text.Encoding GetEncoding(ZipContainer container, string t)
-        {
-            switch (container.AlternateEncodingUsage)
-            {
-                case ZipOption.Always:
-                    return container.AlternateEncoding;
-                case ZipOption.Never:
-                    return container.DefaultEncoding;
-            }
-
-            // AsNecessary is in force
-            var e = container.DefaultEncoding;
-            if (t == null) return e;
-
-            var bytes = e.GetBytes(t);
-            var t2 = e.GetString(bytes,0,bytes.Length);
-            if (t2.Equals(t)) return e;
-            return container.AlternateEncoding;
-        }
-
-
-
-        private static byte[] GenCentralDirectoryFooter(long StartOfCentralDirectory,
-                                                        long EndOfCentralDirectory,
-                                                        Zip64Option zip64,
-                                                        int entryCount,
-                                                        string comment,
-                                                        ZipContainer container)
-        {
-            System.Text.Encoding encoding = GetEncoding(container, comment);
-            int j = 0;
-            int bufferLength = 22;
-            byte[] block = null;
-            Int16 commentLength = 0;
-            if ((comment != null) && (comment.Length != 0))
-            {
-                block = encoding.GetBytes(comment);
-                commentLength = (Int16)block.Length;
-            }
-            bufferLength += commentLength;
-            byte[] bytes = new byte[bufferLength];
-
-            int i = 0;
-            // signature
-            byte[] sig = BitConverter.GetBytes(ZipConstants.EndOfCentralDirectorySignature);
-            Array.Copy(sig, 0, bytes, i, 4);
-            i+=4;
-
-            // number of this disk
-            // (this number may change later)
-            bytes[i++] = 0;
-            bytes[i++] = 0;
-
-            // number of the disk with the start of the central directory
-            // (this number may change later)
-            bytes[i++] = 0;
-            bytes[i++] = 0;
-
-            // handle ZIP64 extensions for the end-of-central-directory
-            if (entryCount >= 0xFFFF || zip64 == Zip64Option.Always)
-            {
-                // the ZIP64 version.
-                for (j = 0; j < 4; j++)
-                    bytes[i++] = 0xFF;
-            }
-            else
-            {
-                // the standard version.
-                // total number of entries in the central dir on this disk
-                bytes[i++] = (byte)(entryCount & 0x00FF);
-                bytes[i++] = (byte)((entryCount & 0xFF00) >> 8);
-
-                // total number of entries in the central directory
-                bytes[i++] = (byte)(entryCount & 0x00FF);
-                bytes[i++] = (byte)((entryCount & 0xFF00) >> 8);
-            }
-
-            // size of the central directory
-            Int64 SizeOfCentralDirectory = EndOfCentralDirectory - StartOfCentralDirectory;
-
-            if (SizeOfCentralDirectory >= 0xFFFFFFFF || StartOfCentralDirectory >= 0xFFFFFFFF)
-            {
-                // The actual data is in the ZIP64 central directory structure
-                for (j = 0; j < 8; j++)
-                    bytes[i++] = 0xFF;
-            }
-            else
-            {
-                // size of the central directory (we just get the low 4 bytes)
-                bytes[i++] = (byte)(SizeOfCentralDirectory & 0x000000FF);
-                bytes[i++] = (byte)((SizeOfCentralDirectory & 0x0000FF00) >> 8);
-                bytes[i++] = (byte)((SizeOfCentralDirectory & 0x00FF0000) >> 16);
-                bytes[i++] = (byte)((SizeOfCentralDirectory & 0xFF000000) >> 24);
-
-                // offset of the start of the central directory (we just get the low 4 bytes)
-                bytes[i++] = (byte)(StartOfCentralDirectory & 0x000000FF);
-                bytes[i++] = (byte)((StartOfCentralDirectory & 0x0000FF00) >> 8);
-                bytes[i++] = (byte)((StartOfCentralDirectory & 0x00FF0000) >> 16);
-                bytes[i++] = (byte)((StartOfCentralDirectory & 0xFF000000) >> 24);
-            }
-
-
-            // zip archive comment
-            if ((comment == null) || (comment.Length == 0))
-            {
-                // no comment!
-                bytes[i++] = (byte)0;
-                bytes[i++] = (byte)0;
-            }
-            else
-            {
-                // the size of our buffer defines the max length of the comment we can write
-                if (commentLength + i + 2 > bytes.Length) commentLength = (Int16)(bytes.Length - i - 2);
-                bytes[i++] = (byte)(commentLength & 0x00FF);
-                bytes[i++] = (byte)((commentLength & 0xFF00) >> 8);
-
-                if (commentLength != 0)
-                {
-                    // now actually write the comment itself into the byte buffer
-                    for (j = 0; (j < commentLength) && (i + j < bytes.Length); j++)
-                    {
-                        bytes[i + j] = block[j];
-                    }
-                    i += j;
-                }
-            }
-
-            //   s.Write(bytes, 0, i);
-            return bytes;
-        }
-
-
-
-        private static byte[] GenZip64EndOfCentralDirectory(long StartOfCentralDirectory,
-                                                            long EndOfCentralDirectory,
-                                                            int entryCount,
-                                                            uint numSegments)
-        {
-            const int bufferLength = 12 + 44 + 20;
-
-            byte[] bytes = new byte[bufferLength];
-
-            int i = 0;
-            // signature
-            byte[] sig = BitConverter.GetBytes(ZipConstants.Zip64EndOfCentralDirectoryRecordSignature);
-            Array.Copy(sig, 0, bytes, i, 4);
-            i+=4;
-
-            // There is a possibility to include "Extensible" data in the zip64
-            // end-of-central-dir record.  I cannot figure out what it might be used to
-            // store, so the size of this record is always fixed.  Maybe it is used for
-            // strong encryption data?  That is for another day.
-            long DataSize = 44;
-            Array.Copy(BitConverter.GetBytes(DataSize), 0, bytes, i, 8);
-            i += 8;
-
-            // offset 12
-            // VersionMadeBy = 45;
-            bytes[i++] = 45;
-            bytes[i++] = 0x00;
-
-            // VersionNeededToExtract = 45;
-            bytes[i++] = 45;
-            bytes[i++] = 0x00;
-
-            // offset 16
-            // number of the disk, and the disk with the start of the central dir.
-            // (this may change later)
-            for (int j = 0; j < 8; j++)
-                bytes[i++] = 0x00;
-
-            // offset 24
-            long numberOfEntries = entryCount;
-            Array.Copy(BitConverter.GetBytes(numberOfEntries), 0, bytes, i, 8);
-            i += 8;
-            Array.Copy(BitConverter.GetBytes(numberOfEntries), 0, bytes, i, 8);
-            i += 8;
-
-            // offset 40
-            Int64 SizeofCentraldirectory = EndOfCentralDirectory - StartOfCentralDirectory;
-            Array.Copy(BitConverter.GetBytes(SizeofCentraldirectory), 0, bytes, i, 8);
-            i += 8;
-            Array.Copy(BitConverter.GetBytes(StartOfCentralDirectory), 0, bytes, i, 8);
-            i += 8;
-
-            // offset 56
-            // now, the locator
-            // signature
-            sig = BitConverter.GetBytes(ZipConstants.Zip64EndOfCentralDirectoryLocatorSignature);
-            Array.Copy(sig, 0, bytes, i, 4);
-            i+=4;
-
-            // offset 60
-            // number of the disk with the start of the zip64 eocd
-            // (this will change later)  (it will?)
-            uint x2 = (numSegments==0)?0:(uint)(numSegments-1);
-            Array.Copy(BitConverter.GetBytes(x2), 0, bytes, i, 4);
-            i+=4;
-
-            // offset 64
-            // relative offset of the zip64 eocd
-            Array.Copy(BitConverter.GetBytes(EndOfCentralDirectory), 0, bytes, i, 8);
-            i += 8;
-
-            // offset 72
-            // total number of disks
-            // (this will change later)
-            Array.Copy(BitConverter.GetBytes(numSegments), 0, bytes, i, 4);
-            i+=4;
-
-            return bytes;
-        }
-
-
-
-        private static int CountEntries(ICollection<ZipEntry> _entries)
-        {
-            // Cannot just emit _entries.Count, because some of the entries
-            // may have been skipped.
-            int count = 0;
-            foreach (var entry in _entries)
-                if (entry.IncludedInMostRecentSave) count++;
-            return count;
-        }
-
-
-
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.SaveSelfExtractor.cs b/EPPlus/Packaging/DotNetZip/ZipFile.SaveSelfExtractor.cs
deleted file mode 100644
index 800a058..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.SaveSelfExtractor.cs
+++ /dev/null
@@ -1,1101 +0,0 @@
-// ZipFile.saveSelfExtractor.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2008-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-10 19:22:46>
-//
-// ------------------------------------------------------------------
-//
-// This is a the source module that implements the stuff for saving to a
-// self-extracting Zip archive.
-//
-// ZipFile is set up as a "partial class" - defined in multiple .cs source modules.
-// This is one of the source modules for the ZipFile class.
-//
-// Here's the design: The self-extracting zip file is just a regular managed EXE
-// file, with embedded resources.  The managed code logic instantiates a ZipFile, and
-// then extracts each entry.  The embedded resources include the zip archive content,
-// as well as the Zip library itself.  The latter is required so that self-extracting
-// can work on any machine, whether or not it has the DotNetZip library installed on
-// it.
-//
-// What we need to do is create the animal I just described, within a method on the
-// ZipFile class.  This source module provides that capability. The method is
-// SaveSelfExtractor().
-//
-// The way the method works: it uses the programmatic interface to the csc.exe
-// compiler, Microsoft.CSharp.CSharpCodeProvider, to compile "boilerplate"
-// extraction logic into a new assembly.  As part of that compile, we embed within
-// that assembly the zip archive itself, as well as the Zip library.
-//
-// Therefore we need to first save to a temporary zip file, then produce the exe.
-//
-// There are a few twists.
-//
-// The Visual Studio Project structure is a little weird.  There are code files
-// that ARE NOT compiled during a normal build of the VS Solution.  They are
-// marked as embedded resources.  These are the various "boilerplate" modules that
-// are used in the self-extractor. These modules are: WinFormsSelfExtractorStub.cs
-// WinFormsSelfExtractorStub.Designer.cs CommandLineSelfExtractorStub.cs
-// PasswordDialog.cs PasswordDialog.Designer.cs
-//
-// At design time, if you want to modify the way the GUI looks, you have to
-// mark those modules to have a "compile" build action.  Then tweak em, test,
-// etc.  Then again mark them as "Embedded resource".
-//
-// ------------------------------------------------------------------
-
-using System;
-using System.Reflection;
-using System.IO;
-using System.Collections.Generic;
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-#if !NO_SFX
-    /// <summary>
-    /// An enum that provides the different self-extractor flavors
-    /// </summary>
-    internal enum SelfExtractorFlavor
-    {
-        /// <summary>
-        /// A self-extracting zip archive that runs from the console or
-        /// command line.
-        /// </summary>
-        ConsoleApplication = 0,
-
-        /// <summary>
-        /// A self-extracting zip archive that presents a graphical user
-        /// interface when it is executed.
-        /// </summary>
-        WinFormsApplication,
-    }
-
-    /// <summary>
-    /// The options for generating a self-extracting archive.
-    /// </summary>
-    internal class SelfExtractorSaveOptions
-    {
-        /// <summary>
-        ///   The type of SFX to create.
-        /// </summary>
-        public SelfExtractorFlavor Flavor
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The command to run after extraction.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This is optional. Leave it empty (<c>null</c> in C# or <c>Nothing</c> in
-        ///   VB) to run no command after extraction.
-        /// </para>
-        ///
-        /// <para>
-        ///   If it is non-empty, the SFX will execute the command specified in this
-        ///   string on the user's machine, and using the extract directory as the
-        ///   working directory for the process, after unpacking the archive. The
-        ///   program to execute can include a path, if you like. If you want to execute
-        ///   a program that accepts arguments, specify the program name, followed by a
-        ///   space, and then the arguments for the program, each separated by a space,
-        ///   just as you would on a normal command line. Example: <c>program.exe arg1
-        ///   arg2</c>.  The string prior to the first space will be taken as the
-        ///   program name, and the string following the first space specifies the
-        ///   arguments to the program.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you want to execute a program that has a space in the name or path of
-        ///   the file, surround the program name in double-quotes. The first character
-        ///   of the command line should be a double-quote character, and there must be
-        ///   a matching double-quote following the end of the program file name. Any
-        ///   optional arguments to the program follow that, separated by
-        ///   spaces. Example: <c>"c:\project files\program name.exe" arg1 arg2</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   If the flavor of the SFX is <c>SelfExtractorFlavor.ConsoleApplication</c>,
-        ///   then the SFX starts a new process, using this string as the post-extract
-        ///   command line.  The SFX waits for the process to exit.  The exit code of
-        ///   the post-extract command line is returned as the exit code of the
-        ///   command-line self-extractor exe. A non-zero exit code is typically used to
-        ///   indicated a failure by the program. In the case of an SFX, a non-zero exit
-        ///   code may indicate a failure during extraction, OR, it may indicate a
-        ///   failure of the run-after-extract program if specified, OR, it may indicate
-        ///   the run-after-extract program could not be fuond. There is no way to
-        ///   distinguish these conditions from the calling shell, aside from parsing
-        ///   the output of the SFX. If you have Quiet set to <c>true</c>, you may not
-        ///   see error messages, if a problem occurs.
-        /// </para>
-        ///
-        /// <para>
-        ///   If the flavor of the SFX is
-        ///   <c>SelfExtractorFlavor.WinFormsApplication</c>, then the SFX starts a new
-        ///   process, using this string as the post-extract command line, and using the
-        ///   extract directory as the working directory for the process. The SFX does
-        ///   not wait for the command to complete, and does not check the exit code of
-        ///   the program. If the run-after-extract program cannot be fuond, a message
-        ///   box is displayed indicating that fact.
-        /// </para>
-        ///
-        /// <para>
-        ///   You can specify environment variables within this string, with a format like
-        ///   <c>%NAME%</c>. The value of these variables will be expanded at the time
-        ///   the SFX is run. Example: <c>%WINDIR%\system32\xcopy.exe</c> may expand at
-        ///   runtime to <c>c:\Windows\System32\xcopy.exe</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   By combining this with the <c>RemoveUnpackedFilesAfterExecute</c>
-        ///   flag, you can create an SFX that extracts itself, runs a file that
-        ///   was extracted, then deletes all the files that were extracted. If
-        ///   you want it to run "invisibly" then set <c>Flavor</c> to
-        ///   <c>SelfExtractorFlavor.ConsoleApplication</c>, and set <c>Quiet</c>
-        ///   to true.  The user running such an EXE will see a console window
-        ///   appear, then disappear quickly.  You may also want to specify the
-        ///   default extract location, with <c>DefaultExtractDirectory</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set <c>Flavor</c> to
-        ///   <c>SelfExtractorFlavor.WinFormsApplication</c>, and set <c>Quiet</c> to
-        ///   true, then a GUI with progressbars is displayed, but it is
-        ///   "non-interactive" - it accepts no input from the user.  Instead the SFX
-        ///   just automatically unpacks and exits.
-        /// </para>
-        ///
-        /// </remarks>
-        public String PostExtractCommandLine
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The default extract directory the user will see when
-        ///   running the self-extracting archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Passing null (or Nothing in VB) here will cause the Self Extractor to use
-        ///   the the user's personal directory (<see
-        ///   cref="Environment.SpecialFolder.Personal"/>) for the default extract
-        ///   location.
-        /// </para>
-        ///
-        /// <para>
-        ///   This is only a default location.  The actual extract location will be
-        ///   settable on the command line when the SFX is executed.
-        /// </para>
-        ///
-        /// <para>
-        ///   You can specify environment variables within this string,
-        ///   with <c>%NAME%</c>. The value of these variables will be
-        ///   expanded at the time the SFX is run. Example:
-        ///   <c>%USERPROFILE%\Documents\unpack</c> may expand at runtime to
-        ///   <c>c:\users\melvin\Documents\unpack</c>.
-        /// </para>
-        /// </remarks>
-        public String DefaultExtractDirectory
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The name of an .ico file in the filesystem to use for the application icon
-        ///   for the generated SFX.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Normally, DotNetZip will embed an "zipped folder" icon into the generated
-        ///   SFX.  If you prefer to use a different icon, you can specify it here. It
-        ///   should be a .ico file.  This file is passed as the <c>/win32icon</c>
-        ///   option to the csc.exe compiler when constructing the SFX file.
-        /// </para>
-        /// </remarks>
-        ///
-        public string IconFile
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   Whether the ConsoleApplication SFX will be quiet during extraction.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This option affects the way the generated SFX runs. By default it is
-        ///   false.  When you set it to true,...
-        /// </para>
-        ///
-        /// <list type="table">
-        ///   <listheader>
-        ///     <term>Flavor</term>
-        ///     <description>Behavior</description>
-        ///   </listheader>
-        ///
-        /// <item>
-        ///   <term><c>ConsoleApplication</c></term>
-        ///   <description><para>no messages will be emitted during successful
-        ///     operation.</para> <para> Double-clicking the SFX in Windows
-        ///     Explorer or as an attachment in an email will cause a console
-        ///     window to appear briefly, before it disappears. If you run the
-        ///     ConsoleApplication SFX from the cmd.exe prompt, it runs as a
-        ///     normal console app; by default, because it is quiet, it displays
-        ///     no messages to the console.  If you pass the -v+ command line
-        ///     argument to the Console SFX when you run it, you will get verbose
-        ///     messages to the console. </para>
-        ///   </description>
-        /// </item>
-        ///
-        /// <item>
-        ///   <term><c>WinFormsApplication</c></term>
-        ///   <description>the SFX extracts automatically when the application
-        ///        is launched, with no additional user input.
-        ///   </description>
-        /// </item>
-        ///
-        /// </list>
-        ///
-        /// <para>
-        ///   When you set it to false,...
-        /// </para>
-        ///
-        /// <list type="table">
-        ///   <listheader>
-        ///     <term>Flavor</term>
-        ///     <description>Behavior</description>
-        ///   </listheader>
-        ///
-        /// <item>
-        ///   <term><c>ConsoleApplication</c></term>
-        ///   <description><para>the extractor will emit a
-        ///     message to the console for each entry extracted.</para>
-        ///     <para>
-        ///       When double-clicking to launch the SFX, the console window will
-        ///       remain, and the SFX will emit a message for each file as it
-        ///       extracts. The messages fly by quickly, they won't be easily
-        ///       readable, unless the extracted files are fairly large.
-        ///     </para>
-        ///   </description>
-        /// </item>
-        ///
-        /// <item>
-        ///   <term><c>WinFormsApplication</c></term>
-        ///   <description>the SFX presents a forms UI and allows the user to select
-        ///     options before extracting.
-        ///   </description>
-        /// </item>
-        ///
-        /// </list>
-        ///
-        /// </remarks>
-        public bool Quiet
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   Specify what the self-extractor will do when extracting an entry
-        ///   would overwrite an existing file.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        ///   The default behavvior is to Throw.
-        /// </para>
-        /// </remarks>
-        public Ionic.Zip.ExtractExistingFileAction ExtractExistingFile
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   Whether to remove the files that have been unpacked, after executing the
-        ///   PostExtractCommandLine.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   If true, and if there is a <see
-        ///   cref="SelfExtractorSaveOptions.PostExtractCommandLine">
-        ///   PostExtractCommandLine</see>, and if the command runs successfully,
-        ///   then the files that the SFX unpacked will be removed, afterwards.  If
-        ///   the command does not complete successfully (non-zero return code),
-        ///   that is interpreted as a failure, and the extracted files will not be
-        ///   removed.
-        /// </para>
-        ///
-        /// <para>
-        ///   Setting this flag, and setting <c>Flavor</c> to
-        ///   <c>SelfExtractorFlavor.ConsoleApplication</c>, and setting <c>Quiet</c> to
-        ///   true, results in an SFX that extracts itself, runs a file that was
-        ///   extracted, then deletes all the files that were extracted, with no
-        ///   intervention by the user.  You may also want to specify the default
-        ///   extract location, with <c>DefaultExtractDirectory</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        public bool RemoveUnpackedFilesAfterExecute
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The file version number to embed into the generated EXE. It will show up, for
-        ///   example, during a mouseover in Windows Explorer.
-        /// </summary>
-        ///
-        public Version FileVersion
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The product version to embed into the generated EXE. It will show up, for
-        ///   example, during a mouseover in Windows Explorer.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   You can use any arbitrary string, but a human-readable version number is
-        ///   recommended. For example "v1.2 alpha" or "v4.2 RC2".  If you specify nothing,
-        ///   then there is no product version embedded into the EXE.
-        /// </remarks>
-        ///
-        public String ProductVersion
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The copyright notice, if any, to embed into the generated EXE.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   It will show up, for example, while viewing properties of the file in
-        ///   Windows Explorer.  You can use any arbitrary string, but typically you
-        ///   want something like "Copyright � Dino Chiesa 2011".
-        /// </remarks>
-        ///
-        public String Copyright
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The description to embed into the generated EXE.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Use any arbitrary string.  This text will be displayed during a
-        ///   mouseover in Windows Explorer.  If you specify nothing, then the string
-        ///   "DotNetZip SFX Archive" is embedded into the EXE as the description.
-        /// </remarks>
-        ///
-        public String Description
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The product name to embed into the generated EXE.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Use any arbitrary string. This text will be displayed
-        ///   while viewing properties of the EXE file in
-        ///   Windows Explorer.
-        /// </remarks>
-        ///
-        public String ProductName
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The title to display in the Window of a GUI SFX, while it extracts.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     By default the title show in the GUI window of a self-extractor
-        ///     is "DotNetZip Self-extractor (http://DotNetZip.codeplex.com/)".
-        ///     You can change that by setting this property before saving the SFX.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     This property has an effect only when producing a Self-extractor
-        ///     of flavor <c>SelfExtractorFlavor.WinFormsApplication</c>.
-        ///   </para>
-        /// </remarks>
-        ///
-        public String SfxExeWindowTitle
-        {
-            // workitem 12608
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   Additional options for the csc.exe compiler, when producing the SFX
-        ///   EXE.
-        /// </summary>
-        /// <exclude/>
-        public string AdditionalCompilerSwitches
-        {
-            get; set;
-        }
-    }
-
-
-
-
-    partial class ZipFile
-    {
-        class ExtractorSettings
-        {
-            public SelfExtractorFlavor Flavor;
-            public List<string> ReferencedAssemblies;
-            public List<string> CopyThroughResources;
-            public List<string> ResourcesToCompile;
-        }
-
-
-        private static ExtractorSettings[] SettingsList = {
-            new ExtractorSettings() {
-                Flavor = SelfExtractorFlavor.WinFormsApplication,
-                ReferencedAssemblies= new List<string>{
-                    "System.dll", "System.Windows.Forms.dll", "System.Drawing.dll"},
-                CopyThroughResources = new List<string>{
-                    "Ionic.Zip.WinFormsSelfExtractorStub.resources",
-                    "Ionic.Zip.Forms.PasswordDialog.resources",
-                    "Ionic.Zip.Forms.ZipContentsDialog.resources"},
-                ResourcesToCompile = new List<string>{
-                    "WinFormsSelfExtractorStub.cs",
-                    "WinFormsSelfExtractorStub.Designer.cs", // .Designer.cs?
-                    "PasswordDialog.cs",
-                    "PasswordDialog.Designer.cs",             //.Designer.cs"
-                    "ZipContentsDialog.cs",
-                    "ZipContentsDialog.Designer.cs",             //.Designer.cs"
-                    "FolderBrowserDialogEx.cs",
-                }
-            },
-            new ExtractorSettings() {
-                Flavor = SelfExtractorFlavor.ConsoleApplication,
-                ReferencedAssemblies= new List<string> { "System.dll", },
-                CopyThroughResources = null,
-                ResourcesToCompile = new List<string>{"CommandLineSelfExtractorStub.cs"}
-            }
-        };
-
-
-
-        //string _defaultExtractLocation;
-        //string _postExtractCmdLine;
-        //         string _SetDefaultLocationCode =
-        //         "namespace OfficeOpenXml.Packaging.Ionic.Zip { internal partial class WinFormsSelfExtractorStub { partial void _SetDefaultExtractLocation() {" +
-        //         " txtExtractDirectory.Text = \"@@VALUE\"; } }}";
-
-
-
-        /// <summary>
-        /// Saves the ZipFile instance to a self-extracting zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        /// The generated exe image will execute on any machine that has the .NET
-        /// Framework 2.0 installed on it.  The generated exe image is also a
-        /// valid ZIP file, readable with DotNetZip or another Zip library or tool
-        /// such as WinZip.
-        /// </para>
-        ///
-        /// <para>
-        /// There are two "flavors" of self-extracting archive.  The
-        /// <c>WinFormsApplication</c> version will pop up a GUI and allow the
-        /// user to select a target directory into which to extract. There's also
-        /// a checkbox allowing the user to specify to overwrite existing files,
-        /// and another checkbox to allow the user to request that Explorer be
-        /// opened to see the extracted files after extraction.  The other flavor
-        /// is <c>ConsoleApplication</c>.  A self-extractor generated with that
-        /// flavor setting will run from the command line. It accepts command-line
-        /// options to set the overwrite behavior, and to specify the target
-        /// extraction directory.
-        /// </para>
-        ///
-        /// <para>
-        /// There are a few temporary files created during the saving to a
-        /// self-extracting zip.  These files are created in the directory pointed
-        /// to by <see cref="ZipFile.TempFileFolder"/>, which defaults to <see
-        /// cref="System.IO.Path.GetTempPath"/>.  These temporary files are
-        /// removed upon successful completion of this method.
-        /// </para>
-        ///
-        /// <para>
-        /// When a user runs the WinForms SFX, the user's personal directory (<see
-        /// cref="Environment.SpecialFolder.Personal">Environment.SpecialFolder.Personal</see>)
-        /// will be used as the default extract location.  If you want to set the
-        /// default extract location, you should use the other overload of
-        /// <c>SaveSelfExtractor()</c>/ The user who runs the SFX will have the
-        /// opportunity to change the extract directory before extracting. When
-        /// the user runs the Command-Line SFX, the user must explicitly specify
-        /// the directory to which to extract.  The .NET Framework 2.0 is required
-        /// on the computer when the self-extracting archive is run.
-        /// </para>
-        ///
-        /// <para>
-        /// NB: This method is not available in the version of DotNetZip build for
-        /// the .NET Compact Framework, nor in the "Reduced" DotNetZip library.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code>
-        /// string DirectoryPath = "c:\\Documents\\Project7";
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath));
-        ///     zip.Comment = "This will be embedded into a self-extracting console-based exe";
-        ///     zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Dim DirectoryPath As String = "c:\Documents\Project7"
-        /// Using zip As New ZipFile()
-        ///     zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath))
-        ///     zip.Comment = "This will be embedded into a self-extracting console-based exe"
-        ///     zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="exeToGenerate">
-        ///   a pathname, possibly fully qualified, to be created. Typically it
-        ///   will end in an .exe extension.</param>
-        /// <param name="flavor">
-        ///   Indicates whether a Winforms or Console self-extractor is
-        ///   desired. </param>
-        internal void SaveSelfExtractor(string exeToGenerate, SelfExtractorFlavor flavor)
-        {
-            SelfExtractorSaveOptions options = new SelfExtractorSaveOptions();
-            options.Flavor = flavor;
-            SaveSelfExtractor(exeToGenerate, options);
-        }
-
-
-
-        /// <summary>
-        ///   Saves the ZipFile instance to a self-extracting zip archive, using
-        ///   the specified save options.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method saves a self extracting archive, using the specified save
-        ///   options. These options include the flavor of the SFX, the default extract
-        ///   directory, the icon file, and so on.  See the documentation
-        ///   for <see cref="SaveSelfExtractor(string , SelfExtractorFlavor)"/> for more
-        ///   details.
-        /// </para>
-        ///
-        /// <para>
-        ///   The user who runs the SFX will have the opportunity to change the extract
-        ///   directory before extracting. If at the time of extraction, the specified
-        ///   directory does not exist, the SFX will create the directory before
-        ///   extracting the files.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example saves a WinForms-based self-extracting archive EXE that
-        ///   will use c:\ExtractHere as the default extract location. The C# code
-        ///   shows syntax for .NET 3.0, which uses an object initializer for
-        ///   the SelfExtractorOptions object.
-        /// <code>
-        /// string DirectoryPath = "c:\\Documents\\Project7";
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath));
-        ///     zip.Comment = "This will be embedded into a self-extracting WinForms-based exe";
-        ///     var options = new SelfExtractorOptions
-        ///     {
-        ///       Flavor = SelfExtractorFlavor.WinFormsApplication,
-        ///       DefaultExtractDirectory = "%USERPROFILE%\\ExtractHere",
-        ///       PostExtractCommandLine = ExeToRunAfterExtract,
-        ///       SfxExeWindowTitle = "My Custom Window Title",
-        ///       RemoveUnpackedFilesAfterExecute = true
-        ///     };
-        ///     zip.SaveSelfExtractor("archive.exe", options);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Dim DirectoryPath As String = "c:\Documents\Project7"
-        /// Using zip As New ZipFile()
-        ///     zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath))
-        ///     zip.Comment = "This will be embedded into a self-extracting console-based exe"
-        ///     Dim options As New SelfExtractorOptions()
-        ///     options.Flavor = SelfExtractorFlavor.WinFormsApplication
-        ///     options.DefaultExtractDirectory = "%USERPROFILE%\\ExtractHere"
-        ///     options.PostExtractCommandLine = ExeToRunAfterExtract
-        ///     options.SfxExeWindowTitle = "My Custom Window Title"
-        ///     options.RemoveUnpackedFilesAfterExecute = True
-        ///     zip.SaveSelfExtractor("archive.exe", options)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="exeToGenerate">The name of the EXE to generate.</param>
-        /// <param name="options">provides the options for creating the
-        /// Self-extracting archive.</param>
-        internal void SaveSelfExtractor(string exeToGenerate, SelfExtractorSaveOptions options)
-        {
-            // Save an SFX that is both an EXE and a ZIP.
-
-            // Check for the case where we are re-saving a zip archive
-            // that was originally instantiated with a stream.  In that case,
-            // the _name will be null. If so, we set _writestream to null,
-            // which insures that we'll cons up a new WriteStream (with a filesystem
-            // file backing it) in the Save() method.
-            if (_name == null)
-                _writestream = null;
-
-            _SavingSfx = true;
-            _name = exeToGenerate;
-            if (Directory.Exists(_name))
-                throw new ZipException("Bad Directory", new System.ArgumentException("That name specifies an existing directory. Please specify a filename.", "exeToGenerate"));
-            _contentsChanged = true;
-            _fileAlreadyExists = File.Exists(_name);
-
-            _SaveSfxStub(exeToGenerate, options);
-
-            Save();
-            _SavingSfx = false;
-        }
-
-
-
-
-        private static void ExtractResourceToFile(Assembly a, string resourceName, string filename)
-        {
-            int n = 0;
-            byte[] bytes = new byte[1024];
-            using (Stream instream = a.GetManifestResourceStream(resourceName))
-            {
-                if (instream == null)
-                    throw new ZipException(String.Format("missing resource '{0}'", resourceName));
-
-                using (FileStream outstream = File.OpenWrite(filename))
-                {
-                    do
-                    {
-                        n = instream.Read(bytes, 0, bytes.Length);
-                        outstream.Write(bytes, 0, n);
-                    } while (n > 0);
-                }
-            }
-        }
-
-
-        private void _SaveSfxStub(string exeToGenerate, SelfExtractorSaveOptions options)
-        {
-            string nameOfIconFile = null;
-            string stubExe = null;
-            string unpackedResourceDir = null;
-            string tmpDir = null;
-            try
-            {
-                if (File.Exists(exeToGenerate))
-                {
-                    if (Verbose) StatusMessageTextWriter.WriteLine("The existing file ({0}) will be overwritten.", exeToGenerate);
-                }
-                if (!exeToGenerate.EndsWith(".exe"))
-                {
-                    if (Verbose) StatusMessageTextWriter.WriteLine("Warning: The generated self-extracting file will not have an .exe extension.");
-                }
-
-                // workitem 10553
-                tmpDir = TempFileFolder ?? Path.GetDirectoryName(exeToGenerate);
-                stubExe = GenerateTempPathname(tmpDir, "exe");
-
-                // get the Ionic.Zip assembly
-                Assembly a1 = typeof(ZipFile).Assembly;
-
-                using (var csharp = new Microsoft.CSharp.CSharpCodeProvider
-                       (new Dictionary<string,string>() { { "CompilerVersion", "v2.0" } })) {
-
-                    // The following is a perfect opportunity for a linq query, but
-                    // I cannot use it.  DotNetZip needs to run on .NET 2.0,
-                    // and using LINQ would break that. Here's what it would look
-                    // like:
-                    //
-                    //   var settings = (from x in SettingsList
-                    //                   where x.Flavor == flavor
-                    //                   select x).First();
-
-                    ExtractorSettings settings = null;
-                    foreach (var x in SettingsList)
-                    {
-                        if (x.Flavor == options.Flavor)
-                        {
-                            settings = x;
-                            break;
-                        }
-                    }
-
-                    // sanity check; should never happen
-                    if (settings == null)
-                        throw new BadStateException(String.Format("While saving a Self-Extracting Zip, Cannot find that flavor ({0})?", options.Flavor));
-
-                    // This is the list of referenced assemblies.  Ionic.Zip is
-                    // needed here.  Also if it is the winforms (gui) extractor, we
-                    // need other referenced assemblies, like
-                    // System.Windows.Forms.dll, etc.
-                    var cp = new System.CodeDom.Compiler.CompilerParameters();
-                    cp.ReferencedAssemblies.Add(a1.Location);
-                    if (settings.ReferencedAssemblies != null)
-                        foreach (string ra in settings.ReferencedAssemblies)
-                            cp.ReferencedAssemblies.Add(ra);
-
-                    cp.GenerateInMemory = false;
-                    cp.GenerateExecutable = true;
-                    cp.IncludeDebugInformation = false;
-                    cp.CompilerOptions = "";
-
-                    Assembly a2 = Assembly.GetExecutingAssembly();
-
-                    // Use this to concatenate all the source code resources into a
-                    // single module.
-                    var sb = new System.Text.StringBuilder();
-
-                    // In case there are compiler errors later, we allocate a source
-                    // file name now. If errors are detected, we'll spool the source
-                    // code as well as the errors (in comments) into that filename,
-                    // and throw an exception with the filename.  Makes it easier to
-                    // diagnose.  This should be rare; most errors happen only
-                    // during devlpmt of DotNetZip itself, but there are rare
-                    // occasions when they occur in other cases.
-                    string sourceFile = GenerateTempPathname(tmpDir, "cs");
-
-
-                    // // debugging: enumerate the resources in this assembly
-                    // Console.WriteLine("Resources in this assembly:");
-                    // foreach (string rsrc in a2.GetManifestResourceNames())
-                    //   {
-                    //     Console.WriteLine(rsrc);
-                    //   }
-                    // Console.WriteLine();
-
-
-                    // all the source code is embedded in the DLL as a zip file.
-                    using (ZipFile zip = ZipFile.Read(a2.GetManifestResourceStream("Ionic.Zip.Resources.ZippedResources.zip")))
-                    {
-                        // // debugging: enumerate the files in the embedded zip
-                        // Console.WriteLine("Entries in the embbedded zip:");
-                        // foreach (ZipEntry entry in zip)
-                        //   {
-                        //     Console.WriteLine(entry.FileName);
-                        //   }
-                        // Console.WriteLine();
-
-                        unpackedResourceDir = GenerateTempPathname(tmpDir, "tmp");
-
-                        if (String.IsNullOrEmpty(options.IconFile))
-                        {
-                            // Use the ico file that is embedded into the Ionic.Zip
-                            // DLL itself.  To do this we must unpack the icon to
-                            // the filesystem, in order to specify it on the cmdline
-                            // of csc.exe.  This method will remove the unpacked
-                            // file later.
-                            System.IO.Directory.CreateDirectory(unpackedResourceDir);
-                            ZipEntry e = zip["zippedFile.ico"];
-                            // Must not extract a readonly file - it will be impossible to
-                            // delete later.
-                            if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
-                                e.Attributes ^= FileAttributes.ReadOnly;
-                            e.Extract(unpackedResourceDir);
-                            nameOfIconFile = Path.Combine(unpackedResourceDir, "zippedFile.ico");
-                            cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", nameOfIconFile);
-                        }
-                        else
-                            cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", options.IconFile);
-
-                        cp.OutputAssembly = stubExe;
-
-                        if (options.Flavor == SelfExtractorFlavor.WinFormsApplication)
-                            cp.CompilerOptions += " /target:winexe";
-
-                        if (!String.IsNullOrEmpty(options.AdditionalCompilerSwitches))
-                            cp.CompilerOptions += " " + options.AdditionalCompilerSwitches;
-
-                        if (String.IsNullOrEmpty(cp.CompilerOptions))
-                            cp.CompilerOptions = null;
-
-                        if ((settings.CopyThroughResources != null) && (settings.CopyThroughResources.Count != 0))
-                        {
-                            if (!Directory.Exists(unpackedResourceDir)) System.IO.Directory.CreateDirectory(unpackedResourceDir);
-                            foreach (string re in settings.CopyThroughResources)
-                            {
-                                string filename = Path.Combine(unpackedResourceDir, re);
-
-                                ExtractResourceToFile(a2, re, filename);
-                                // add the file into the target assembly as an embedded resource
-                                cp.EmbeddedResources.Add(filename);
-                            }
-                        }
-
-                        // add the Ionic.Utils.Zip DLL as an embedded resource
-                        cp.EmbeddedResources.Add(a1.Location);
-
-                        // file header
-                        sb.Append("// " + Path.GetFileName(sourceFile) + "\n")
-                            .Append("// --------------------------------------------\n//\n")
-                            .Append("// This SFX source file was generated by DotNetZip ")
-                            .Append(ZipFile.LibraryVersion.ToString())
-                            .Append("\n//         at ")
-                            .Append(System.DateTime.Now.ToString("yyyy MMMM dd  HH:mm:ss"))
-                            .Append("\n//\n// --------------------------------------------\n\n\n");
-
-                        // assembly attributes
-                        if (!String.IsNullOrEmpty(options.Description))
-                            sb.Append("[assembly: System.Reflection.AssemblyTitle(\""
-                                      + options.Description.Replace("\"", "")
-                                      + "\")]\n");
-                        else
-                            sb.Append("[assembly: System.Reflection.AssemblyTitle(\"DotNetZip SFX Archive\")]\n");
-
-                        if (!String.IsNullOrEmpty(options.ProductVersion))
-                            sb.Append("[assembly: System.Reflection.AssemblyInformationalVersion(\""
-                                      + options.ProductVersion.Replace("\"", "")
-                                      + "\")]\n");
-
-                        // workitem
-                        string copyright =
-                            (String.IsNullOrEmpty(options.Copyright))
-                            ? "Extractor: Copyright � Dino Chiesa 2008-2011"
-                            : options.Copyright.Replace("\"", "");
-
-                        if (!String.IsNullOrEmpty(options.ProductName))
-                            sb.Append("[assembly: System.Reflection.AssemblyProduct(\"")
-                                .Append(options.ProductName.Replace("\"", ""))
-                                .Append("\")]\n");
-                        else
-                            sb.Append("[assembly: System.Reflection.AssemblyProduct(\"DotNetZip\")]\n");
-
-
-                        sb.Append("[assembly: System.Reflection.AssemblyCopyright(\"" + copyright + "\")]\n")
-                            .Append(String.Format("[assembly: System.Reflection.AssemblyVersion(\"{0}\")]\n", ZipFile.LibraryVersion.ToString()));
-                        if (options.FileVersion != null)
-                            sb.Append(String.Format("[assembly: System.Reflection.AssemblyFileVersion(\"{0}\")]\n",
-                                                    options.FileVersion.ToString()));
-
-                        sb.Append("\n\n\n");
-
-                        // Set the default extract location if it is available
-                        string extractLoc = options.DefaultExtractDirectory;
-                        if (extractLoc != null)
-                        {
-                            // remove double-quotes and replace slash with double-slash.
-                            // This, because the value is going to be embedded into a
-                            // cs file as a quoted string, and it needs to be escaped.
-                            extractLoc = extractLoc.Replace("\"", "").Replace("\\", "\\\\");
-                        }
-
-                        string postExCmdLine = options.PostExtractCommandLine;
-                        if (postExCmdLine != null)
-                        {
-                            postExCmdLine = postExCmdLine.Replace("\\", "\\\\");
-                            postExCmdLine = postExCmdLine.Replace("\"", "\\\"");
-                        }
-
-
-                        foreach (string rc in settings.ResourcesToCompile)
-                        {
-                            using (Stream s = zip[rc].OpenReader())
-                            {
-                                if (s == null)
-                                    throw new ZipException(String.Format("missing resource '{0}'", rc));
-                                using (StreamReader sr = new StreamReader(s))
-                                {
-                                    while (sr.Peek() >= 0)
-                                    {
-                                        string line = sr.ReadLine();
-                                        if (extractLoc != null)
-                                            line = line.Replace("@@EXTRACTLOCATION", extractLoc);
-
-                                        line = line.Replace("@@REMOVE_AFTER_EXECUTE", options.RemoveUnpackedFilesAfterExecute.ToString());
-                                        line = line.Replace("@@QUIET", options.Quiet.ToString());
-                                        if (!String.IsNullOrEmpty(options.SfxExeWindowTitle))
-
-                                            line = line.Replace("@@SFX_EXE_WINDOW_TITLE", options.SfxExeWindowTitle);
-
-                                        line = line.Replace("@@EXTRACT_EXISTING_FILE", ((int)options.ExtractExistingFile).ToString());
-
-                                        if (postExCmdLine != null)
-                                            line = line.Replace("@@POST_UNPACK_CMD_LINE", postExCmdLine);
-
-                                        sb.Append(line).Append("\n");
-                                    }
-                                }
-                                sb.Append("\n\n");
-                            }
-                        }
-                    }
-
-                    string LiteralSource = sb.ToString();
-
-#if DEBUGSFX
-                    // for debugging only
-                    string sourceModule = GenerateTempPathname(tmpDir, "cs");
-                    using (StreamWriter sw = File.CreateText(sourceModule))
-                    {
-                        sw.Write(LiteralSource);
-                    }
-                    Console.WriteLine("source: {0}", sourceModule);
-#endif
-
-                    var cr = csharp.CompileAssemblyFromSource(cp, LiteralSource);
-
-
-                    if (cr == null)
-                        throw new SfxGenerationException("Cannot compile the extraction logic!");
-
-                    if (Verbose)
-                        foreach (string output in cr.Output)
-                            StatusMessageTextWriter.WriteLine(output);
-
-                    if (cr.Errors.Count != 0)
-                    {
-                        using (TextWriter tw = new StreamWriter(sourceFile))
-                        {
-                            // first, the source we compiled
-                            tw.Write(LiteralSource);
-
-                            // now, append the compile errors
-                            tw.Write("\n\n\n// ------------------------------------------------------------------\n");
-                            tw.Write("// Errors during compilation: \n//\n");
-                            string p = Path.GetFileName(sourceFile);
-
-                            foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors)
-                            {
-                                tw.Write(String.Format("//   {0}({1},{2}): {3} {4}: {5}\n//\n",
-                                                       p,                                   // 0
-                                                       error.Line,                          // 1
-                                                       error.Column,                        // 2
-                                                       error.IsWarning ? "Warning" : "error",   // 3
-                                                       error.ErrorNumber,                   // 4
-                                                       error.ErrorText));                  // 5
-                            }
-                        }
-                        throw new SfxGenerationException(String.Format("Errors compiling the extraction logic!  {0}", sourceFile));
-                    }
-
-                    OnSaveEvent(ZipProgressEventType.Saving_AfterCompileSelfExtractor);
-
-                    // Now, copy the resulting EXE image to the _writestream.
-                    // Because this stub exe is being saved first, the effect will be to
-                    // concatenate the exe and the zip data together.
-                    using (System.IO.Stream input = System.IO.File.OpenRead(stubExe))
-                    {
-                        byte[] buffer = new byte[4000];
-                        int n = 1;
-                        while (n != 0)
-                        {
-                            n = input.Read(buffer, 0, buffer.Length);
-                            if (n != 0)
-                                WriteStream.Write(buffer, 0, n);
-                        }
-                    }
-                }
-
-                OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive);
-            }
-            finally
-            {
-                try
-                {
-                    if (Directory.Exists(unpackedResourceDir))
-                    {
-                        try { Directory.Delete(unpackedResourceDir, true); }
-                        catch (System.IO.IOException exc1)
-                        {
-                            StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1);
-                        }
-                    }
-                    if (File.Exists(stubExe))
-                    {
-                        try { File.Delete(stubExe); }
-                        catch (System.IO.IOException exc1)
-                        {
-                            StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1);
-                        }
-                    }
-                }
-                catch (System.IO.IOException) { }
-            }
-
-            return;
-
-        }
-
-
-
-        internal static string GenerateTempPathname(string dir, string extension)
-        {
-            string candidate = null;
-            String AppName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
-            do
-            {
-                // workitem 13475
-                string uuid = System.Guid.NewGuid().ToString();
-
-                string Name = String.Format("{0}-{1}-{2}.{3}",
-                        AppName, System.DateTime.Now.ToString("yyyyMMMdd-HHmmss"),
-                                            uuid, extension);
-                candidate = System.IO.Path.Combine(dir, Name);
-            } while (System.IO.File.Exists(candidate) || System.IO.Directory.Exists(candidate));
-
-            // The candidate path does not exist as a file or directory.
-            // It can now be created, as a file or directory.
-            return candidate;
-        }
-
-    }
-#endif
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.Selector.cs b/EPPlus/Packaging/DotNetZip/ZipFile.Selector.cs
deleted file mode 100644
index 3023f77..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.Selector.cs
+++ /dev/null
@@ -1,1466 +0,0 @@
-// ZipFile.Selector.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2010 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-06 09:35:58>
-//
-// ------------------------------------------------------------------
-//
-// This module defines methods in the ZipFile class associated to the FileFilter
-// capability - selecting files to add into the archive, or selecting entries to
-// retrieve from the archive based on criteria including the filename, size, date, or
-// attributes.  It is something like a "poor man's LINQ".  I included it into DotNetZip
-// because not everyone has .NET 3.5 yet.  When using DotNetZip on .NET 3.5, the LINQ
-// query/selection will be superior.
-//
-// These methods are segregated into a different module to facilitate easy exclusion for
-// those people who wish to have a smaller library without this function.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-using OfficeOpenXml.Packaging.Ionic.Zip;
-using System.Globalization;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    partial class ZipFile
-    {
-        /// <summary>
-        ///   Adds to the ZipFile a set of files from the current working directory on
-        ///   disk, that conform to the specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method selects files from the the current working directory matching
-        ///   the specified criteria, and adds them to the ZipFile.
-        /// </para>
-        ///
-        /// <para>
-        ///   Specify the criteria in statements of 3 elements: a noun, an operator, and
-        ///   a value.  Consider the string "name != *.doc" .  The noun is "name".  The
-        ///   operator is "!=", implying "Not Equal".  The value is "*.doc".  That
-        ///   criterion, in English, says "all files with a name that does not end in
-        ///   the .doc extension."
-        /// </para>
-        ///
-        /// <para>
-        ///   Supported nouns include "name" (or "filename") for the filename; "atime",
-        ///   "mtime", and "ctime" for last access time, last modfied time, and created
-        ///   time of the file, respectively; "attributes" (or "attrs") for the file
-        ///   attributes; "size" (or "length") for the file length (uncompressed), and
-        ///   "type" for the type of object, either a file or a directory.  The
-        ///   "attributes", "name" and "type" nouns both support = and != as operators.
-        ///   The "size", "atime", "mtime", and "ctime" nouns support = and !=, and
-        ///   &gt;, &gt;=, &lt;, &lt;= as well. The times are taken to be expressed in
-        ///   local time.
-        /// </para>
-        ///
-        /// <para>
-        /// Specify values for the file attributes as a string with one or more of the
-        /// characters H,R,S,A,I,L in any order, implying file attributes of Hidden,
-        /// ReadOnly, System, Archive, NotContextIndexed, and ReparsePoint (symbolic
-        /// link) respectively.
-        /// </para>
-        ///
-        /// <para>
-        /// To specify a time, use YYYY-MM-DD-HH:mm:ss or YYYY/MM/DD-HH:mm:ss as the
-        /// format.  If you omit the HH:mm:ss portion, it is assumed to be 00:00:00
-        /// (midnight).
-        /// </para>
-        ///
-        /// <para>
-        /// The value for a size criterion is expressed in integer quantities of bytes,
-        /// kilobytes (use k or kb after the number), megabytes (m or mb), or gigabytes
-        /// (g or gb).
-        /// </para>
-        ///
-        /// <para>
-        /// The value for a name is a pattern to match against the filename, potentially
-        /// including wildcards.  The pattern follows CMD.exe glob rules: * implies one
-        /// or more of any character, while ?  implies one character.  If the name
-        /// pattern contains any slashes, it is matched to the entire filename,
-        /// including the path; otherwise, it is matched against only the filename
-        /// without the path.  This means a pattern of "*\*.*" matches all files one
-        /// directory level deep, while a pattern of "*.*" matches all files in all
-        /// directories.
-        /// </para>
-        ///
-        /// <para>
-        /// To specify a name pattern that includes spaces, use single quotes around the
-        /// pattern.  A pattern of "'* *.*'" will match all files that have spaces in
-        /// the filename.  The full criteria string for that would be "name = '* *.*'" .
-        /// </para>
-        ///
-        /// <para>
-        /// The value for a type criterion is either F (implying a file) or D (implying
-        /// a directory).
-        /// </para>
-        ///
-        /// <para>
-        /// Some examples:
-        /// </para>
-        ///
-        /// <list type="table">
-        ///   <listheader>
-        ///     <term>criteria</term>
-        ///     <description>Files retrieved</description>
-        ///   </listheader>
-        ///
-        ///   <item>
-        ///     <term>name != *.xls </term>
-        ///     <description>any file with an extension that is not .xls
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>name = *.mp3 </term>
-        ///     <description>any file with a .mp3 extension.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>*.mp3</term>
-        ///     <description>(same as above) any file with a .mp3 extension.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>attributes = A </term>
-        ///     <description>all files whose attributes include the Archive bit.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>attributes != H </term>
-        ///     <description>all files whose attributes do not include the Hidden bit.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>mtime > 2009-01-01</term>
-        ///     <description>all files with a last modified time after January 1st, 2009.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>size > 2gb</term>
-        ///     <description>all files whose uncompressed size is greater than 2gb.
-        ///     </description>
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <term>type = D</term>
-        ///     <description>all directories in the filesystem. </description>
-        ///   </item>
-        ///
-        /// </list>
-        ///
-        /// <para>
-        /// You can combine criteria with the conjunctions AND or OR. Using a string
-        /// like "name = *.txt AND size &gt;= 100k" for the selectionCriteria retrieves
-        /// entries whose names end in .txt, and whose uncompressed size is greater than
-        /// or equal to 100 kilobytes.
-        /// </para>
-        ///
-        /// <para>
-        /// For more complex combinations of criteria, you can use parenthesis to group
-        /// clauses in the boolean logic.  Without parenthesis, the precedence of the
-        /// criterion atoms is determined by order of appearance.  Unlike the C#
-        /// language, the AND conjunction does not take precendence over the logical OR.
-        /// This is important only in strings that contain 3 or more criterion atoms.
-        /// In other words, "name = *.txt and size &gt; 1000 or attributes = H" implies
-        /// "((name = *.txt AND size &gt; 1000) OR attributes = H)" while "attributes =
-        /// H OR name = *.txt and size &gt; 1000" evaluates to "((attributes = H OR name
-        /// = *.txt) AND size &gt; 1000)".  When in doubt, use parenthesis.
-        /// </para>
-        ///
-        /// <para>
-        /// Using time properties requires some extra care. If you want to retrieve all
-        /// entries that were last updated on 2009 February 14, specify a time range
-        /// like so:"mtime &gt;= 2009-02-14 AND mtime &lt; 2009-02-15".  Read this to
-        /// say: all files updated after 12:00am on February 14th, until 12:00am on
-        /// February 15th.  You can use the same bracketing approach to specify any time
-        /// period - a year, a month, a week, and so on.
-        /// </para>
-        ///
-        /// <para>
-        /// The syntax allows one special case: if you provide a string with no spaces, it is
-        /// treated as a pattern to match for the filename.  Therefore a string like "*.xls"
-        /// will be equivalent to specifying "name = *.xls".
-        /// </para>
-        ///
-        /// <para>
-        /// There is no logic in this method that insures that the file inclusion
-        /// criteria are internally consistent.  For example, it's possible to specify
-        /// criteria that says the file must have a size of less than 100 bytes, as well
-        /// as a size that is greater than 1000 bytes. Obviously no file will ever
-        /// satisfy such criteria, but this method does not detect such logical
-        /// inconsistencies. The caller is responsible for insuring the criteria are
-        /// sensible.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using this method, the file selection does not recurse into
-        ///   subdirectories, and the full path of the selected files is included in the
-        ///   entries added into the zip archive.  If you don't like these behaviors,
-        ///   see the other overloads of this method.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example zips up all *.csv files in the current working directory.
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     // To just match on filename wildcards,
-        ///     // use the shorthand form of the selectionCriteria string.
-        ///     zip.AddSelectedFiles("*.csv");
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile()
-        ///     zip.AddSelectedFiles("*.csv")
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection</param>
-        public void AddSelectedFiles(String selectionCriteria)
-        {
-            this.AddSelectedFiles(selectionCriteria, ".", null, false);
-        }
-
-        /// <summary>
-        ///   Adds to the ZipFile a set of files from the disk that conform to the
-        ///   specified criteria, optionally recursing into subdirectories.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method selects files from the the current working directory matching
-        ///   the specified criteria, and adds them to the ZipFile.  If
-        ///   <c>recurseDirectories</c> is true, files are also selected from
-        ///   subdirectories, and the directory structure in the filesystem is
-        ///   reproduced in the zip archive, rooted at the current working directory.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using this method, the full path of the selected files is included in the
-        ///   entries added into the zip archive.  If you don't want this behavior, use
-        ///   one of the overloads of this method that allows the specification of a
-        ///   <c>directoryInArchive</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For details on the syntax for the selectionCriteria parameter, see <see
-        ///   cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example zips up all *.xml files in the current working directory, or any
-        ///   subdirectory, that are larger than 1mb.
-        ///
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     // Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.xml  and  size > 1024kb", true);
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile()
-        ///     ' Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.xml  and  size > 1024kb", true)
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection</param>
-        ///
-        /// <param name="recurseDirectories">
-        ///   If true, the file selection will recurse into subdirectories.
-        /// </param>
-        public void AddSelectedFiles(String selectionCriteria, bool recurseDirectories)
-        {
-            this.AddSelectedFiles(selectionCriteria, ".", null, recurseDirectories);
-        }
-
-        /// <summary>
-        ///   Adds to the ZipFile a set of files from a specified directory in the
-        ///   filesystem, that conform to the specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method selects files that conform to the specified criteria, from the
-        ///   the specified directory on disk, and adds them to the ZipFile.  The search
-        ///   does not recurse into subdirectores.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using this method, the full filesystem path of the files on disk is
-        ///   reproduced on the entries added to the zip file.  If you don't want this
-        ///   behavior, use one of the other overloads of this method.
-        /// </para>
-        ///
-        /// <para>
-        ///   For details on the syntax for the selectionCriteria parameter, see <see
-        ///   cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example zips up all *.xml files larger than 1mb in the directory
-        ///   given by "d:\rawdata".
-        ///
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     // Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.xml  and  size > 1024kb", "d:\\rawdata");
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile()
-        ///     ' Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.xml  and  size > 1024kb", "d:\rawdata)
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection</param>
-        ///
-        /// <param name="directoryOnDisk">
-        /// The name of the directory on the disk from which to select files.
-        /// </param>
-        public void AddSelectedFiles(String selectionCriteria, String directoryOnDisk)
-        {
-            this.AddSelectedFiles(selectionCriteria, directoryOnDisk, null, false);
-        }
-
-
-        /// <summary>
-        ///   Adds to the ZipFile a set of files from the specified directory on disk,
-        ///   that conform to the specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This method selects files from the the specified disk directory matching
-        ///   the specified selection criteria, and adds them to the ZipFile.  If
-        ///   <c>recurseDirectories</c> is true, files are also selected from
-        ///   subdirectories.
-        /// </para>
-        ///
-        /// <para>
-        ///   The full directory structure in the filesystem is reproduced on the
-        ///   entries added to the zip archive.  If you don't want this behavior, use
-        ///   one of the overloads of this method that allows the specification of a
-        ///   <c>directoryInArchive</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   For details on the syntax for the selectionCriteria parameter, see <see
-        ///   cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example zips up all *.csv files in the "files" directory, or any
-        ///   subdirectory, that have been saved since 2009 February 14th.
-        ///
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     // Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.csv  and  mtime > 2009-02-14", "files", true);
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile()
-        ///     ' Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.csv  and  mtime > 2009-02-14", "files", true)
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        ///   This example zips up all files in the current working
-        ///   directory, and all its child directories, except those in
-        ///   the <c>excludethis</c> subdirectory.
-        /// <code lang="VB">
-        /// Using Zip As ZipFile = New ZipFile(zipfile)
-        ///   Zip.AddSelectedFfiles("name != 'excludethis\*.*'", datapath, True)
-        ///   Zip.Save()
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">The criteria for file selection</param>
-        ///
-        /// <param name="directoryOnDisk">
-        ///   The filesystem path from which to select files.
-        /// </param>
-        ///
-        /// <param name="recurseDirectories">
-        ///   If true, the file selection will recurse into subdirectories.
-        /// </param>
-        public void AddSelectedFiles(String selectionCriteria, String directoryOnDisk, bool recurseDirectories)
-        {
-            this.AddSelectedFiles(selectionCriteria, directoryOnDisk, null, recurseDirectories);
-        }
-
-
-        /// <summary>
-        ///   Adds to the ZipFile a selection of files from the specified directory on
-        ///   disk, that conform to the specified criteria, and using a specified root
-        ///   path for entries added to the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method selects files from the specified disk directory matching the
-        ///   specified selection criteria, and adds those files to the ZipFile, using
-        ///   the specified directory path in the archive.  The search does not recurse
-        ///   into subdirectories.  For details on the syntax for the selectionCriteria
-        ///   parameter, see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example zips up all *.psd files in the "photos" directory that have
-        ///   been saved since 2009 February 14th, and puts them all in a zip file,
-        ///   using the directory name of "content" in the zip archive itself. When the
-        ///   zip archive is unzipped, the folder containing the .psd files will be
-        ///   named "content".
-        ///
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     // Use a compound expression in the selectionCriteria string.
-        ///     zip.AddSelectedFiles("name = *.psd  and  mtime > 2009-02-14", "photos", "content");
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile
-        ///     zip.AddSelectedFiles("name = *.psd  and  mtime > 2009-02-14", "photos", "content")
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">
-        ///   The criteria for selection of files to add to the <c>ZipFile</c>.
-        /// </param>
-        ///
-        /// <param name="directoryOnDisk">
-        ///   The path to the directory in the filesystem from which to select files.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to in place of the
-        ///   <c>directoryOnDisk</c>.  This path may, or may not, correspond to a real
-        ///   directory in the current filesystem.  If the files within the zip are
-        ///   later extracted, this is the path used for the extracted file.  Passing
-        ///   null (nothing in VB) will use the path on the file name, if any; in other
-        ///   words it would use <c>directoryOnDisk</c>, plus any subdirectory.  Passing
-        ///   the empty string ("") will insert the item at the root path within the
-        ///   archive.
-        /// </param>
-        public void AddSelectedFiles(String selectionCriteria,
-                                     String directoryOnDisk,
-                                     String directoryPathInArchive)
-        {
-            this.AddSelectedFiles(selectionCriteria, directoryOnDisk, directoryPathInArchive, false);
-        }
-
-        /// <summary>
-        ///   Adds to the ZipFile a selection of files from the specified directory on
-        ///   disk, that conform to the specified criteria, optionally recursing through
-        ///   subdirectories, and using a specified root path for entries added to the
-        ///   zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This method selects files from the specified disk directory that match the
-        ///   specified selection criteria, and adds those files to the ZipFile, using
-        ///   the specified directory path in the archive. If <c>recurseDirectories</c>
-        ///   is true, files are also selected from subdirectories, and the directory
-        ///   structure in the filesystem is reproduced in the zip archive, rooted at
-        ///   the directory specified by <c>directoryOnDisk</c>.  For details on the
-        ///   syntax for the selectionCriteria parameter, see <see
-        ///   cref="AddSelectedFiles(String)" />.
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example zips up all files that are NOT *.pst files, in the current
-        ///   working directory and any subdirectories.
-        ///
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddSelectedFiles("name != *.pst", SourceDirectory, "backup", true);
-        ///     zip.Save(PathToZipArchive);
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = New ZipFile
-        ///     zip.AddSelectedFiles("name != *.pst", SourceDirectory, "backup", true)
-        ///     zip.Save(PathToZipArchive)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">
-        ///   The criteria for selection of files to add to the <c>ZipFile</c>.
-        /// </param>
-        ///
-        /// <param name="directoryOnDisk">
-        ///   The path to the directory in the filesystem from which to select files.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to in place of the
-        ///   <c>directoryOnDisk</c>.  This path may, or may not, correspond to a real
-        ///   directory in the current filesystem.  If the files within the zip are
-        ///   later extracted, this is the path used for the extracted file.  Passing
-        ///   null (nothing in VB) will use the path on the file name, if any; in other
-        ///   words it would use <c>directoryOnDisk</c>, plus any subdirectory.  Passing
-        ///   the empty string ("") will insert the item at the root path within the
-        ///   archive.
-        /// </param>
-        ///
-        /// <param name="recurseDirectories">
-        ///   If true, the method also scans subdirectories for files matching the
-        ///   criteria.
-        /// </param>
-        public void AddSelectedFiles(String selectionCriteria,
-                                     String directoryOnDisk,
-                                     String directoryPathInArchive,
-                                     bool recurseDirectories)
-        {
-            _AddOrUpdateSelectedFiles(selectionCriteria,
-                                      directoryOnDisk,
-                                      directoryPathInArchive,
-                                      recurseDirectories,
-                                      false);
-        }
-
-        /// <summary>
-        ///   Updates the ZipFile with a selection of files from the disk that conform
-        ///   to the specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This method selects files from the specified disk directory that match the
-        ///   specified selection criteria, and Updates the <c>ZipFile</c> with those
-        ///   files, using the specified directory path in the archive. If
-        ///   <c>recurseDirectories</c> is true, files are also selected from
-        ///   subdirectories, and the directory structure in the filesystem is
-        ///   reproduced in the zip archive, rooted at the directory specified by
-        ///   <c>directoryOnDisk</c>.  For details on the syntax for the
-        ///   selectionCriteria parameter, see <see cref="AddSelectedFiles(String)" />.
-        /// </remarks>
-        ///
-        /// <param name="selectionCriteria">
-        ///   The criteria for selection of files to add to the <c>ZipFile</c>.
-        /// </param>
-        ///
-        /// <param name="directoryOnDisk">
-        ///   The path to the directory in the filesystem from which to select files.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        ///   Specifies a directory path to use to in place of the
-        ///   <c>directoryOnDisk</c>. This path may, or may not, correspond to a
-        ///   real directory in the current filesystem. If the files within the zip
-        ///   are later extracted, this is the path used for the extracted file.
-        ///   Passing null (nothing in VB) will use the path on the file name, if
-        ///   any; in other words it would use <c>directoryOnDisk</c>, plus any
-        ///   subdirectory.  Passing the empty string ("") will insert the item at
-        ///   the root path within the archive.
-        /// </param>
-        ///
-        /// <param name="recurseDirectories">
-        ///   If true, the method also scans subdirectories for files matching the criteria.
-        /// </param>
-        ///
-        /// <seealso cref="AddSelectedFiles(String, String, String, bool)" />
-        public void UpdateSelectedFiles(String selectionCriteria,
-                                     String directoryOnDisk,
-                                     String directoryPathInArchive,
-                                     bool recurseDirectories)
-        {
-            _AddOrUpdateSelectedFiles(selectionCriteria,
-                                      directoryOnDisk,
-                                      directoryPathInArchive,
-                                      recurseDirectories,
-                                      true);
-        }
-
-
-        private string EnsureendInSlash(string s)
-        {
-            if (s.EndsWith("\\")) return s;
-            return s + "\\";
-        }
-
-        private void _AddOrUpdateSelectedFiles(String selectionCriteria,
-                                               String directoryOnDisk,
-                                               String directoryPathInArchive,
-                                               bool recurseDirectories,
-                                               bool wantUpdate)
-        {
-            if (directoryOnDisk == null && (Directory.Exists(selectionCriteria)))
-            {
-                directoryOnDisk = selectionCriteria;
-                selectionCriteria = "*.*";
-            }
-            else if (String.IsNullOrEmpty(directoryOnDisk))
-            {
-                directoryOnDisk = ".";
-            }
-
-            // workitem 9176
-            while (directoryOnDisk.EndsWith("\\")) directoryOnDisk = directoryOnDisk.Substring(0, directoryOnDisk.Length - 1);
-            if (Verbose) StatusMessageTextWriter.WriteLine("adding selection '{0}' from dir '{1}'...",
-                                                               selectionCriteria, directoryOnDisk);
-            Ionic.FileSelector ff = new Ionic.FileSelector(selectionCriteria,
-                                                           AddDirectoryWillTraverseReparsePoints);
-            var itemsToAdd = ff.SelectFiles(directoryOnDisk, recurseDirectories);
-
-            if (Verbose) StatusMessageTextWriter.WriteLine("found {0} files...", itemsToAdd.Count);
-
-            OnAddStarted();
-
-            AddOrUpdateAction action = (wantUpdate) ? AddOrUpdateAction.AddOrUpdate : AddOrUpdateAction.AddOnly;
-            foreach (var item in itemsToAdd)
-            {
-                // workitem 10153
-                string dirInArchive = (directoryPathInArchive == null)
-                    ? null
-                    // workitem 12260
-                    : ReplaceLeadingDirectory(Path.GetDirectoryName(item),
-                                              directoryOnDisk,
-                                              directoryPathInArchive);
-
-                if (File.Exists(item))
-                {
-                    if (wantUpdate)
-                        this.UpdateFile(item, dirInArchive);
-                    else
-                        this.AddFile(item, dirInArchive);
-                }
-                else
-                {
-                    // this adds "just" the directory, without recursing to the contained files
-                    AddOrUpdateDirectoryImpl(item, dirInArchive, action, false, 0);
-                }
-            }
-
-            OnAddCompleted();
-        }
-
-
-        // workitem 12260
-        private static string ReplaceLeadingDirectory(string original,
-                                                      string pattern,
-                                                      string replacement)
-        {
-            string upperString = original.ToUpper(CultureInfo.InvariantCulture);
-            string upperPattern = pattern.ToUpper(CultureInfo.InvariantCulture);
-            int p1 = upperString.IndexOf(upperPattern);
-            if (p1 != 0) return original;
-            return replacement + original.Substring(upperPattern.Length);
-        }
-
-#if NOT
-        private static string ReplaceEx(string original,
-                                                      string pattern,
-                                                      string replacement)
-        {
-            int count, position0, position1;
-            count = position0 = position1 = 0;
-            string upperString = original.ToUpper();
-            string upperPattern = pattern.ToUpper();
-            int inc = (original.Length/pattern.Length) *
-                (replacement.Length-pattern.Length);
-            char [] chars = new char[original.Length + Math.Max(0, inc)];
-            while( (position1 = upperString.IndexOf(upperPattern,
-                                                    position0)) != -1 )
-            {
-                for ( int i=position0 ; i < position1 ; ++i )
-                    chars[count++] = original[i];
-                for ( int i=0 ; i < replacement.Length ; ++i )
-                    chars[count++] = replacement[i];
-                position0 = position1+pattern.Length;
-            }
-            if ( position0 == 0 ) return original;
-            for ( int i=position0 ; i < original.Length ; ++i )
-                chars[count++] = original[i];
-            return new string(chars, 0, count);
-        }
-#endif
-
-        /// <summary>
-        /// Retrieve entries from the zipfile by specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method allows callers to retrieve the collection of entries from the zipfile
-        /// that fit the specified criteria.  The criteria are described in a string format, and
-        /// can include patterns for the filename; constraints on the size of the entry;
-        /// constraints on the last modified, created, or last accessed time for the file
-        /// described by the entry; or the attributes of the entry.
-        /// </para>
-        ///
-        /// <para>
-        /// For details on the syntax for the selectionCriteria parameter, see <see
-        /// cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// This method is intended for use with a ZipFile that has been read from storage.
-        /// When creating a new ZipFile, this method will work only after the ZipArchive has
-        /// been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip
-        /// archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been
-        /// saved will deliver undefined results.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        /// Thrown if selectionCriteria has an invalid syntax.
-        /// </exception>
-        ///
-        /// <example>
-        /// This example selects all the PhotoShop files from within an archive, and extracts them
-        /// to the current working directory.
-        /// <code>
-        /// using (ZipFile zip1 = ZipFile.Read(ZipFileName))
-        /// {
-        ///     var PhotoShopFiles = zip1.SelectEntries("*.psd");
-        ///     foreach (ZipEntry psd in PhotoShopFiles)
-        ///     {
-        ///         psd.Extract();
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip1 As ZipFile = ZipFile.Read(ZipFileName)
-        ///     Dim PhotoShopFiles as ICollection(Of ZipEntry)
-        ///     PhotoShopFiles = zip1.SelectEntries("*.psd")
-        ///     Dim psd As ZipEntry
-        ///     For Each psd In PhotoShopFiles
-        ///         psd.Extract
-        ///     Next
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="selectionCriteria">the string that specifies which entries to select</param>
-        /// <returns>a collection of ZipEntry objects that conform to the inclusion spec</returns>
-        public ICollection<ZipEntry> SelectEntries(String selectionCriteria)
-        {
-            Ionic.FileSelector ff = new Ionic.FileSelector(selectionCriteria,
-                                                           AddDirectoryWillTraverseReparsePoints);
-            return ff.SelectEntries(this);
-        }
-
-
-        /// <summary>
-        /// Retrieve entries from the zipfile by specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method allows callers to retrieve the collection of entries from the zipfile
-        /// that fit the specified criteria.  The criteria are described in a string format, and
-        /// can include patterns for the filename; constraints on the size of the entry;
-        /// constraints on the last modified, created, or last accessed time for the file
-        /// described by the entry; or the attributes of the entry.
-        /// </para>
-        ///
-        /// <para>
-        /// For details on the syntax for the selectionCriteria parameter, see <see
-        /// cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// This method is intended for use with a ZipFile that has been read from storage.
-        /// When creating a new ZipFile, this method will work only after the ZipArchive has
-        /// been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip
-        /// archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been
-        /// saved will deliver undefined results.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        /// Thrown if selectionCriteria has an invalid syntax.
-        /// </exception>
-        ///
-        /// <example>
-        /// <code>
-        /// using (ZipFile zip1 = ZipFile.Read(ZipFileName))
-        /// {
-        ///     var UpdatedPhotoShopFiles = zip1.SelectEntries("*.psd", "UpdatedFiles");
-        ///     foreach (ZipEntry e in UpdatedPhotoShopFiles)
-        ///     {
-        ///         // prompt for extract here
-        ///         if (WantExtract(e.FileName))
-        ///             e.Extract();
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip1 As ZipFile = ZipFile.Read(ZipFileName)
-        ///     Dim UpdatedPhotoShopFiles As ICollection(Of ZipEntry) = zip1.SelectEntries("*.psd", "UpdatedFiles")
-        ///     Dim e As ZipEntry
-        ///     For Each e In UpdatedPhotoShopFiles
-        ///         ' prompt for extract here
-        ///         If Me.WantExtract(e.FileName) Then
-        ///             e.Extract
-        ///         End If
-        ///     Next
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="selectionCriteria">the string that specifies which entries to select</param>
-        ///
-        /// <param name="directoryPathInArchive">
-        /// the directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        ///
-        /// <returns>a collection of ZipEntry objects that conform to the inclusion spec</returns>
-        public ICollection<ZipEntry> SelectEntries(String selectionCriteria, string directoryPathInArchive)
-        {
-            Ionic.FileSelector ff = new Ionic.FileSelector(selectionCriteria,
-                                                           AddDirectoryWillTraverseReparsePoints);
-            return ff.SelectEntries(this, directoryPathInArchive);
-        }
-
-
-
-        /// <summary>
-        /// Remove entries from the zipfile by specified criteria.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method allows callers to remove the collection of entries from the zipfile
-        /// that fit the specified criteria.  The criteria are described in a string format, and
-        /// can include patterns for the filename; constraints on the size of the entry;
-        /// constraints on the last modified, created, or last accessed time for the file
-        /// described by the entry; or the attributes of the entry.
-        /// </para>
-        ///
-        /// <para>
-        /// For details on the syntax for the selectionCriteria parameter, see <see
-        /// cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// This method is intended for use with a ZipFile that has been read from storage.
-        /// When creating a new ZipFile, this method will work only after the ZipArchive has
-        /// been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip
-        /// archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been
-        /// saved will deliver undefined results.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        /// Thrown if selectionCriteria has an invalid syntax.
-        /// </exception>
-        ///
-        /// <example>
-        /// This example removes all entries in a zip file that were modified prior to January 1st, 2008.
-        /// <code>
-        /// using (ZipFile zip1 = ZipFile.Read(ZipFileName))
-        /// {
-        ///     // remove all entries from prior to Jan 1, 2008
-        ///     zip1.RemoveEntries("mtime &lt; 2008-01-01");
-        ///     // don't forget to save the archive!
-        ///     zip1.Save();
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(ZipFileName)
-        ///     ' remove all entries from prior to Jan 1, 2008
-        ///     zip1.RemoveEntries("mtime &lt; 2008-01-01")
-        ///     ' do not forget to save the archive!
-        ///     zip1.Save
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="selectionCriteria">the string that specifies which entries to select</param>
-        /// <returns>the number of entries removed</returns>
-        public int RemoveSelectedEntries(String selectionCriteria)
-        {
-            var selection = this.SelectEntries(selectionCriteria);
-            this.RemoveEntries(selection);
-            return selection.Count;
-        }
-
-
-        /// <summary>
-        /// Remove entries from the zipfile by specified criteria, and within the specified
-        /// path in the archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// This method allows callers to remove the collection of entries from the zipfile
-        /// that fit the specified criteria.  The criteria are described in a string format, and
-        /// can include patterns for the filename; constraints on the size of the entry;
-        /// constraints on the last modified, created, or last accessed time for the file
-        /// described by the entry; or the attributes of the entry.
-        /// </para>
-        ///
-        /// <para>
-        /// For details on the syntax for the selectionCriteria parameter, see <see
-        /// cref="AddSelectedFiles(String)"/>.
-        /// </para>
-        ///
-        /// <para>
-        /// This method is intended for use with a ZipFile that has been read from storage.
-        /// When creating a new ZipFile, this method will work only after the ZipArchive has
-        /// been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip
-        /// archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been
-        /// saved will deliver undefined results.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.Exception">
-        /// Thrown if selectionCriteria has an invalid syntax.
-        /// </exception>
-        ///
-        /// <example>
-        /// <code>
-        /// using (ZipFile zip1 = ZipFile.Read(ZipFileName))
-        /// {
-        ///     // remove all entries from prior to Jan 1, 2008
-        ///     zip1.RemoveEntries("mtime &lt; 2008-01-01", "documents");
-        ///     // a call to ZipFile.Save will make the modifications permanent
-        ///     zip1.Save();
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(ZipFileName)
-        ///     ' remove all entries from prior to Jan 1, 2008
-        ///     zip1.RemoveEntries("mtime &lt; 2008-01-01", "documents")
-        ///     ' a call to ZipFile.Save will make the modifications permanent
-        ///     zip1.Save
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">the string that specifies which entries to select</param>
-        /// <param name="directoryPathInArchive">
-        /// the directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        /// <returns>the number of entries removed</returns>
-        public int RemoveSelectedEntries(String selectionCriteria, string directoryPathInArchive)
-        {
-            var selection = this.SelectEntries(selectionCriteria, directoryPathInArchive);
-            this.RemoveEntries(selection);
-            return selection.Count;
-        }
-
-
-        /// <summary>
-        /// Selects and Extracts a set of Entries from the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The entries are extracted into the current working directory.
-        /// </para>
-        ///
-        /// <para>
-        /// If any of the files to be extracted already exist, then the action taken is as
-        /// specified in the <see cref="ZipEntry.ExtractExistingFile"/> property on the
-        /// corresponding ZipEntry instance.  By default, the action taken in this case is to
-        /// throw an exception.
-        /// </para>
-        ///
-        /// <para>
-        /// For information on the syntax of the selectionCriteria string,
-        /// see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how extract all XML files modified after 15 January 2009.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipArchiveName))
-        /// {
-        ///   zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15");
-        /// }
-        /// </code>
-        /// </example>
-        /// <param name="selectionCriteria">the selection criteria for entries to extract.</param>
-        ///
-        /// <seealso cref="ExtractSelectedEntries(String,ExtractExistingFileAction)"/>
-        public void ExtractSelectedEntries(String selectionCriteria)
-        {
-            foreach (ZipEntry e in SelectEntries(selectionCriteria))
-            {
-                e.Password = _Password; // possibly null
-                e.Extract();
-            }
-        }
-
-
-        /// <summary>
-        /// Selects and Extracts a set of Entries from the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The entries are extracted into the current working directory. When extraction would would
-        /// overwrite an existing filesystem file, the action taken is as specified in the
-        /// <paramref name="extractExistingFile"/> parameter.
-        /// </para>
-        ///
-        /// <para>
-        /// For information on the syntax of the string describing the entry selection criteria,
-        /// see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how extract all XML files modified after 15 January 2009,
-        /// overwriting any existing files.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipArchiveName))
-        /// {
-        ///   zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15",
-        ///                              ExtractExistingFileAction.OverwriteSilently);
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">the selection criteria for entries to extract.</param>
-        ///
-        /// <param name="extractExistingFile">
-        /// The action to take if extraction would overwrite an existing file.
-        /// </param>
-        internal void ExtractSelectedEntries(String selectionCriteria, ExtractExistingFileAction extractExistingFile)
-        {
-            foreach (ZipEntry e in SelectEntries(selectionCriteria))
-            {
-                e.Password = _Password; // possibly null
-                e.Extract(extractExistingFile);
-            }
-        }
-
-
-        /// <summary>
-        /// Selects and Extracts a set of Entries from the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The entries are selected from the specified directory within the archive, and then
-        /// extracted into the current working directory.
-        /// </para>
-        ///
-        /// <para>
-        /// If any of the files to be extracted already exist, then the action taken is as
-        /// specified in the <see cref="ZipEntry.ExtractExistingFile"/> property on the
-        /// corresponding ZipEntry instance.  By default, the action taken in this case is to
-        /// throw an exception.
-        /// </para>
-        ///
-        /// <para>
-        /// For information on the syntax of the string describing the entry selection criteria,
-        /// see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how extract all XML files modified after 15 January 2009,
-        /// and writes them to the "unpack" directory.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipArchiveName))
-        /// {
-        ///   zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15","unpack");
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">the selection criteria for entries to extract.</param>
-        ///
-        /// <param name="directoryPathInArchive">
-        /// the directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        ///
-        /// <seealso cref="ExtractSelectedEntries(String,String,String,ExtractExistingFileAction)"/>
-        public void ExtractSelectedEntries(String selectionCriteria, String directoryPathInArchive)
-        {
-            foreach (ZipEntry e in SelectEntries(selectionCriteria, directoryPathInArchive))
-            {
-                e.Password = _Password; // possibly null
-                e.Extract();
-            }
-        }
-
-
-        /// <summary>
-        /// Selects and Extracts a set of Entries from the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The entries are extracted into the specified directory. If any of the files to be
-        /// extracted already exist, an exception will be thrown.
-        /// </para>
-        /// <para>
-        /// For information on the syntax of the string describing the entry selection criteria,
-        /// see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="selectionCriteria">the selection criteria for entries to extract.</param>
-        ///
-        /// <param name="directoryInArchive">
-        /// the directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        ///
-        /// <param name="extractDirectory">
-        /// the directory on the disk into which to extract. It will be created
-        /// if it does not exist.
-        /// </param>
-        public void ExtractSelectedEntries(String selectionCriteria, string directoryInArchive, string extractDirectory)
-        {
-            foreach (ZipEntry e in SelectEntries(selectionCriteria, directoryInArchive))
-            {
-                e.Password = _Password; // possibly null
-                e.Extract(extractDirectory);
-            }
-        }
-
-
-        /// <summary>
-        /// Selects and Extracts a set of Entries from the ZipFile.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        /// The entries are extracted into the specified directory. When extraction would would
-        /// overwrite an existing filesystem file, the action taken is as specified in the
-        /// <paramref name="extractExistingFile"/> parameter.
-        /// </para>
-        ///
-        /// <para>
-        /// For information on the syntax of the string describing the entry selection criteria,
-        /// see <see cref="AddSelectedFiles(String)" />.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how extract all files  with an XML extension or with  a size larger than 100,000 bytes,
-        /// and puts them in the unpack directory.  For any files that already exist in
-        /// that destination directory, they will not be overwritten.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipArchiveName))
-        /// {
-        ///   zip.ExtractSelectedEntries("name = *.xml  or  size &gt; 100000",
-        ///                              null,
-        ///                              "unpack",
-        ///                              ExtractExistingFileAction.DontOverwrite);
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="selectionCriteria">the selection criteria for entries to extract.</param>
-        ///
-        /// <param name="extractDirectory">
-        /// The directory on the disk into which to extract. It will be created if it does not exist.
-        /// </param>
-        ///
-        /// <param name="directoryPathInArchive">
-        /// The directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        ///
-        /// <param name="extractExistingFile">
-        /// The action to take if extraction would overwrite an existing file.
-        /// </param>
-        ///
-        internal void ExtractSelectedEntries(String selectionCriteria, string directoryPathInArchive, string extractDirectory, ExtractExistingFileAction extractExistingFile)
-        {
-            foreach (ZipEntry e in SelectEntries(selectionCriteria, directoryPathInArchive))
-            {
-                e.Password = _Password; // possibly null
-                e.Extract(extractDirectory, extractExistingFile);
-            }
-        }
-
-    }
-
-}
-
-
-
-namespace OfficeOpenXml.Packaging.Ionic
-{
-    internal abstract partial class SelectionCriterion
-    {
-        internal abstract bool Evaluate(ZipEntry entry);
-    }
-
-
-    internal partial class NameCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            // swap forward slashes in the entry.FileName for backslashes
-            string transformedFileName = entry.FileName.Replace("/", "\\");
-
-            return _Evaluate(transformedFileName);
-        }
-    }
-
-
-    internal partial class SizeCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            return _Evaluate(entry.UncompressedSize);
-        }
-    }
-
-    internal partial class TimeCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            DateTime x;
-            switch (Which)
-            {
-                case WhichTime.atime:
-                    x = entry.AccessedTime;
-                    break;
-                case WhichTime.mtime:
-                    x = entry.ModifiedTime;
-                    break;
-                case WhichTime.ctime:
-                    x = entry.CreationTime;
-                    break;
-                default: throw new ArgumentException("??time");
-            }
-            return _Evaluate(x);
-        }
-    }
-
-
-    internal partial class TypeCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            bool result = (ObjectType == 'D')
-                ? entry.IsDirectory
-                : !entry.IsDirectory;
-
-            if (Operator != ComparisonOperator.EqualTo)
-                result = !result;
-            return result;
-        }
-    }
-
-#if !SILVERLIGHT
-    internal partial class AttributesCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            FileAttributes fileAttrs = entry.Attributes;
-            return _Evaluate(fileAttrs);
-        }
-    }
-#endif
-
-    internal partial class CompoundCriterion : SelectionCriterion
-    {
-        internal override bool Evaluate(ZipEntry entry)
-        {
-            bool result = Left.Evaluate(entry);
-            switch (Conjunction)
-            {
-                case LogicalConjunction.AND:
-                    if (result)
-                        result = Right.Evaluate(entry);
-                    break;
-                case LogicalConjunction.OR:
-                    if (!result)
-                        result = Right.Evaluate(entry);
-                    break;
-                case LogicalConjunction.XOR:
-                    result ^= Right.Evaluate(entry);
-                    break;
-            }
-            return result;
-        }
-    }
-
-
-
-    internal partial class FileSelector
-    {
-        private bool Evaluate(ZipEntry entry)
-        {
-            bool result = _Criterion.Evaluate(entry);
-            return result;
-        }
-
-        /// <summary>
-        /// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        /// This method applies the criteria set in the FileSelector instance (as described in
-        /// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile.  Using this
-        /// method, for example, you can retrieve all entries from the given ZipFile that
-        /// have filenames ending in .txt.
-        /// </para>
-        ///
-        /// <para>
-        /// Normally, applications would not call this method directly.  This method is used
-        /// by the ZipFile class.
-        /// </para>
-        ///
-        /// <para>
-        /// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
-        /// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
-        /// description of the syntax of the SelectionCriteria string.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="zip">The ZipFile from which to retrieve entries.</param>
-        ///
-        /// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
-        public ICollection<ZipEntry> SelectEntries(ZipFile zip)
-        {
-            if (zip == null)
-                throw new ArgumentNullException("zip");
-
-            var list = new List<ZipEntry>();
-
-            foreach (ZipEntry e in zip)
-            {
-                if (this.Evaluate(e))
-                    list.Add(e);
-            }
-
-            return list;
-        }
-
-
-        /// <summary>
-        /// Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        /// This method applies the criteria set in the FileSelector instance (as described in
-        /// the <see cref="FileSelector.SelectionCriteria"/>) to the specified ZipFile.  Using this
-        /// method, for example, you can retrieve all entries from the given ZipFile that
-        /// have filenames ending in .txt.
-        /// </para>
-        ///
-        /// <para>
-        /// Normally, applications would not call this method directly.  This method is used
-        /// by the ZipFile class.
-        /// </para>
-        ///
-        /// <para>
-        /// This overload allows the selection of ZipEntry instances from the ZipFile to be restricted
-        /// to entries contained within a particular directory in the ZipFile.
-        /// </para>
-        ///
-        /// <para>
-        /// Using the appropriate SelectionCriteria, you can retrieve entries based on size,
-        /// time, and attributes. See <see cref="FileSelector.SelectionCriteria"/> for a
-        /// description of the syntax of the SelectionCriteria string.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="zip">The ZipFile from which to retrieve entries.</param>
-        ///
-        /// <param name="directoryPathInArchive">
-        /// the directory in the archive from which to select entries. If null, then
-        /// all directories in the archive are used.
-        /// </param>
-        ///
-        /// <returns>a collection of ZipEntry objects that conform to the criteria.</returns>
-        public ICollection<ZipEntry> SelectEntries(ZipFile zip, string directoryPathInArchive)
-        {
-            if (zip == null)
-                throw new ArgumentNullException("zip");
-
-            var list = new List<ZipEntry>();
-            // workitem 8559
-            string slashSwapped = (directoryPathInArchive == null) ? null : directoryPathInArchive.Replace("/", "\\");
-            // workitem 9174
-            if (slashSwapped != null)
-            {
-                while (slashSwapped.EndsWith("\\"))
-                    slashSwapped = slashSwapped.Substring(0, slashSwapped.Length - 1);
-            }
-            foreach (ZipEntry e in zip)
-            {
-                if (directoryPathInArchive == null || (Path.GetDirectoryName(e.FileName) == directoryPathInArchive)
-                    || (Path.GetDirectoryName(e.FileName) == slashSwapped)) // workitem 8559
-                    if (this.Evaluate(e))
-                        list.Add(e);
-            }
-
-            return list;
-        }
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.cs b/EPPlus/Packaging/DotNetZip/ZipFile.cs
deleted file mode 100644
index 7edaff5..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.cs
+++ /dev/null
@@ -1,3909 +0,0 @@
-// ZipFile.cs
-//
-// Copyright (c) 2006-2010 Dino Chiesa
-// All rights reserved.
-//
-// This module is part of DotNetZip, a zipfile class library.
-// The class library reads and writes zip files, according to the format
-// described by PKware, at:
-// http://www.pkware.com/business_and_developers/developer/popups/appnote.txt
-//
-//
-// There are other Zip class libraries available.
-//
-// - it is possible to read and write zip files within .NET via the J# runtime.
-//   But some people don't like to install the extra DLL, which is no longer
-//   supported by MS. And also, the J# libraries don't support advanced zip
-//   features, like ZIP64, spanned archives, or AES encryption.
-//
-// - There are third-party GPL and LGPL libraries available. Some people don't
-//   like the license, and some of them don't support all the ZIP features, like AES.
-//
-// - Finally, there are commercial tools (From ComponentOne, XCeed, etc).  But
-//   some people don't want to incur the cost.
-//
-// This alternative implementation is **not** GPL licensed. It is free of cost, and
-// does not require J#. It does require .NET 2.0.  It balances a good set of
-// features, with ease of use and speed of performance.
-//
-// This code is released under the Microsoft Public License .
-// See the License.txt for details.
-//
-//
-// NB: This implementation originally relied on the
-// System.IO.Compression.DeflateStream base class in the .NET Framework
-// v2.0 base class library, but now includes a managed-code port of Zlib.
-//
-// Thu, 08 Oct 2009  17:04
-//
-
-
-using System;
-using System.IO;
-using System.Collections.Generic;
-using Interop = System.Runtime.InteropServices;
-using OfficeOpenXml.Packaging.Ionic.Zlib;
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   The ZipFile type represents a zip archive file.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    ///   This is the main type in the DotNetZip class library. This class reads and
-    ///   writes zip files, as defined in the <see
-    ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specification
-    ///   for zip files described by PKWare</see>.  The compression for this
-    ///   implementation is provided by a managed-code version of Zlib, included with
-    ///   DotNetZip in the classes in the Ionic.Zlib namespace.
-    /// </para>
-    ///
-    /// <para>
-    ///   This class provides a general purpose zip file capability.  Use it to read,
-    ///   create, or update zip files.  When you want to create zip files using a
-    ///   <c>Stream</c> type to write the zip file, you may want to consider the <see
-    ///   cref="ZipOutputStream"/> class.
-    /// </para>
-    ///
-    /// <para>
-    ///   Both the <c>ZipOutputStream</c> class and the <c>ZipFile</c> class can
-    ///   be used to create zip files. Both of them support many of the common zip
-    ///   features, including Unicode, different compression methods and levels,
-    ///   and ZIP64. They provide very similar performance when creating zip
-    ///   files.
-    /// </para>
-    ///
-    /// <para>
-    ///   The <c>ZipFile</c> class is generally easier to use than
-    ///   <c>ZipOutputStream</c> and should be considered a higher-level interface.  For
-    ///   example, when creating a zip file via calls to the <c>PutNextEntry()</c> and
-    ///   <c>Write()</c> methods on the <c>ZipOutputStream</c> class, the caller is
-    ///   responsible for opening the file, reading the bytes from the file, writing
-    ///   those bytes into the <c>ZipOutputStream</c>, setting the attributes on the
-    ///   <c>ZipEntry</c>, and setting the created, last modified, and last accessed
-    ///   timestamps on the zip entry. All of these things are done automatically by a
-    ///   call to <see cref="ZipFile.AddFile(string,string)">ZipFile.AddFile()</see>.
-    ///   For this reason, the <c>ZipOutputStream</c> is generally recommended for use
-    ///   only when your application emits arbitrary data, not necessarily data from a
-    ///   filesystem file, directly into a zip file, and does so using a <c>Stream</c>
-    ///   metaphor.
-    /// </para>
-    ///
-    /// <para>
-    ///   Aside from the differences in programming model, there are other
-    ///   differences in capability between the two classes.
-    /// </para>
-    ///
-    /// <list type="bullet">
-    ///   <item>
-    ///     <c>ZipFile</c> can be used to read and extract zip files, in addition to
-    ///     creating zip files. <c>ZipOutputStream</c> cannot read zip files. If you want
-    ///     to use a stream to read zip files, check out the ZipInputStream class.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipOutputStream</c> does not support the creation of segmented or spanned
-    ///     zip files.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipOutputStream</c> cannot produce a self-extracting archive.
-    ///   </item>
-    /// </list>
-    ///
-    /// <para>
-    ///   Be aware that the <c>ZipFile</c> class implements the <see
-    ///   cref="System.IDisposable"/> interface.  In order for <c>ZipFile</c> to
-    ///   produce a valid zip file, you use use it within a using clause (<c>Using</c>
-    ///   in VB), or call the <c>Dispose()</c> method explicitly.  See the examples
-    ///   for how to employ a using clause.
-    /// </para>
-    ///
-    /// </remarks>
-    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d00005")]
-    [Interop.ComVisible(true)]
-#if !NETCF
-    [Interop.ClassInterface(Interop.ClassInterfaceType.AutoDispatch)]
-#endif
-    internal partial class ZipFile :
-    System.Collections.IEnumerable,
-    System.Collections.Generic.IEnumerable<ZipEntry>,
-    IDisposable
-    {
-
-        #region public properties
-
-        /// <summary>
-        /// Indicates whether to perform a full scan of the zip file when reading it.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   You almost never want to use this property.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading a zip file, if this flag is <c>true</c> (<c>True</c> in
-        ///   VB), the entire zip archive will be scanned and searched for entries.
-        ///   For large archives, this can take a very, long time. The much more
-        ///   efficient default behavior is to read the zip directory, which is
-        ///   stored at the end of the zip file. But, in some cases the directory is
-        ///   corrupted and you need to perform a full scan of the zip file to
-        ///   determine the contents of the zip file. This property lets you do
-        ///   that, when necessary.
-        /// </para>
-        ///
-        /// <para>
-        ///   This flag is effective only when calling <see
-        ///   cref="Initialize(string)"/>. Normally you would read a ZipFile with the
-        ///   static <see cref="ZipFile.Read(String)">ZipFile.Read</see>
-        ///   method. But you can't set the <c>FullScan</c> property on the
-        ///   <c>ZipFile</c> instance when you use a static factory method like
-        ///   <c>ZipFile.Read</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to read a zip file using the full scan approach,
-        ///   and then save it, thereby producing a corrected zip file.
-        ///
-        /// <code lang="C#">
-        /// using (var zip = new ZipFile())
-        /// {
-        ///     zip.FullScan = true;
-        ///     zip.Initialize(zipFileName);
-        ///     zip.Save(newName);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     zip.FullScan = True
-        ///     zip.Initialize(zipFileName)
-        ///     zip.Save(newName)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        public bool FullScan
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   Whether to sort the ZipEntries before saving the file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   The default is false.  If you have a large number of zip entries, the sort
-        ///   alone can consume significant time.
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code lang="C#">
-        /// using (var zip = new ZipFile())
-        /// {
-        ///     zip.AddFiles(filesToAdd);
-        ///     zip.SortEntriesBeforeSaving = true;
-        ///     zip.Save(name);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     zip.AddFiles(filesToAdd)
-        ///     zip.SortEntriesBeforeSaving = True
-        ///     zip.Save(name)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        public bool SortEntriesBeforeSaving
-        {
-            get;
-            set;
-        }
-
-
-
-        /// <summary>
-        ///   Indicates whether NTFS Reparse Points, like junctions, should be
-        ///   traversed during calls to <c>AddDirectory()</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   By default, calls to AddDirectory() will traverse NTFS reparse
-        ///   points, like mounted volumes, and directory junctions.  An example
-        ///   of a junction is the "My Music" directory in Windows Vista.  In some
-        ///   cases you may not want DotNetZip to traverse those directories.  In
-        ///   that case, set this property to false.
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code lang="C#">
-        /// using (var zip = new ZipFile())
-        /// {
-        ///     zip.AddDirectoryWillTraverseReparsePoints = false;
-        ///     zip.AddDirectory(dirToZip,"fodder");
-        ///     zip.Save(zipFileToCreate);
-        /// }
-        /// </code>
-        /// </example>
-        public bool AddDirectoryWillTraverseReparsePoints { get; set; }
-
-
-        /// <summary>
-        ///   Size of the IO buffer used while saving.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   First, let me say that you really don't need to bother with this.  It is
-        ///   here to allow for optimizations that you probably won't make! It will work
-        ///   fine if you don't set or get this property at all. Ok?
-        /// </para>
-        ///
-        /// <para>
-        ///   Now that we have <em>that</em> out of the way, the fine print: This
-        ///   property affects the size of the buffer that is used for I/O for each
-        ///   entry contained in the zip file. When a file is read in to be compressed,
-        ///   it uses a buffer given by the size here.  When you update a zip file, the
-        ///   data for unmodified entries is copied from the first zip file to the
-        ///   other, through a buffer given by the size here.
-        /// </para>
-        ///
-        /// <para>
-        ///   Changing the buffer size affects a few things: first, for larger buffer
-        ///   sizes, the memory used by the <c>ZipFile</c>, obviously, will be larger
-        ///   during I/O operations.  This may make operations faster for very much
-        ///   larger files.  Last, for any given entry, when you use a larger buffer
-        ///   there will be fewer progress events during I/O operations, because there's
-        ///   one progress event generated for each time the buffer is filled and then
-        ///   emptied.
-        /// </para>
-        ///
-        /// <para>
-        ///   The default buffer size is 8k.  Increasing the buffer size may speed
-        ///   things up as you compress larger files.  But there are no hard-and-fast
-        ///   rules here, eh?  You won't know til you test it.  And there will be a
-        ///   limit where ever larger buffers actually slow things down.  So as I said
-        ///   in the beginning, it's probably best if you don't set or get this property
-        ///   at all.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how you might set a large buffer size for efficiency when
-        /// dealing with zip entries that are larger than 1gb.
-        /// <code lang="C#">
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.SaveProgress += this.zip1_SaveProgress;
-        ///     zip.AddDirectory(directoryToZip, "");
-        ///     zip.UseZip64WhenSaving = Zip64Option.Always;
-        ///     zip.BufferSize = 65536*8; // 65536 * 8 = 512k
-        ///     zip.Save(ZipFileToCreate);
-        /// }
-        /// </code>
-        /// </example>
-
-        public int BufferSize
-        {
-            get { return _BufferSize; }
-            set { _BufferSize = value; }
-        }
-
-        /// <summary>
-        ///   Size of the work buffer to use for the ZLIB codec during compression.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     When doing ZLIB or Deflate compression, the library fills a buffer,
-        ///     then passes it to the compressor for compression. Then the library
-        ///     reads out the compressed bytes. This happens repeatedly until there
-        ///     is no more uncompressed data to compress. This property sets the
-        ///     size of the buffer that will be used for chunk-wise compression. In
-        ///     order for the setting to take effect, your application needs to set
-        ///     this property before calling one of the <c>ZipFile.Save()</c>
-        ///     overloads.
-        ///   </para>
-        ///   <para>
-        ///     Setting this affects the performance and memory efficiency of
-        ///     compression and decompression. For larger files, setting this to a
-        ///     larger size may improve compression performance, but the exact
-        ///     numbers vary depending on available memory, the size of the streams
-        ///     you are compressing, and a bunch of other variables. I don't have
-        ///     good firm recommendations on how to set it.  You'll have to test it
-        ///     yourself. Or just leave it alone and accept the default.
-        ///   </para>
-        /// </remarks>
-        public int CodecBufferSize
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   Indicates whether extracted files should keep their paths as
-        ///   stored in the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    This property affects Extraction.  It is not used when creating zip
-        ///    archives.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    With this property set to <c>false</c>, the default, extracting entries
-        ///    from a zip file will create files in the filesystem that have the full
-        ///    path associated to the entry within the zip file.  With this property set
-        ///    to <c>true</c>, extracting entries from the zip file results in files
-        ///    with no path: the folders are "flattened."
-        ///  </para>
-        ///
-        ///  <para>
-        ///    An example: suppose the zip file contains entries /directory1/file1.txt and
-        ///    /directory2/file2.txt.  With <c>FlattenFoldersOnExtract</c> set to false,
-        ///    the files created will be \directory1\file1.txt and \directory2\file2.txt.
-        ///    With the property set to true, the files created are file1.txt and file2.txt.
-        ///  </para>
-        ///
-        /// </remarks>
-        public bool FlattenFoldersOnExtract
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The compression strategy to use for all entries.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Set the Strategy used by the ZLIB-compatible compressor, when
-        ///   compressing entries using the DEFLATE method. Different compression
-        ///   strategies work better on different sorts of data. The strategy
-        ///   parameter can affect the compression ratio and the speed of
-        ///   compression but not the correctness of the compresssion.  For more
-        ///   information see <see
-        ///   cref="Ionic.Zlib.CompressionStrategy">Ionic.Zlib.CompressionStrategy</see>.
-        /// </remarks>
-        public CompressionStrategy Strategy
-        {
-            get { return _Strategy; }
-            set { _Strategy = value; }
-        }
-
-
-        /// <summary>
-        ///   The name of the <c>ZipFile</c>, on disk.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When the <c>ZipFile</c> instance was created by reading an archive using
-        ///   one of the <c>ZipFile.Read</c> methods, this property represents the name
-        ///   of the zip file that was read.  When the <c>ZipFile</c> instance was
-        ///   created by using the no-argument constructor, this value is <c>null</c>
-        ///   (<c>Nothing</c> in VB).
-        /// </para>
-        ///
-        /// <para>
-        ///   If you use the no-argument constructor, and you then explicitly set this
-        ///   property, when you call <see cref="ZipFile.Save()"/>, this name will
-        ///   specify the name of the zip file created.  Doing so is equivalent to
-        ///   calling <see cref="ZipFile.Save(String)"/>.  When instantiating a
-        ///   <c>ZipFile</c> by reading from a stream or byte array, the <c>Name</c>
-        ///   property remains <c>null</c>.  When saving to a stream, the <c>Name</c>
-        ///   property is implicitly set to <c>null</c>.
-        /// </para>
-        /// </remarks>
-        public string Name
-        {
-            get { return _name; }
-            set { _name = value; }
-        }
-
-
-        /// <summary>
-        ///   Sets the compression level to be used for entries subsequently added to
-        ///   the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    Varying the compression level used on entries can affect the
-        ///    size-vs-speed tradeoff when compression and decompressing data streams
-        ///    or files.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    As with some other properties on the <c>ZipFile</c> class, like <see
-        ///    cref="Password"/>, <see cref="Encryption"/>, and <see
-        ///    cref="ZipErrorAction"/>, setting this property on a <c>ZipFile</c>
-        ///    instance will cause the specified <c>CompressionLevel</c> to be used on all
-        ///    <see cref="ZipEntry"/> items that are subsequently added to the
-        ///    <c>ZipFile</c> instance. If you set this property after you have added
-        ///    items to the <c>ZipFile</c>, but before you have called <c>Save()</c>,
-        ///    those items will not use the specified compression level.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you do not set this property, the default compression level is used,
-        ///    which normally gives a good balance of compression efficiency and
-        ///    compression speed.  In some tests, using <c>BestCompression</c> can
-        ///    double the time it takes to compress, while delivering just a small
-        ///    increase in compression efficiency.  This behavior will vary with the
-        ///    type of data you compress.  If you are in doubt, just leave this setting
-        ///    alone, and accept the default.
-        ///  </para>
-        /// </remarks>
-        public OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel CompressionLevel
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The compression method for the zipfile.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     By default, the compression method is <c>CompressionMethod.Deflate.</c>
-        ///   </para>
-        /// </remarks>
-        /// <seealso cref="Ionic.Zip.CompressionMethod" />
-        internal Ionic.Zip.CompressionMethod CompressionMethod
-        {
-            get
-            {
-                return _compressionMethod;
-            }
-            set
-            {
-                _compressionMethod = value;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   A comment attached to the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This property is read/write. It allows the application to specify a
-        ///   comment for the <c>ZipFile</c>, or read the comment for the
-        ///   <c>ZipFile</c>.  After setting this property, changes are only made
-        ///   permanent when you call a <c>Save()</c> method.
-        /// </para>
-        ///
-        /// <para>
-        ///   According to <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see>, the comment is not encrypted, even if there is a
-        ///   password set on the zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   The specification does not describe how to indicate the encoding used
-        ///   on a comment string. Many "compliant" zip tools and libraries use
-        ///   IBM437 as the code page for comments; DotNetZip, too, follows that
-        ///   practice.  On the other hand, there are situations where you want a
-        ///   Comment to be encoded with something else, for example using code page
-        ///   950 "Big-5 Chinese". To fill that need, DotNetZip will encode the
-        ///   comment following the same procedure it follows for encoding
-        ///   filenames: (a) if <see cref="AlternateEncodingUsage"/> is
-        ///   <c>Never</c>, it uses the default encoding (IBM437). (b) if <see
-        ///   cref="AlternateEncodingUsage"/> is <c>Always</c>, it always uses the
-        ///   alternate encoding (<see cref="AlternateEncoding"/>). (c) if <see
-        ///   cref="AlternateEncodingUsage"/> is <c>AsNecessary</c>, it uses the
-        ///   alternate encoding only if the default encoding is not sufficient for
-        ///   encoding the comment - in other words if decoding the result does not
-        ///   produce the original string.  This decision is taken at the time of
-        ///   the call to <c>ZipFile.Save()</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   When creating a zip archive using this library, it is possible to change
-        ///   the value of <see cref="AlternateEncoding" /> between each
-        ///   entry you add, and between adding entries and the call to
-        ///   <c>Save()</c>. Don't do this.  It will likely result in a zip file that is
-        ///   not readable by any tool or application.  For best interoperability, leave
-        ///   <see cref="AlternateEncoding"/> alone, or specify it only
-        ///   once, before adding any entries to the <c>ZipFile</c> instance.
-        /// </para>
-        ///
-        /// </remarks>
-        public string Comment
-        {
-            get { return _Comment; }
-            set
-            {
-                _Comment = value;
-                _contentsChanged = true;
-            }
-        }
-
-
-
-
-        /// <summary>
-        ///   Specifies whether the Creation, Access, and Modified times for entries
-        ///   added to the zip file will be emitted in &#147;Windows format&#148;
-        ///   when the zip archive is saved.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   An application creating a zip archive can use this flag to explicitly
-        ///   specify that the file times for the entries should or should not be stored
-        ///   in the zip archive in the format used by Windows. By default this flag is
-        ///   <c>true</c>, meaning the Windows-format times are stored in the zip
-        ///   archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   When adding an entry from a file or directory, the Creation (<see
-        ///   cref="ZipEntry.CreationTime"/>), Access (<see
-        ///   cref="ZipEntry.AccessedTime"/>), and Modified (<see
-        ///   cref="ZipEntry.ModifiedTime"/>) times for the given entry are
-        ///   automatically set from the filesystem values. When adding an entry from a
-        ///   stream or string, all three values are implicitly set to
-        ///   <c>DateTime.Now</c>.  Applications can also explicitly set those times by
-        ///   calling <see cref="ZipEntry.SetEntryTimes(DateTime, DateTime,
-        ///   DateTime)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see> describes multiple ways to format these times in a
-        ///   zip file. One is the format Windows applications normally use: 100ns ticks
-        ///   since January 1, 1601 UTC.  The other is a format Unix applications typically
-        ///   use: seconds since January 1, 1970 UTC.  Each format can be stored in an
-        ///   "extra field" in the zip entry when saving the zip archive. The former
-        ///   uses an extra field with a Header Id of 0x000A, while the latter uses a
-        ///   header ID of 0x5455, although you probably don't need to know that.
-        /// </para>
-        ///
-        /// <para>
-        ///   Not all tools and libraries can interpret these fields.  Windows
-        ///   compressed folders is one that can read the Windows Format timestamps,
-        ///   while I believe <see href="http://www.info-zip.org/">the Infozip
-        ///   tools</see> can read the Unix format timestamps. Some tools and libraries
-        ///   may be able to read only one or the other. DotNetZip can read or write
-        ///   times in either or both formats.
-        /// </para>
-        ///
-        /// <para>
-        ///   The times stored are taken from <see cref="ZipEntry.ModifiedTime"/>, <see
-        ///   cref="ZipEntry.AccessedTime"/>, and <see cref="ZipEntry.CreationTime"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   The value set here applies to all entries subsequently added to the
-        ///   <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not mutually exclusive of the <see
-        ///   cref="EmitTimesInUnixFormatWhenSaving" /> property. It is possible and
-        ///   legal and valid to produce a zip file that contains timestamps encoded in
-        ///   the Unix format as well as in the Windows format, in addition to the <see
-        ///   cref="ZipEntry.LastModified">LastModified</see> time attached to each
-        ///   entry in the archive, a time that is always stored in "DOS format". And,
-        ///   notwithstanding the names PKWare uses for these time formats, any of them
-        ///   can be read and written by any computer, on any operating system.  But,
-        ///   there are no guarantees that a program running on Mac or Linux will
-        ///   gracefully handle a zip file with "Windows" formatted times, or that an
-        ///   application that does not use DotNetZip but runs on Windows will be able to
-        ///   handle file times in Unix format.
-        /// </para>
-        ///
-        /// <para>
-        ///   When in doubt, test.  Sorry, I haven't got a complete list of tools and
-        ///   which sort of timestamps they can use and will tolerate.  If you get any
-        ///   good information and would like to pass it on, please do so and I will
-        ///   include that information in this documentation.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example shows how to save a zip file that contains file timestamps
-        ///   in a format normally used by Unix.
-        /// <code lang="C#">
-        /// using (var zip = new ZipFile())
-        /// {
-        ///     // produce a zip file the Mac will like
-        ///     zip.EmitTimesInWindowsFormatWhenSaving = false;
-        ///     zip.EmitTimesInUnixFormatWhenSaving = true;
-        ///     zip.AddDirectory(directoryToZip, "files");
-        ///     zip.Save(outputFile);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     '' produce a zip file the Mac will like
-        ///     zip.EmitTimesInWindowsFormatWhenSaving = False
-        ///     zip.EmitTimesInUnixFormatWhenSaving = True
-        ///     zip.AddDirectory(directoryToZip, "files")
-        ///     zip.Save(outputFile)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="ZipEntry.EmitTimesInWindowsFormatWhenSaving" />
-        /// <seealso cref="EmitTimesInUnixFormatWhenSaving" />
-        public bool EmitTimesInWindowsFormatWhenSaving
-        {
-            get
-            {
-                return _emitNtfsTimes;
-            }
-            set
-            {
-                _emitNtfsTimes = value;
-            }
-        }
-
-
-        /// <summary>
-        /// Specifies whether the Creation, Access, and Modified times
-        /// for entries added to the zip file will be emitted in "Unix(tm)
-        /// format" when the zip archive is saved.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   An application creating a zip archive can use this flag to explicitly
-        ///   specify that the file times for the entries should or should not be stored
-        ///   in the zip archive in the format used by Unix. By default this flag is
-        ///   <c>false</c>, meaning the Unix-format times are not stored in the zip
-        ///   archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   When adding an entry from a file or directory, the Creation (<see
-        ///   cref="ZipEntry.CreationTime"/>), Access (<see
-        ///   cref="ZipEntry.AccessedTime"/>), and Modified (<see
-        ///   cref="ZipEntry.ModifiedTime"/>) times for the given entry are
-        ///   automatically set from the filesystem values. When adding an entry from a
-        ///   stream or string, all three values are implicitly set to DateTime.Now.
-        ///   Applications can also explicitly set those times by calling <see
-        ///   cref="ZipEntry.SetEntryTimes(DateTime, DateTime, DateTime)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see> describes multiple ways to format these times in a
-        ///   zip file. One is the format Windows applications normally use: 100ns ticks
-        ///   since January 1, 1601 UTC.  The other is a format Unix applications
-        ///   typically use: seconds since January 1, 1970 UTC.  Each format can be
-        ///   stored in an "extra field" in the zip entry when saving the zip
-        ///   archive. The former uses an extra field with a Header Id of 0x000A, while
-        ///   the latter uses a header ID of 0x5455, although you probably don't need to
-        ///   know that.
-        /// </para>
-        ///
-        /// <para>
-        ///   Not all tools and libraries can interpret these fields.  Windows
-        ///   compressed folders is one that can read the Windows Format timestamps,
-        ///   while I believe the <see href="http://www.info-zip.org/">Infozip</see>
-        ///   tools can read the Unix format timestamps. Some tools and libraries may be
-        ///   able to read only one or the other.  DotNetZip can read or write times in
-        ///   either or both formats.
-        /// </para>
-        ///
-        /// <para>
-        ///   The times stored are taken from <see cref="ZipEntry.ModifiedTime"/>, <see
-        ///   cref="ZipEntry.AccessedTime"/>, and <see cref="ZipEntry.CreationTime"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not mutually exclusive of the <see
-        ///   cref="EmitTimesInWindowsFormatWhenSaving" /> property. It is possible and
-        ///   legal and valid to produce a zip file that contains timestamps encoded in
-        ///   the Unix format as well as in the Windows format, in addition to the <see
-        ///   cref="ZipEntry.LastModified">LastModified</see> time attached to each
-        ///   entry in the zip archive, a time that is always stored in "DOS
-        ///   format". And, notwithstanding the names PKWare uses for these time
-        ///   formats, any of them can be read and written by any computer, on any
-        ///   operating system.  But, there are no guarantees that a program running on
-        ///   Mac or Linux will gracefully handle a zip file with "Windows" formatted
-        ///   times, or that an application that does not use DotNetZip but runs on
-        ///   Windows will be able to handle file times in Unix format.
-        /// </para>
-        ///
-        /// <para>
-        ///   When in doubt, test.  Sorry, I haven't got a complete list of tools and
-        ///   which sort of timestamps they can use and will tolerate.  If you get any
-        ///   good information and would like to pass it on, please do so and I will
-        ///   include that information in this documentation.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="ZipEntry.EmitTimesInUnixFormatWhenSaving" />
-        /// <seealso cref="EmitTimesInWindowsFormatWhenSaving" />
-        public bool EmitTimesInUnixFormatWhenSaving
-        {
-            get
-            {
-                return _emitUnixTimes;
-            }
-            set
-            {
-                _emitUnixTimes = value;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Indicates whether verbose output is sent to the <see
-        ///   cref="StatusMessageTextWriter"/> during <c>AddXxx()</c> and
-        ///   <c>ReadXxx()</c> operations.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This is a <em>synthetic</em> property.  It returns true if the <see
-        ///   cref="StatusMessageTextWriter"/> is non-null.
-        /// </remarks>
-        internal bool Verbose
-        {
-            get { return (_StatusMessageTextWriter != null); }
-        }
-
-
-        /// <summary>
-        ///   Returns true if an entry by the given name exists in the ZipFile.
-        /// </summary>
-        ///
-        /// <param name='name'>the name of the entry to find</param>
-        /// <returns>true if an entry with the given name exists; otherwise false.
-        /// </returns>
-        public bool ContainsEntry(string name)
-        {
-            // workitem 12534
-            return _entries.ContainsKey(SharedUtilities.NormalizePathForUseInZipFile(name));
-        }
-
-
-
-        /// <summary>
-        ///   Indicates whether to perform case-sensitive matching on the filename when
-        ///   retrieving entries in the zipfile via the string-based indexer.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   The default value is <c>false</c>, which means don't do case-sensitive
-        ///   matching. In other words, retrieving zip["ReadMe.Txt"] is the same as
-        ///   zip["readme.txt"].  It really makes sense to set this to <c>true</c> only
-        ///   if you are not running on Windows, which has case-insensitive
-        ///   filenames. But since this library is not built for non-Windows platforms,
-        ///   in most cases you should just leave this property alone.
-        /// </remarks>
-        public bool CaseSensitiveRetrieval
-        {
-            get
-            {
-                return _CaseSensitiveRetrieval;
-            }
-
-            set
-            {
-                // workitem 9868
-                if (value != _CaseSensitiveRetrieval)
-                {
-                    _CaseSensitiveRetrieval = value;
-                    _initEntriesDictionary();
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///   Indicates whether to encode entry filenames and entry comments using Unicode
-        ///   (UTF-8).
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The
-        ///   PKWare zip specification</see> provides for encoding file names and file
-        ///   comments in either the IBM437 code page, or in UTF-8.  This flag selects
-        ///   the encoding according to that specification.  By default, this flag is
-        ///   false, and filenames and comments are encoded into the zip file in the
-        ///   IBM437 codepage.  Setting this flag to true will specify that filenames
-        ///   and comments that cannot be encoded with IBM437 will be encoded with
-        ///   UTF-8.
-        /// </para>
-        ///
-        /// <para>
-        ///   Zip files created with strict adherence to the PKWare specification with
-        ///   respect to UTF-8 encoding can contain entries with filenames containing
-        ///   any combination of Unicode characters, including the full range of
-        ///   characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many other
-        ///   alphabets.  However, because at this time, the UTF-8 portion of the PKWare
-        ///   specification is not broadly supported by other zip libraries and
-        ///   utilities, such zip files may not be readable by your favorite zip tool or
-        ///   archiver. In other words, interoperability will decrease if you set this
-        ///   flag to true.
-        /// </para>
-        ///
-        /// <para>
-        ///   In particular, Zip files created with strict adherence to the PKWare
-        ///   specification with respect to UTF-8 encoding will not work well with
-        ///   Explorer in Windows XP or Windows Vista, because Windows compressed
-        ///   folders, as far as I know, do not support UTF-8 in zip files.  Vista can
-        ///   read the zip files, but shows the filenames incorrectly. Unpacking from
-        ///   Windows Vista Explorer will result in filenames that have rubbish
-        ///   characters in place of the high-order UTF-8 bytes.
-        /// </para>
-        ///
-        /// <para>
-        ///   Also, zip files that use UTF-8 encoding will not work well with Java
-        ///   applications that use the java.util.zip classes, as of v5.0 of the Java
-        ///   runtime. The Java runtime does not correctly implement the PKWare
-        ///   specification in this regard.
-        /// </para>
-        ///
-        /// <para>
-        ///   As a result, we have the unfortunate situation that "correct" behavior by
-        ///   the DotNetZip library with regard to Unicode encoding of filenames during
-        ///   zip creation will result in zip files that are readable by strictly
-        ///   compliant and current tools (for example the most recent release of the
-        ///   commercial WinZip tool); but these zip files will not be readable by
-        ///   various other tools or libraries, including Windows Explorer.
-        /// </para>
-        ///
-        /// <para>
-        ///   The DotNetZip library can read and write zip files with UTF8-encoded
-        ///   entries, according to the PKware spec.  If you use DotNetZip for both
-        ///   creating and reading the zip file, and you use UTF-8, there will be no
-        ///   loss of information in the filenames. For example, using a self-extractor
-        ///   created by this library will allow you to unpack files correctly with no
-        ///   loss of information in the filenames.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you do not set this flag, it will remain false.  If this flag is false,
-        ///   your <c>ZipFile</c> will encode all filenames and comments using the
-        ///   IBM437 codepage.  This can cause "loss of information" on some filenames,
-        ///   but the resulting zipfile will be more interoperable with other
-        ///   utilities. As an example of the loss of information, diacritics can be
-        ///   lost.  The o-tilde character will be down-coded to plain o.  The c with a
-        ///   cedilla (Unicode 0xE7) used in Portugese will be downcoded to a c.
-        ///   Likewise, the O-stroke character (Unicode 248), used in Danish and
-        ///   Norwegian, will be down-coded to plain o. Chinese characters cannot be
-        ///   represented in codepage IBM437; when using the default encoding, Chinese
-        ///   characters in filenames will be represented as ?. These are all examples
-        ///   of "information loss".
-        /// </para>
-        ///
-        /// <para>
-        ///   The loss of information associated to the use of the IBM437 encoding is
-        ///   inconvenient, and can also lead to runtime errors. For example, using
-        ///   IBM437, any sequence of 4 Chinese characters will be encoded as ????.  If
-        ///   your application creates a <c>ZipFile</c>, then adds two files, each with
-        ///   names of four Chinese characters each, this will result in a duplicate
-        ///   filename exception.  In the case where you add a single file with a name
-        ///   containing four Chinese characters, calling Extract() on the entry that
-        ///   has question marks in the filename will result in an exception, because
-        ///   the question mark is not legal for use within filenames on Windows.  These
-        ///   are just a few examples of the problems associated to loss of information.
-        /// </para>
-        ///
-        /// <para>
-        ///   This flag is independent of the encoding of the content within the entries
-        ///   in the zip file. Think of the zip file as a container - it supports an
-        ///   encoding.  Within the container are other "containers" - the file entries
-        ///   themselves.  The encoding within those entries is independent of the
-        ///   encoding of the zip archive container for those entries.
-        /// </para>
-        ///
-        /// <para>
-        ///   Rather than specify the encoding in a binary fashion using this flag, an
-        ///   application can specify an arbitrary encoding via the <see
-        ///   cref="ProvisionalAlternateEncoding"/> property.  Setting the encoding
-        ///   explicitly when creating zip archives will result in non-compliant zip
-        ///   files that, curiously, are fairly interoperable.  The challenge is, the
-        ///   PKWare specification does not provide for a way to specify that an entry
-        ///   in a zip archive uses a code page that is neither IBM437 nor UTF-8.
-        ///   Therefore if you set the encoding explicitly when creating a zip archive,
-        ///   you must take care upon reading the zip archive to use the same code page.
-        ///   If you get it wrong, the behavior is undefined and may result in incorrect
-        ///   filenames, exceptions, stomach upset, hair loss, and acne.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="ProvisionalAlternateEncoding"/>
-        [Obsolete("Beginning with v1.9.1.6 of DotNetZip, this property is obsolete.  It will be removed in a future version of the library. Your applications should  use AlternateEncoding and AlternateEncodingUsage instead.")]
-        public bool UseUnicodeAsNecessary
-        {
-            get
-            {
-                return (_alternateEncoding == System.Text.Encoding.GetEncoding("UTF-8")) &&
-                    (_alternateEncodingUsage == ZipOption.AsNecessary);
-            }
-            set
-            {
-                if (value)
-                {
-                    _alternateEncoding = System.Text.Encoding.GetEncoding("UTF-8");
-                    _alternateEncodingUsage = ZipOption.AsNecessary;
-
-                }
-                else
-                {
-                    _alternateEncoding = Ionic.Zip.ZipFile.DefaultEncoding;
-                    _alternateEncodingUsage = ZipOption.Never;
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///   Specify whether to use ZIP64 extensions when saving a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When creating a zip file, the default value for the property is <see
-        ///   cref="Zip64Option.Never"/>. <see cref="Zip64Option.AsNecessary"/> is
-        ///   safest, in the sense that you will not get an Exception if a pre-ZIP64
-        ///   limit is exceeded.
-        /// </para>
-        ///
-        /// <para>
-        ///   You may set the property at any time before calling Save().
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading a zip file via the <c>Zipfile.Read()</c> method, DotNetZip
-        ///   will properly read ZIP64-endowed zip archives, regardless of the value of
-        ///   this property.  DotNetZip will always read ZIP64 archives.  This property
-        ///   governs only whether DotNetZip will write them. Therefore, when updating
-        ///   archives, be careful about setting this property after reading an archive
-        ///   that may use ZIP64 extensions.
-        /// </para>
-        ///
-        /// <para>
-        ///   An interesting question is, if you have set this property to
-        ///   <c>AsNecessary</c>, and then successfully saved, does the resulting
-        ///   archive use ZIP64 extensions or not?  To learn this, check the <see
-        ///   cref="OutputUsedZip64"/> property, after calling <c>Save()</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Have you thought about
-        ///   <see href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">donating</see>?
-        /// </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="RequiresZip64"/>
-        internal Zip64Option UseZip64WhenSaving
-        {
-            get
-            {
-                return _zip64;
-            }
-            set
-            {
-                _zip64 = value;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Indicates whether the archive requires ZIP64 extensions.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This property is <c>null</c> (or <c>Nothing</c> in VB) if the archive has
-        ///   not been saved, and there are fewer than 65334 <c>ZipEntry</c> items
-        ///   contained in the archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <c>Value</c> is true if any of the following four conditions holds:
-        ///   the uncompressed size of any entry is larger than 0xFFFFFFFF; the
-        ///   compressed size of any entry is larger than 0xFFFFFFFF; the relative
-        ///   offset of any entry within the zip archive is larger than 0xFFFFFFFF; or
-        ///   there are more than 65534 entries in the archive.  (0xFFFFFFFF =
-        ///   4,294,967,295).  The result may not be known until a <c>Save()</c> is attempted
-        ///   on the zip archive.  The Value of this <see cref="System.Nullable"/>
-        ///   property may be set only AFTER one of the Save() methods has been called.
-        /// </para>
-        ///
-        /// <para>
-        ///   If none of the four conditions holds, and the archive has been saved, then
-        ///   the <c>Value</c> is false.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>Value</c> of false does not indicate that the zip archive, as saved,
-        ///   does not use ZIP64.  It merely indicates that ZIP64 is not required.  An
-        ///   archive may use ZIP64 even when not required if the <see
-        ///   cref="ZipFile.UseZip64WhenSaving"/> property is set to <see
-        ///   cref="Zip64Option.Always"/>, or if the <see
-        ///   cref="ZipFile.UseZip64WhenSaving"/> property is set to <see
-        ///   cref="Zip64Option.AsNecessary"/> and the output stream was not
-        ///   seekable. Use the <see cref="OutputUsedZip64"/> property to determine if
-        ///   the most recent <c>Save()</c> method resulted in an archive that utilized
-        ///   the ZIP64 extensions.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="UseZip64WhenSaving"/>
-        /// <seealso cref="OutputUsedZip64"/>
-        public Nullable<bool> RequiresZip64
-        {
-            get
-            {
-                if (_entries.Count > 65534)
-                    return new Nullable<bool>(true);
-
-                // If the <c>ZipFile</c> has not been saved or if the contents have changed, then
-                // it is not known if ZIP64 is required.
-                if (!_hasBeenSaved || _contentsChanged) return null;
-
-                // Whether ZIP64 is required is knowable.
-                foreach (ZipEntry e in _entries.Values)
-                {
-                    if (e.RequiresZip64.Value) return new Nullable<bool>(true);
-                }
-
-                return new Nullable<bool>(false);
-            }
-        }
-
-
-        /// <summary>
-        ///   Indicates whether the most recent <c>Save()</c> operation used ZIP64 extensions.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The use of ZIP64 extensions within an archive is not always necessary, and
-        ///   for interoperability concerns, it may be desired to NOT use ZIP64 if
-        ///   possible.  The <see cref="ZipFile.UseZip64WhenSaving"/> property can be
-        ///   set to use ZIP64 extensions only when necessary.  In those cases,
-        ///   Sometimes applications want to know whether a Save() actually used ZIP64
-        ///   extensions.  Applications can query this read-only property to learn
-        ///   whether ZIP64 has been used in a just-saved <c>ZipFile</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   The value is <c>null</c> (or <c>Nothing</c> in VB) if the archive has not
-        ///   been saved.
-        /// </para>
-        ///
-        /// <para>
-        ///   Non-null values (<c>HasValue</c> is true) indicate whether ZIP64
-        ///   extensions were used during the most recent <c>Save()</c> operation.  The
-        ///   ZIP64 extensions may have been used as required by any particular entry
-        ///   because of its uncompressed or compressed size, or because the archive is
-        ///   larger than 4294967295 bytes, or because there are more than 65534 entries
-        ///   in the archive, or because the <c>UseZip64WhenSaving</c> property was set
-        ///   to <see cref="Zip64Option.Always"/>, or because the
-        ///   <c>UseZip64WhenSaving</c> property was set to <see
-        ///   cref="Zip64Option.AsNecessary"/> and the output stream was not seekable.
-        ///   The value of this property does not indicate the reason the ZIP64
-        ///   extensions were used.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <seealso cref="UseZip64WhenSaving"/>
-        /// <seealso cref="RequiresZip64"/>
-        public Nullable<bool> OutputUsedZip64
-        {
-            get
-            {
-                return _OutputUsesZip64;
-            }
-        }
-
-
-        /// <summary>
-        ///   Indicates whether the most recent <c>Read()</c> operation read a zip file that uses
-        ///   ZIP64 extensions.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   This property will return null (Nothing in VB) if you've added an entry after reading
-        ///   the zip file.
-        /// </remarks>
-        public Nullable<bool> InputUsesZip64
-        {
-            get
-            {
-                if (_entries.Count > 65534)
-                    return true;
-
-                foreach (ZipEntry e in this)
-                {
-                    // if any entry was added after reading the zip file, then the result is null
-                    if (e.Source != ZipEntrySource.ZipFile) return null;
-
-                    // if any entry read from the zip used zip64, then the result is true
-                    if (e._InputUsesZip64) return true;
-                }
-                return false;
-            }
-        }
-
-
-        /// <summary>
-        ///   The text encoding to use when writing new entries to the <c>ZipFile</c>,
-        ///   for those entries that cannot be encoded with the default (IBM437)
-        ///   encoding; or, the text encoding that was used when reading the entries
-        ///   from the <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its
-        ///   zip specification</see>, PKWare describes two options for encoding
-        ///   filenames and comments: using IBM437 or UTF-8.  But, some archiving tools
-        ///   or libraries do not follow the specification, and instead encode
-        ///   characters using the system default code page.  For example, WinRAR when
-        ///   run on a machine in Shanghai may encode filenames with the Big-5 Chinese
-        ///   (950) code page.  This behavior is contrary to the Zip specification, but
-        ///   it occurs anyway.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using DotNetZip to write zip archives that will be read by one of
-        ///   these other archivers, set this property to specify the code page to use
-        ///   when encoding the <see cref="ZipEntry.FileName"/> and <see
-        ///   cref="ZipEntry.Comment"/> for each <c>ZipEntry</c> in the zip file, for
-        ///   values that cannot be encoded with the default codepage for zip files,
-        ///   IBM437.  This is why this property is "provisional".  In all cases, IBM437
-        ///   is used where possible, in other words, where no loss of data would
-        ///   result. It is possible, therefore, to have a given entry with a
-        ///   <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with the
-        ///   specified "provisional" codepage.
-        /// </para>
-        ///
-        /// <para>
-        ///   Be aware that a zip file created after you've explicitly set the <see
-        ///   cref="ProvisionalAlternateEncoding" /> property to a value other than
-        ///   IBM437 may not be compliant to the PKWare specification, and may not be
-        ///   readable by compliant archivers.  On the other hand, many (most?)
-        ///   archivers are non-compliant and can read zip files created in arbitrary
-        ///   code pages.  The trick is to use or specify the proper codepage when
-        ///   reading the zip.
-        /// </para>
-        ///
-        /// <para>
-        ///   When creating a zip archive using this library, it is possible to change
-        ///   the value of <see cref="ProvisionalAlternateEncoding" /> between each
-        ///   entry you add, and between adding entries and the call to
-        ///   <c>Save()</c>. Don't do this. It will likely result in a zipfile that is
-        ///   not readable.  For best interoperability, either leave <see
-        ///   cref="ProvisionalAlternateEncoding" /> alone, or specify it only once,
-        ///   before adding any entries to the <c>ZipFile</c> instance.  There is one
-        ///   exception to this recommendation, described later.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using an arbitrary, non-UTF8 code page for encoding, there is no
-        ///   standard way for the creator application - whether DotNetZip, WinZip,
-        ///   WinRar, or something else - to formally specify in the zip file which
-        ///   codepage has been used for the entries. As a result, readers of zip files
-        ///   are not able to inspect the zip file and determine the codepage that was
-        ///   used for the entries contained within it.  It is left to the application
-        ///   or user to determine the necessary codepage when reading zip files encoded
-        ///   this way.  In other words, if you explicitly specify the codepage when you
-        ///   create the zipfile, you must explicitly specify the same codepage when
-        ///   reading the zipfile.
-        /// </para>
-        ///
-        /// <para>
-        ///   The way you specify the code page to use when reading a zip file varies
-        ///   depending on the tool or library you use to read the zip.  In DotNetZip,
-        ///   you use a ZipFile.Read() method that accepts an encoding parameter.  It
-        ///   isn't possible with Windows Explorer, as far as I know, to specify an
-        ///   explicit codepage to use when reading a zip.  If you use an incorrect
-        ///   codepage when reading a zipfile, you will get entries with filenames that
-        ///   are incorrect, and the incorrect filenames may even contain characters
-        ///   that are not legal for use within filenames in Windows. Extracting entries
-        ///   with illegal characters in the filenames will lead to exceptions. It's too
-        ///   bad, but this is just the way things are with code pages in zip
-        ///   files. Caveat Emptor.
-        /// </para>
-        ///
-        /// <para>
-        ///   Example: Suppose you create a zipfile that contains entries with
-        ///   filenames that have Danish characters.  If you use <see
-        ///   cref="ProvisionalAlternateEncoding" /> equal to "iso-8859-1" (cp 28591),
-        ///   the filenames will be correctly encoded in the zip.  But, to read that
-        ///   zipfile correctly, you have to specify the same codepage at the time you
-        ///   read it. If try to read that zip file with Windows Explorer or another
-        ///   application that is not flexible with respect to the codepage used to
-        ///   decode filenames in zipfiles, you will get a filename like "Inf�.txt".
-        /// </para>
-        ///
-        /// <para>
-        ///   When using DotNetZip to read a zip archive, and the zip archive uses an
-        ///   arbitrary code page, you must specify the encoding to use before or when
-        ///   the <c>Zipfile</c> is READ.  This means you must use a <c>ZipFile.Read()</c>
-        ///   method that allows you to specify a System.Text.Encoding parameter.  Setting
-        ///   the ProvisionalAlternateEncoding property after your application has read in
-        ///   the zip archive will not affect the entry names of entries that have already
-        ///   been read in.
-        /// </para>
-        ///
-        /// <para>
-        ///   And now, the exception to the rule described above.  One strategy for
-        ///   specifying the code page for a given zip file is to describe the code page
-        ///   in a human-readable form in the Zip comment. For example, the comment may
-        ///   read "Entries in this archive are encoded in the Big5 code page".  For
-        ///   maximum interoperability, the zip comment in this case should be encoded
-        ///   in the default, IBM437 code page.  In this case, the zip comment is
-        ///   encoded using a different page than the filenames.  To do this, Specify
-        ///   <c>ProvisionalAlternateEncoding</c> to your desired region-specific code
-        ///   page, once before adding any entries, and then reset
-        ///   <c>ProvisionalAlternateEncoding</c> to IBM437 before setting the <see
-        ///   cref="Comment"/> property and calling Save().
-        /// </para>
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example shows how to read a zip file using the Big-5 Chinese code page
-        /// (950), and extract each entry in the zip file.  For this code to work as
-        /// desired, the <c>Zipfile</c> must have been created using the big5 code page
-        /// (CP950). This is typical, for example, when using WinRar on a machine with
-        /// CP950 set as the default code page.  In that case, the names of entries
-        /// within the Zip archive will be stored in that code page, and reading the zip
-        /// archive must be done using that code page.  If the application did not use
-        /// the correct code page in <c>ZipFile.Read()</c>, then names of entries within the
-        /// zip archive would not be correctly retrieved.
-        /// <code>
-        /// using (var zip = ZipFile.Read(zipFileName, System.Text.Encoding.GetEncoding("big5")))
-        /// {
-        ///     // retrieve and extract an entry using a name encoded with CP950
-        ///     zip[MyDesiredEntry].Extract("unpack");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(ZipToExtract, System.Text.Encoding.GetEncoding("big5"))
-        ///     ' retrieve and extract an entry using a name encoded with CP950
-        ///     zip(MyDesiredEntry).Extract("unpack")
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.DefaultEncoding">DefaultEncoding</seealso>
-        [Obsolete("use AlternateEncoding instead.")]
-        public System.Text.Encoding ProvisionalAlternateEncoding
-        {
-            get
-            {
-                if (_alternateEncodingUsage == ZipOption.AsNecessary)
-                    return _alternateEncoding;
-                return null;
-            }
-            set
-            {
-                _alternateEncoding = value;
-                _alternateEncodingUsage = ZipOption.AsNecessary;
-            }
-        }
-
-
-        /// <summary>
-        ///   A Text Encoding to use when encoding the filenames and comments for
-        ///   all the ZipEntry items, during a ZipFile.Save() operation.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Whether the encoding specified here is used during the save depends
-        ///     on <see cref="AlternateEncodingUsage"/>.
-        ///   </para>
-        /// </remarks>
-        public System.Text.Encoding AlternateEncoding
-        {
-            get
-            {
-                return _alternateEncoding;
-            }
-            set
-            {
-                _alternateEncoding = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   A flag that tells if and when this instance should apply
-        ///   AlternateEncoding to encode the filenames and comments associated to
-        ///   of ZipEntry objects contained within this instance.
-        /// </summary>
-        internal ZipOption AlternateEncodingUsage
-        {
-            get
-            {
-                return _alternateEncodingUsage;
-            }
-            set
-            {
-                _alternateEncodingUsage = value;
-            }
-        }
-
-
-        /// <summary>
-        /// The default text encoding used in zip archives.  It is numeric 437, also
-        /// known as IBM437.
-        /// </summary>
-        /// <seealso cref="Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>
-        public static System.Text.Encoding DefaultEncoding
-        {
-            get
-            {
-                return _defaultEncoding;
-            }
-        }
-
-
-        /// <summary>
-        /// Gets or sets the <c>TextWriter</c> to which status messages are delivered
-        /// for the instance.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   If the TextWriter is set to a non-null value, then verbose output is sent
-        ///   to the <c>TextWriter</c> during <c>Add</c><c>, Read</c><c>, Save</c> and
-        ///   <c>Extract</c> operations.  Typically, console applications might use
-        ///   <c>Console.Out</c> and graphical or headless applications might use a
-        ///   <c>System.IO.StringWriter</c>. The output of this is suitable for viewing
-        ///   by humans.
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   In this example, a console application instantiates a <c>ZipFile</c>, then
-        ///   sets the <c>StatusMessageTextWriter</c> to <c>Console.Out</c>.  At that
-        ///   point, all verbose status messages for that <c>ZipFile</c> are sent to the
-        ///   console.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// using (ZipFile zip= ZipFile.Read(FilePath))
-        /// {
-        ///   zip.StatusMessageTextWriter= System.Console.Out;
-        ///   // messages are sent to the console during extraction
-        ///   zip.ExtractAll();
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(FilePath)
-        ///   zip.StatusMessageTextWriter= System.Console.Out
-        ///   'Status Messages will be sent to the console during extraction
-        ///   zip.ExtractAll()
-        /// End Using
-        /// </code>
-        ///
-        /// <para>
-        ///   In this example, a Windows Forms application instantiates a
-        ///   <c>ZipFile</c>, then sets the <c>StatusMessageTextWriter</c> to a
-        ///   <c>StringWriter</c>.  At that point, all verbose status messages for that
-        ///   <c>ZipFile</c> are sent to the <c>StringWriter</c>.
-        /// </para>
-        ///
-        /// <code lang="C#">
-        /// var sw = new System.IO.StringWriter();
-        /// using (ZipFile zip= ZipFile.Read(FilePath))
-        /// {
-        ///   zip.StatusMessageTextWriter= sw;
-        ///   zip.ExtractAll();
-        /// }
-        /// Console.WriteLine("{0}", sw.ToString());
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim sw as New System.IO.StringWriter
-        /// Using zip As ZipFile = ZipFile.Read(FilePath)
-        ///   zip.StatusMessageTextWriter= sw
-        ///   zip.ExtractAll()
-        /// End Using
-        /// 'Status Messages are now available in sw
-        ///
-        /// </code>
-        /// </example>
-        public TextWriter StatusMessageTextWriter
-        {
-            get { return _StatusMessageTextWriter; }
-            set { _StatusMessageTextWriter = value; }
-        }
-
-
-
-
-        /// <summary>
-        ///   Gets or sets the name for the folder to store the temporary file
-        ///   this library writes when saving a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This library will create a temporary file when saving a Zip archive to a
-        ///   file.  This file is written when calling one of the <c>Save()</c> methods
-        ///   that does not save to a stream, or one of the <c>SaveSelfExtractor()</c>
-        ///   methods.
-        /// </para>
-        ///
-        /// <para>
-        ///   By default, the library will create the temporary file in the directory
-        ///   specified for the file itself, via the <see cref="Name"/> property or via
-        ///   the <see cref="ZipFile.Save(String)"/> method.
-        /// </para>
-        ///
-        /// <para>
-        ///   Setting this property allows applications to override this default
-        ///   behavior, so that the library will create the temporary file in the
-        ///   specified folder. For example, to have the library create the temporary
-        ///   file in the current working directory, regardless where the <c>ZipFile</c>
-        ///   is saved, specfy ".".  To revert to the default behavior, set this
-        ///   property to <c>null</c> (<c>Nothing</c> in VB).
-        /// </para>
-        ///
-        /// <para>
-        ///   When setting the property to a non-null value, the folder specified must
-        ///   exist; if it does not an exception is thrown.  The application should have
-        ///   write and delete permissions on the folder.  The permissions are not
-        ///   explicitly checked ahead of time; if the application does not have the
-        ///   appropriate rights, an exception will be thrown at the time <c>Save()</c>
-        ///   is called.
-        /// </para>
-        ///
-        /// <para>
-        ///   There is no temporary file created when reading a zip archive.  When
-        ///   saving to a Stream, there is no temporary file created.  For example, if
-        ///   the application is an ASP.NET application and calls <c>Save()</c>
-        ///   specifying the <c>Response.OutputStream</c> as the output stream, there is
-        ///   no temporary file created.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.IO.FileNotFoundException">
-        /// Thrown when setting the property if the directory does not exist.
-        /// </exception>
-        ///
-        public String TempFileFolder
-        {
-            get { return _TempFileFolder; }
-
-            set
-            {
-                _TempFileFolder = value;
-                if (value == null) return;
-
-                if (!Directory.Exists(value))
-                    throw new FileNotFoundException(String.Format("That directory ({0}) does not exist.", value));
-
-            }
-        }
-
-        /// <summary>
-        /// Sets the password to be used on the <c>ZipFile</c> instance.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When writing a zip archive, this password is applied to the entries, not
-        ///   to the zip archive itself. It applies to any <c>ZipEntry</c> subsequently
-        ///   added to the <c>ZipFile</c>, using one of the <c>AddFile</c>,
-        ///   <c>AddDirectory</c>, <c>AddEntry</c>, or <c>AddItem</c> methods, etc.
-        ///   When reading a zip archive, this property applies to any entry
-        ///   subsequently extracted from the <c>ZipFile</c> using one of the Extract
-        ///   methods on the <c>ZipFile</c> class.
-        /// </para>
-        ///
-        /// <para>
-        ///   When writing a zip archive, keep this in mind: though the password is set
-        ///   on the ZipFile object, according to the Zip spec, the "directory" of the
-        ///   archive - in other words the list of entries or files contained in the archive - is
-        ///   not encrypted with the password, or protected in any way.  If you set the
-        ///   Password property, the password actually applies to individual entries
-        ///   that are added to the archive, subsequent to the setting of this property.
-        ///   The list of filenames in the archive that is eventually created will
-        ///   appear in clear text, but the contents of the individual files are
-        ///   encrypted.  This is how Zip encryption works.
-        /// </para>
-        ///
-        /// <para>
-        ///   One simple way around this limitation is to simply double-wrap sensitive
-        ///   filenames: Store the files in a zip file, and then store that zip file
-        ///   within a second, "outer" zip file.  If you apply a password to the outer
-        ///   zip file, then readers will be able to see that the outer zip file
-        ///   contains an inner zip file.  But readers will not be able to read the
-        ///   directory or file list of the inner zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set the password on the <c>ZipFile</c>, and then add a set of files
-        ///   to the archive, then each entry is encrypted with that password.  You may
-        ///   also want to change the password between adding different entries. If you
-        ///   set the password, add an entry, then set the password to <c>null</c>
-        ///   (<c>Nothing</c> in VB), and add another entry, the first entry is
-        ///   encrypted and the second is not.  If you call <c>AddFile()</c>, then set
-        ///   the <c>Password</c> property, then call <c>ZipFile.Save</c>, the file
-        ///   added will not be password-protected, and no warning will be generated.
-        /// </para>
-        ///
-        /// <para>
-        ///   When setting the Password, you may also want to explicitly set the <see
-        ///   cref="Encryption"/> property, to specify how to encrypt the entries added
-        ///   to the ZipFile.  If you set the Password to a non-null value and do not
-        ///   set <see cref="Encryption"/>, then PKZip 2.0 ("Weak") encryption is used.
-        ///   This encryption is relatively weak but is very interoperable. If you set
-        ///   the password to a <c>null</c> value (<c>Nothing</c> in VB), Encryption is
-        ///   reset to None.
-        /// </para>
-        ///
-        /// <para>
-        ///   All of the preceding applies to writing zip archives, in other words when
-        ///   you use one of the Save methods.  To use this property when reading or an
-        ///   existing ZipFile, do the following: set the Password property on the
-        ///   <c>ZipFile</c>, then call one of the Extract() overloads on the <see
-        ///   cref="ZipEntry" />. In this case, the entry is extracted using the
-        ///   <c>Password</c> that is specified on the <c>ZipFile</c> instance. If you
-        ///   have not set the <c>Password</c> property, then the password is
-        ///   <c>null</c>, and the entry is extracted with no password.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set the Password property on the <c>ZipFile</c>, then call
-        ///   <c>Extract()</c> an entry that has not been encrypted with a password, the
-        ///   password is not used for that entry, and the <c>ZipEntry</c> is extracted
-        ///   as normal. In other words, the password is used only if necessary.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="ZipEntry"/> class also has a <see
-        ///   cref="ZipEntry.Password">Password</see> property.  It takes precedence
-        ///   over this property on the <c>ZipFile</c>.  Typically, you would use the
-        ///   per-entry Password when most entries in the zip archive use one password,
-        ///   and a few entries use a different password.  If all entries in the zip
-        ///   file use the same password, then it is simpler to just set this property
-        ///   on the <c>ZipFile</c> itself, whether creating a zip archive or extracting
-        ///   a zip archive.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example creates a zip file, using password protection for the
-        ///   entries, and then extracts the entries from the zip file.  When creating
-        ///   the zip file, the Readme.txt file is not protected with a password, but
-        ///   the other two are password-protected as they are saved. During extraction,
-        ///   each file is extracted with the appropriate password.
-        /// </para>
-        /// <code>
-        /// // create a file with encryption
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddFile("ReadMe.txt");
-        ///     zip.Password= "!Secret1";
-        ///     zip.AddFile("MapToTheSite-7440-N49th.png");
-        ///     zip.AddFile("2008-Regional-Sales-Report.pdf");
-        ///     zip.Save("EncryptedArchive.zip");
-        /// }
-        ///
-        /// // extract entries that use encryption
-        /// using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))
-        /// {
-        ///     zip.Password= "!Secret1";
-        ///     zip.ExtractAll("extractDir");
-        /// }
-        ///
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     zip.AddFile("ReadMe.txt")
-        ///     zip.Password = "123456!"
-        ///     zip.AddFile("MapToTheSite-7440-N49th.png")
-        ///     zip.Password= "!Secret1";
-        ///     zip.AddFile("2008-Regional-Sales-Report.pdf")
-        ///     zip.Save("EncryptedArchive.zip")
-        /// End Using
-        ///
-        ///
-        /// ' extract entries that use encryption
-        /// Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))
-        ///     zip.Password= "!Secret1"
-        ///     zip.ExtractAll("extractDir")
-        /// End Using
-        ///
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.Encryption">ZipFile.Encryption</seealso>
-        /// <seealso cref="ZipEntry.Password">ZipEntry.Password</seealso>
-        public String Password
-        {
-            set
-            {
-                _Password = value;
-                if (_Password == null)
-                {
-                    Encryption = EncryptionAlgorithm.None;
-                }
-                else if (Encryption == EncryptionAlgorithm.None)
-                {
-                    Encryption = EncryptionAlgorithm.PkzipWeak;
-                }
-            }
-            private get
-            {
-                return _Password;
-            }
-        }
-
-
-
-
-
-        /// <summary>
-        ///   The action the library should take when extracting a file that already
-        ///   exists.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property affects the behavior of the Extract methods (one of the
-        ///   <c>Extract()</c> or <c>ExtractWithPassword()</c> overloads), when
-        ///   extraction would would overwrite an existing filesystem file. If you do
-        ///   not set this property, the library throws an exception when extracting an
-        ///   entry would overwrite an existing file.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property has no effect when extracting to a stream, or when the file
-        ///   to be extracted does not already exist.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="ZipEntry.ExtractExistingFile"/>
-        internal ExtractExistingFileAction ExtractExistingFile
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The action the library should take when an error is encountered while
-        ///   opening or reading files as they are saved into a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    Errors can occur as a file is being saved to the zip archive.  For
-        ///    example, the File.Open may fail, or a File.Read may fail, because of
-        ///    lock conflicts or other reasons.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    The first problem might occur after having called AddDirectory() on a
-        ///    directory that contains a Clipper .dbf file; the file is locked by
-        ///    Clipper and cannot be opened for read by another process. An example of
-        ///    the second problem might occur when trying to zip a .pst file that is in
-        ///    use by Microsoft Outlook. Outlook locks a range on the file, which allows
-        ///    other processes to open the file, but not read it in its entirety.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    This property tells DotNetZip what you would like to do in the case of
-        ///    these errors.  The primary options are: <c>ZipErrorAction.Throw</c> to
-        ///    throw an exception (this is the default behavior if you don't set this
-        ///    property); <c>ZipErrorAction.Skip</c> to Skip the file for which there
-        ///    was an error and continue saving; <c>ZipErrorAction.Retry</c> to Retry
-        ///    the entry that caused the problem; or
-        ///    <c>ZipErrorAction.InvokeErrorEvent</c> to invoke an event handler.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    This property is implicitly set to <c>ZipErrorAction.InvokeErrorEvent</c>
-        ///    if you add a handler to the <see cref="ZipError" /> event.  If you set
-        ///    this property to something other than
-        ///    <c>ZipErrorAction.InvokeErrorEvent</c>, then the <c>ZipError</c>
-        ///    event is implicitly cleared.  What it means is you can set one or the
-        ///    other (or neither), depending on what you want, but you never need to set
-        ///    both.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    As with some other properties on the <c>ZipFile</c> class, like <see
-        ///    cref="Password"/>, <see cref="Encryption"/>, and <see
-        ///    cref="CompressionLevel"/>, setting this property on a <c>ZipFile</c>
-        ///    instance will cause the specified <c>ZipErrorAction</c> to be used on all
-        ///    <see cref="ZipEntry"/> items that are subsequently added to the
-        ///    <c>ZipFile</c> instance. If you set this property after you have added
-        ///    items to the <c>ZipFile</c>, but before you have called <c>Save()</c>,
-        ///    those items will not use the specified error handling action.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you want to handle any errors that occur with any entry in the zip
-        ///    file in the same way, then set this property once, before adding any
-        ///    entries to the zip archive.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you set this property to <c>ZipErrorAction.Skip</c> and you'd like to
-        ///    learn which files may have been skipped after a <c>Save()</c>, you can
-        ///    set the <see cref="StatusMessageTextWriter" /> on the ZipFile before
-        ///    calling <c>Save()</c>. A message will be emitted into that writer for
-        ///    each skipped file, if any.
-        ///  </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example shows how to tell DotNetZip to skip any files for which an
-        ///   error is generated during the Save().
-        /// <code lang="VB">
-        /// Public Sub SaveZipFile()
-        ///     Dim SourceFolder As String = "fodder"
-        ///     Dim DestFile As String =  "eHandler.zip"
-        ///     Dim sw as New StringWriter
-        ///     Using zipArchive As ZipFile = New ZipFile
-        ///         ' Tell DotNetZip to skip any files for which it encounters an error
-        ///         zipArchive.ZipErrorAction = ZipErrorAction.Skip
-        ///         zipArchive.StatusMessageTextWriter = sw
-        ///         zipArchive.AddDirectory(SourceFolder)
-        ///         zipArchive.Save(DestFile)
-        ///     End Using
-        ///     ' examine sw here to see any messages
-        /// End Sub
-        ///
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="ZipEntry.ZipErrorAction"/>
-        /// <seealso cref="Ionic.Zip.ZipFile.ZipError"/>
-
-        internal ZipErrorAction ZipErrorAction
-        {
-            get
-            {
-                if (ZipError != null)
-                    _zipErrorAction = ZipErrorAction.InvokeErrorEvent;
-                return _zipErrorAction;
-            }
-            set
-            {
-                _zipErrorAction = value;
-                if (_zipErrorAction != ZipErrorAction.InvokeErrorEvent && ZipError != null)
-                    ZipError = null;
-            }
-        }
-
-
-        /// <summary>
-        ///   The Encryption to use for entries added to the <c>ZipFile</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Set this when creating a zip archive, or when updating a zip archive. The
-        ///   specified Encryption is applied to the entries subsequently added to the
-        ///   <c>ZipFile</c> instance.  Applications do not need to set the
-        ///   <c>Encryption</c> property when reading or extracting a zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set this to something other than EncryptionAlgorithm.None, you
-        ///   will also need to set the <see cref="Password"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   As with some other properties on the <c>ZipFile</c> class, like <see
-        ///   cref="Password"/> and <see cref="CompressionLevel"/>, setting this
-        ///   property on a <c>ZipFile</c> instance will cause the specified
-        ///   <c>EncryptionAlgorithm</c> to be used on all <see cref="ZipEntry"/> items
-        ///   that are subsequently added to the <c>ZipFile</c> instance. In other
-        ///   words, if you set this property after you have added items to the
-        ///   <c>ZipFile</c>, but before you have called <c>Save()</c>, those items will
-        ///   not be encrypted or protected with a password in the resulting zip
-        ///   archive. To get a zip archive with encrypted entries, set this property,
-        ///   along with the <see cref="Password"/> property, before calling
-        ///   <c>AddFile</c>, <c>AddItem</c>, or <c>AddDirectory</c> (etc.) on the
-        ///   <c>ZipFile</c> instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you read a <c>ZipFile</c>, you can modify the <c>Encryption</c> on an
-        ///   encrypted entry, only by setting the <c>Encryption</c> property on the
-        ///   <c>ZipEntry</c> itself.  Setting the <c>Encryption</c> property on the
-        ///   <c>ZipFile</c>, once it has been created via a call to
-        ///   <c>ZipFile.Read()</c>, does not affect entries that were previously read.
-        /// </para>
-        ///
-        /// <para>
-        ///   For example, suppose you read a <c>ZipFile</c>, and there is an encrypted
-        ///   entry.  Setting the <c>Encryption</c> property on that <c>ZipFile</c> and
-        ///   then calling <c>Save()</c> on the <c>ZipFile</c> does not update the
-        ///   <c>Encryption</c> used for the entries in the archive.  Neither is an
-        ///   exception thrown. Instead, what happens during the <c>Save()</c> is that
-        ///   all previously existing entries are copied through to the new zip archive,
-        ///   with whatever encryption and password that was used when originally
-        ///   creating the zip archive. Upon re-reading that archive, to extract
-        ///   entries, applications should use the original password or passwords, if
-        ///   any.
-        /// </para>
-        ///
-        /// <para>
-        ///   Suppose an application reads a <c>ZipFile</c>, and there is an encrypted
-        ///   entry.  Setting the <c>Encryption</c> property on that <c>ZipFile</c> and
-        ///   then adding new entries (via <c>AddFile()</c>, <c>AddEntry()</c>, etc)
-        ///   and then calling <c>Save()</c> on the <c>ZipFile</c> does not update the
-        ///   <c>Encryption</c> on any of the entries that had previously been in the
-        ///   <c>ZipFile</c>.  The <c>Encryption</c> property applies only to the
-        ///   newly-added entries.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// <para>
-        ///   This example creates a zip archive that uses encryption, and then extracts
-        ///   entries from the archive.  When creating the zip archive, the ReadMe.txt
-        ///   file is zipped without using a password or encryption.  The other files
-        ///   use encryption.
-        /// </para>
-        ///
-        /// <code>
-        /// // Create a zip archive with AES Encryption.
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///     zip.AddFile("ReadMe.txt");
-        ///     zip.Encryption= EncryptionAlgorithm.WinZipAes256;
-        ///     zip.Password= "Top.Secret.No.Peeking!";
-        ///     zip.AddFile("7440-N49th.png");
-        ///     zip.AddFile("2008-Regional-Sales-Report.pdf");
-        ///     zip.Save("EncryptedArchive.zip");
-        /// }
-        ///
-        /// // Extract a zip archive that uses AES Encryption.
-        /// // You do not need to specify the algorithm during extraction.
-        /// using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))
-        /// {
-        ///     zip.Password= "Top.Secret.No.Peeking!";
-        ///     zip.ExtractAll("extractDirectory");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// ' Create a zip that uses Encryption.
-        /// Using zip As New ZipFile()
-        ///     zip.Encryption= EncryptionAlgorithm.WinZipAes256
-        ///     zip.Password= "Top.Secret.No.Peeking!"
-        ///     zip.AddFile("ReadMe.txt")
-        ///     zip.AddFile("7440-N49th.png")
-        ///     zip.AddFile("2008-Regional-Sales-Report.pdf")
-        ///     zip.Save("EncryptedArchive.zip")
-        /// End Using
-        ///
-        /// ' Extract a zip archive that uses AES Encryption.
-        /// ' You do not need to specify the algorithm during extraction.
-        /// Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))
-        ///     zip.Password= "Top.Secret.No.Peeking!"
-        ///     zip.ExtractAll("extractDirectory")
-        /// End Using
-        /// </code>
-        ///
-        /// </example>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.Password">ZipFile.Password</seealso>
-        /// <seealso cref="ZipEntry.Encryption">ZipEntry.Encryption</seealso>
-        internal EncryptionAlgorithm Encryption
-        {
-            get
-            {
-                return _Encryption;
-            }
-            set
-            {
-                if (value == EncryptionAlgorithm.Unsupported)
-                    throw new InvalidOperationException("You may not set Encryption to that value.");
-                _Encryption = value;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   A callback that allows the application to specify the compression level
-        ///   to use for entries subsequently added to the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   With this callback, the DotNetZip library allows the application to
-        ///   determine whether compression will be used, at the time of the
-        ///   <c>Save</c>. This may be useful if the application wants to favor
-        ///   speed over size, and wants to defer the decision until the time of
-        ///   <c>Save</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Typically applications set the <see cref="CompressionLevel"/> property on
-        ///   the <c>ZipFile</c> or on each <c>ZipEntry</c> to determine the level of
-        ///   compression used. This is done at the time the entry is added to the
-        ///   <c>ZipFile</c>. Setting the property to
-        ///   <c>Ionic.Zlib.CompressionLevel.None</c> means no compression will be used.
-        /// </para>
-        ///
-        /// <para>
-        ///   This callback allows the application to defer the decision on the
-        ///   <c>CompressionLevel</c> to use, until the time of the call to
-        ///   <c>ZipFile.Save()</c>. The callback is invoked once per <c>ZipEntry</c>,
-        ///   at the time the data for the entry is being written out as part of a
-        ///   <c>Save()</c> operation. The application can use whatever criteria it
-        ///   likes in determining the level to return.  For example, an application may
-        ///   wish that no .mp3 files should be compressed, because they are already
-        ///   compressed and the extra compression is not worth the CPU time incurred,
-        ///   and so can return <c>None</c> for all .mp3 entries.
-        /// </para>
-        ///
-        /// <para>
-        ///   The library determines whether compression will be attempted for an entry
-        ///   this way: If the entry is a zero length file, or a directory, no
-        ///   compression is used.  Otherwise, if this callback is set, it is invoked
-        ///   and the <c>CompressionLevel</c> is set to the return value. If this
-        ///   callback has not been set, then the previously set value for
-        ///   <c>CompressionLevel</c> is used.
-        /// </para>
-        ///
-        /// </remarks>
-        public SetCompressionCallback SetCompression
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        /// The maximum size of an output segment, when saving a split Zip file.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Set this to a non-zero value before calling <see cref="Save()"/> or <see
-        ///     cref="Save(String)"/> to specify that the ZipFile should be saved as a
-        ///     split archive, also sometimes called a spanned archive. Some also
-        ///     call them multi-file archives.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     A split zip archive is saved in a set of discrete filesystem files,
-        ///     rather than in a single file. This is handy when transmitting the
-        ///     archive in email or some other mechanism that has a limit to the size of
-        ///     each file.  The first file in a split archive will be named
-        ///     <c>basename.z01</c>, the second will be named <c>basename.z02</c>, and
-        ///     so on. The final file is named <c>basename.zip</c>. According to the zip
-        ///     specification from PKWare, the minimum value is 65536, for a 64k segment
-        ///     size. The maximum number of segments allows in a split archive is 99.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     The value of this property determines the maximum size of a split
-        ///     segment when writing a split archive.  For example, suppose you have a
-        ///     <c>ZipFile</c> that would save to a single file of 200k. If you set the
-        ///     <c>MaxOutputSegmentSize</c> to 65536 before calling <c>Save()</c>, you
-        ///     will get four distinct output files. On the other hand if you set this
-        ///     property to 256k, then you will get a single-file archive for that
-        ///     <c>ZipFile</c>.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     The size of each split output file will be as large as possible, up to
-        ///     the maximum size set here. The zip specification requires that some data
-        ///     fields in a zip archive may not span a split boundary, and an output
-        ///     segment may be smaller than the maximum if necessary to avoid that
-        ///     problem. Also, obviously the final segment of the archive may be smaller
-        ///     than the maximum segment size. Segments will never be larger than the
-        ///     value set with this property.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     You can save a split Zip file only when saving to a regular filesystem
-        ///     file. It's not possible to save a split zip file as a self-extracting
-        ///     archive, nor is it possible to save a split zip file to a stream. When
-        ///     saving to a SFX or to a Stream, this property is ignored.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     About interoperability: Split or spanned zip files produced by DotNetZip
-        ///     can be read by WinZip or PKZip, and vice-versa. Segmented zip files may
-        ///     not be readable by other tools, if those other tools don't support zip
-        ///     spanning or splitting.  When in doubt, test.  I don't believe Windows
-        ///     Explorer can extract a split archive.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     This property has no effect when reading a split archive. You can read
-        ///     a split archive in the normal way with DotNetZip.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     When saving a zip file, if you want a regular zip file rather than a
-        ///     split zip file, don't set this property, or set it to Zero.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     If you read a split archive, with <see cref="ZipFile.Read(string)"/> and
-        ///     then subsequently call <c>ZipFile.Save()</c>, unless you set this
-        ///     property before calling <c>Save()</c>, you will get a normal,
-        ///     single-file archive.
-        ///   </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="NumberOfSegmentsForMostRecentSave"/>
-        public Int32 MaxOutputSegmentSize
-        {
-            get
-            {
-                return _maxOutputSegmentSize;
-            }
-            set
-            {
-                if (value < 65536 && value != 0)
-                    throw new ZipException("The minimum acceptable segment size is 65536.");
-                _maxOutputSegmentSize = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   Returns the number of segments used in the most recent Save() operation.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This is normally zero, unless you have set the <see
-        ///     cref="MaxOutputSegmentSize"/> property.  If you have set <see
-        ///     cref="MaxOutputSegmentSize"/>, and then you save a file, after the call to
-        ///     Save() completes, you can read this value to learn the number of segments that
-        ///     were created.
-        ///   </para>
-        ///   <para>
-        ///     If you call Save("Archive.zip"), and it creates 5 segments, then you
-        ///     will have filesystem files named Archive.z01, Archive.z02, Archive.z03,
-        ///     Archive.z04, and Archive.zip, and the value of this property will be 5.
-        ///   </para>
-        /// </remarks>
-        /// <seealso cref="MaxOutputSegmentSize"/>
-        public Int32 NumberOfSegmentsForMostRecentSave
-        {
-            get
-            {
-                return unchecked((Int32)_numberOfSegmentsForMostRecentSave + 1);
-            }
-        }
-
-
-#if !NETCF
-        /// <summary>
-        ///   The size threshold for an entry, above which a parallel deflate is used.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        ///   <para>
-        ///     DotNetZip will use multiple threads to compress any ZipEntry,
-        ///     if the entry is larger than the given size.  Zero means "always
-        ///     use parallel deflate", while -1 means "never use parallel
-        ///     deflate". The default value for this property is 512k. Aside
-        ///     from the special values of 0 and 1, the minimum value is 65536.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     If the entry size cannot be known before compression, as with a
-        ///     read-forward stream, then Parallel deflate will never be
-        ///     performed, unless the value of this property is zero.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     A parallel deflate operations will speed up the compression of
-        ///     large files, on computers with multiple CPUs or multiple CPU
-        ///     cores.  For files above 1mb, on a dual core or dual-cpu (2p)
-        ///     machine, the time required to compress the file can be 70% of the
-        ///     single-threaded deflate.  For very large files on 4p machines the
-        ///     compression can be done in 30% of the normal time.  The downside
-        ///     is that parallel deflate consumes extra memory during the deflate,
-        ///     and the deflation is not as effective.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     Parallel deflate tends to yield slightly less compression when
-        ///     compared to as single-threaded deflate; this is because the original
-        ///     data stream is split into multiple independent buffers, each of which
-        ///     is compressed in parallel.  But because they are treated
-        ///     independently, there is no opportunity to share compression
-        ///     dictionaries.  For that reason, a deflated stream may be slightly
-        ///     larger when compressed using parallel deflate, as compared to a
-        ///     traditional single-threaded deflate. Sometimes the increase over the
-        ///     normal deflate is as much as 5% of the total compressed size. For
-        ///     larger files it can be as small as 0.1%.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     Multi-threaded compression does not give as much an advantage when
-        ///     using Encryption. This is primarily because encryption tends to slow
-        ///     down the entire pipeline. Also, multi-threaded compression gives less
-        ///     of an advantage when using lower compression levels, for example <see
-        ///     cref="Ionic.Zlib.CompressionLevel.BestSpeed"/>.  You may have to
-        ///     perform some tests to determine the best approach for your situation.
-        ///   </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="ParallelDeflateMaxBufferPairs"/>
-        ///
-        public long ParallelDeflateThreshold
-        {
-            set
-            {
-                if ((value != 0) && (value != -1) && (value < 64 * 1024))
-                    throw new ArgumentOutOfRangeException("ParallelDeflateThreshold should be -1, 0, or > 65536");
-                _ParallelDeflateThreshold = value;
-            }
-            get
-            {
-                return _ParallelDeflateThreshold;
-            }
-        }
-
-        /// <summary>
-        ///   The maximum number of buffer pairs to use when performing
-        ///   parallel compression.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property sets an upper limit on the number of memory
-        ///   buffer pairs to create when performing parallel
-        ///   compression.  The implementation of the parallel
-        ///   compression stream allocates multiple buffers to
-        ///   facilitate parallel compression.  As each buffer fills up,
-        ///   the stream uses <see
-        ///   cref="System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback)">
-        ///   ThreadPool.QueueUserWorkItem()</see> to compress those
-        ///   buffers in a background threadpool thread. After a buffer
-        ///   is compressed, it is re-ordered and written to the output
-        ///   stream.
-        /// </para>
-        ///
-        /// <para>
-        ///   A higher number of buffer pairs enables a higher degree of
-        ///   parallelism, which tends to increase the speed of compression on
-        ///   multi-cpu computers.  On the other hand, a higher number of buffer
-        ///   pairs also implies a larger memory consumption, more active worker
-        ///   threads, and a higher cpu utilization for any compression. This
-        ///   property enables the application to limit its memory consumption and
-        ///   CPU utilization behavior depending on requirements.
-        /// </para>
-        ///
-        /// <para>
-        ///   For each compression "task" that occurs in parallel, there are 2
-        ///   buffers allocated: one for input and one for output.  This property
-        ///   sets a limit for the number of pairs.  The total amount of storage
-        ///   space allocated for buffering will then be (N*S*2), where N is the
-        ///   number of buffer pairs, S is the size of each buffer (<see
-        ///   cref="BufferSize"/>).  By default, DotNetZip allocates 4 buffer
-        ///   pairs per CPU core, so if your machine has 4 cores, and you retain
-        ///   the default buffer size of 128k, then the
-        ///   ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer
-        ///   memory in total, or 4mb, in blocks of 128kb.  If you then set this
-        ///   property to 8, then the number will be 8 * 2 * 128kb of buffer
-        ///   memory, or 2mb.
-        /// </para>
-        ///
-        /// <para>
-        ///   CPU utilization will also go up with additional buffers, because a
-        ///   larger number of buffer pairs allows a larger number of background
-        ///   threads to compress in parallel. If you find that parallel
-        ///   compression is consuming too much memory or CPU, you can adjust this
-        ///   value downward.
-        /// </para>
-        ///
-        /// <para>
-        ///   The default value is 16. Different values may deliver better or
-        ///   worse results, depending on your priorities and the dynamic
-        ///   performance characteristics of your storage and compute resources.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not the number of buffer pairs to use; it is an
-        ///   upper limit. An illustration: Suppose you have an application that
-        ///   uses the default value of this property (which is 16), and it runs
-        ///   on a machine with 2 CPU cores. In that case, DotNetZip will allocate
-        ///   4 buffer pairs per CPU core, for a total of 8 pairs.  The upper
-        ///   limit specified by this property has no effect.
-        /// </para>
-        ///
-        /// <para>
-        ///   The application can set this value at any time
-        ///   before calling <c>ZipFile.Save()</c>.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="ParallelDeflateThreshold"/>
-        ///
-        public int ParallelDeflateMaxBufferPairs
-        {
-            get
-            {
-                return _maxBufferPairs;
-            }
-            set
-            {
-                if (value < 4)
-                    throw new ArgumentOutOfRangeException("ParallelDeflateMaxBufferPairs",
-                                                "Value must be 4 or greater.");
-                _maxBufferPairs = value;
-            }
-        }
-#endif
-
-
-        /// <summary>Provides a string representation of the instance.</summary>
-        /// <returns>a string representation of the instance.</returns>
-        public override String ToString()
-        {
-            return String.Format("ZipFile::{0}", Name);
-        }
-
-
-        /// <summary>
-        /// Returns the version number on the DotNetZip assembly.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///     This property is exposed as a convenience.  Callers could also get the
-        ///     version value by retrieving GetName().Version on the
-        ///     System.Reflection.Assembly object pointing to the DotNetZip
-        ///     assembly. But sometimes it is not clear which assembly is being loaded.
-        ///     This property makes it clear.
-        ///   </para>
-        ///   <para>
-        ///     This static property is primarily useful for diagnostic purposes.
-        ///   </para>
-        /// </remarks>
-        public static System.Version LibraryVersion
-        {
-            get
-            {
-                return System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
-            }
-        }
-
-        internal void NotifyEntryChanged()
-        {
-            _contentsChanged = true;
-        }
-
-
-        internal Stream StreamForDiskNumber(uint diskNumber)
-        {
-            if (diskNumber + 1 == this._diskNumberWithCd ||
-                (diskNumber == 0 && this._diskNumberWithCd == 0))
-            {
-                //return (this.ReadStream as FileStream);
-                return this.ReadStream;
-            }
-            return ZipSegmentedStream.ForReading(this._readName ?? this._name,
-                                                 diskNumber, _diskNumberWithCd);
-        }
-
-
-
-        // called by ZipEntry in ZipEntry.Extract(), when there is no stream set for the
-        // ZipEntry.
-        internal void Reset(bool whileSaving)
-        {
-            if (_JustSaved)
-            {
-                // read in the just-saved zip archive
-                using (ZipFile x = new ZipFile())
-                {
-                    // workitem 10735
-                    x._readName = x._name = whileSaving
-                        ? (this._readName ?? this._name)
-                        : this._name;
-                    x.AlternateEncoding = this.AlternateEncoding;
-                    x.AlternateEncodingUsage = this.AlternateEncodingUsage;
-                    ReadIntoInstance(x);
-                    // copy the contents of the entries.
-                    // cannot just replace the entries - the app may be holding them
-                    foreach (ZipEntry e1 in x)
-                    {
-                        foreach (ZipEntry e2 in this)
-                        {
-                            if (e1.FileName == e2.FileName)
-                            {
-                                e2.CopyMetaData(e1);
-                                break;
-                            }
-                        }
-                    }
-                }
-                _JustSaved = false;
-            }
-        }
-
-
-        #endregion
-
-        #region Constructors
-
-        /// <summary>
-        ///   Creates a new <c>ZipFile</c> instance, using the specified filename.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Applications can use this constructor to create a new ZipFile for writing,
-        ///   or to slurp in an existing zip archive for read and update purposes.
-        /// </para>
-        ///
-        /// <para>
-        ///   To create a new zip archive, an application can call this constructor,
-        ///   passing the name of a file that does not exist.  The name may be a fully
-        ///   qualified path. Then the application can add directories or files to the
-        ///   <c>ZipFile</c> via <c>AddDirectory()</c>, <c>AddFile()</c>, <c>AddItem()</c>
-        ///   and then write the zip archive to the disk by calling <c>Save()</c>. The
-        ///   zip file is not actually opened and written to the disk until the
-        ///   application calls <c>ZipFile.Save()</c>.  At that point the new zip file
-        ///   with the given name is created.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you won't know the name of the <c>Zipfile</c> until the time you call
-        ///   <c>ZipFile.Save()</c>, or if you plan to save to a stream (which has no
-        ///   name), then you should use the no-argument constructor.
-        /// </para>
-        ///
-        /// <para>
-        ///   The application can also call this constructor to read an existing zip
-        ///   archive.  passing the name of a valid zip file that does exist. But, it's
-        ///   better form to use the static <see cref="ZipFile.Read(String)"/> method,
-        ///   passing the name of the zip file, because using <c>ZipFile.Read()</c> in
-        ///   your code communicates very clearly what you are doing.  In either case,
-        ///   the file is then read into the <c>ZipFile</c> instance.  The app can then
-        ///   enumerate the entries or can modify the zip file, for example adding
-        ///   entries, removing entries, changing comments, and so on.
-        /// </para>
-        ///
-        /// <para>
-        ///   One advantage to this parameterized constructor: it allows applications to
-        ///   use the same code to add items to a zip archive, regardless of whether the
-        ///   zip file exists.
-        /// </para>
-        ///
-        /// <para>
-        ///   Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may
-        ///   not party on a single instance with multiple threads.  You may have
-        ///   multiple threads that each use a distinct <c>ZipFile</c> instance, or you
-        ///   can synchronize multi-thread access to a single instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   By the way, since DotNetZip is so easy to use, don't you think <see
-        ///   href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">you should
-        ///   donate $5 or $10</see>?
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="Ionic.Zip.ZipException">
-        /// Thrown if name refers to an existing file that is not a valid zip file.
-        /// </exception>
-        ///
-        /// <example>
-        /// This example shows how to create a zipfile, and add a few files into it.
-        /// <code>
-        /// String ZipFileToCreate = "archive1.zip";
-        /// String DirectoryToZip  = "c:\\reports";
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///   // Store all files found in the top level directory, into the zip archive.
-        ///   String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
-        ///   zip.AddFiles(filenames, "files");
-        ///   zip.Save(ZipFileToCreate);
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Dim ZipFileToCreate As String = "archive1.zip"
-        /// Dim DirectoryToZip As String = "c:\reports"
-        /// Using zip As ZipFile = New ZipFile()
-        ///     Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
-        ///     zip.AddFiles(filenames, "files")
-        ///     zip.Save(ZipFileToCreate)
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="fileName">The filename to use for the new zip archive.</param>
-        ///
-        public ZipFile(string fileName)
-        {
-            try
-            {
-                _InitInstance(fileName, null);
-            }
-            catch (Exception e1)
-            {
-                throw new ZipException(String.Format("Could not read {0} as a zip file", fileName), e1);
-            }
-        }
-
-
-        /// <summary>
-        ///   Creates a new <c>ZipFile</c> instance, using the specified name for the
-        ///   filename, and the specified Encoding.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the documentation on the <see cref="ZipFile(String)">ZipFile
-        ///   constructor that accepts a single string argument</see> for basic
-        ///   information on all the <c>ZipFile</c> constructors.
-        /// </para>
-        ///
-        /// <para>
-        ///   The Encoding is used as the default alternate encoding for entries with
-        ///   filenames or comments that cannot be encoded with the IBM437 code page.
-        ///   This is equivalent to setting the <see
-        ///   cref="ProvisionalAlternateEncoding"/> property on the <c>ZipFile</c>
-        ///   instance after construction.
-        /// </para>
-        ///
-        /// <para>
-        ///   Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may
-        ///   not party on a single instance with multiple threads.  You may have
-        ///   multiple threads that each use a distinct <c>ZipFile</c> instance, or you
-        ///   can synchronize multi-thread access to a single instance.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="Ionic.Zip.ZipException">
-        /// Thrown if name refers to an existing file that is not a valid zip file.
-        /// </exception>
-        ///
-        /// <param name="fileName">The filename to use for the new zip archive.</param>
-        /// <param name="encoding">The Encoding is used as the default alternate
-        /// encoding for entries with filenames or comments that cannot be encoded
-        /// with the IBM437 code page. </param>
-        public ZipFile(string fileName, System.Text.Encoding encoding)
-        {
-            try
-            {
-                AlternateEncoding = encoding;
-                AlternateEncodingUsage = ZipOption.Always;
-                _InitInstance(fileName, null);
-            }
-            catch (Exception e1)
-            {
-                throw new ZipException(String.Format("{0} is not a valid zip file", fileName), e1);
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Create a zip file, without specifying a target filename or stream to save to.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the documentation on the <see cref="ZipFile(String)">ZipFile
-        ///   constructor that accepts a single string argument</see> for basic
-        ///   information on all the <c>ZipFile</c> constructors.
-        /// </para>
-        ///
-        /// <para>
-        ///   After instantiating with this constructor and adding entries to the
-        ///   archive, the application should call <see cref="ZipFile.Save(String)"/> or
-        ///   <see cref="ZipFile.Save(System.IO.Stream)"/> to save to a file or a
-        ///   stream, respectively.  The application can also set the <see cref="Name"/>
-        ///   property and then call the no-argument <see cref="Save()"/> method.  (This
-        ///   is the preferred approach for applications that use the library through
-        ///   COM interop.)  If you call the no-argument <see cref="Save()"/> method
-        ///   without having set the <c>Name</c> of the <c>ZipFile</c>, either through
-        ///   the parameterized constructor or through the explicit property , the
-        ///   Save() will throw, because there is no place to save the file.  </para>
-        ///
-        /// <para>
-        ///   Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may
-        ///   have multiple threads that each use a distinct <c>ZipFile</c> instance, or
-        ///   you can synchronize multi-thread access to a single instance.  </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example creates a Zip archive called Backup.zip, containing all the files
-        /// in the directory DirectoryToZip. Files within subdirectories are not zipped up.
-        /// <code>
-        /// using (ZipFile zip = new ZipFile())
-        /// {
-        ///   // Store all files found in the top level directory, into the zip archive.
-        ///   // note: this code does not recurse subdirectories!
-        ///   String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
-        ///   zip.AddFiles(filenames, "files");
-        ///   zip.Save("Backup.zip");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile
-        ///     ' Store all files found in the top level directory, into the zip archive.
-        ///     ' note: this code does not recurse subdirectories!
-        ///     Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
-        ///     zip.AddFiles(filenames, "files")
-        ///     zip.Save("Backup.zip")
-        /// End Using
-        /// </code>
-        /// </example>
-        public ZipFile()
-        {
-            _InitInstance(null, null);
-        }
-
-
-        /// <summary>
-        ///   Create a zip file, specifying a text Encoding, but without specifying a
-        ///   target filename or stream to save to.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the documentation on the <see cref="ZipFile(String)">ZipFile
-        ///   constructor that accepts a single string argument</see> for basic
-        ///   information on all the <c>ZipFile</c> constructors.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="encoding">
-        /// The Encoding is used as the default alternate encoding for entries with
-        /// filenames or comments that cannot be encoded with the IBM437 code page.
-        /// </param>
-        public ZipFile(System.Text.Encoding encoding)
-        {
-            AlternateEncoding = encoding;
-            AlternateEncodingUsage = ZipOption.Always;
-            _InitInstance(null, null);
-        }
-
-
-        /// <summary>
-        ///   Creates a new <c>ZipFile</c> instance, using the specified name for the
-        ///   filename, and the specified status message writer.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   See the documentation on the <see cref="ZipFile(String)">ZipFile
-        ///   constructor that accepts a single string argument</see> for basic
-        ///   information on all the <c>ZipFile</c> constructors.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the constructor allows the caller to pass in a TextWriter,
-        ///   to which verbose messages will be written during extraction or creation of
-        ///   the zip archive.  A console application may wish to pass
-        ///   System.Console.Out to get messages on the Console. A graphical or headless
-        ///   application may wish to capture the messages in a different
-        ///   <c>TextWriter</c>, for example, a <c>StringWriter</c>, and then display
-        ///   the messages in a TextBox, or generate an audit log of ZipFile operations.
-        /// </para>
-        ///
-        /// <para>
-        ///   To encrypt the data for the files added to the <c>ZipFile</c> instance,
-        ///   set the Password property after creating the <c>ZipFile</c> instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may
-        ///   not party on a single instance with multiple threads.  You may have
-        ///   multiple threads that each use a distinct <c>ZipFile</c> instance, or you
-        ///   can synchronize multi-thread access to a single instance.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="Ionic.Zip.ZipException">
-        /// Thrown if name refers to an existing file that is not a valid zip file.
-        /// </exception>
-        ///
-        /// <example>
-        /// <code>
-        /// using (ZipFile zip = new ZipFile("Backup.zip", Console.Out))
-        /// {
-        ///   // Store all files found in the top level directory, into the zip archive.
-        ///   // note: this code does not recurse subdirectories!
-        ///   // Status messages will be written to Console.Out
-        ///   String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
-        ///   zip.AddFiles(filenames);
-        ///   zip.Save();
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As New ZipFile("Backup.zip", Console.Out)
-        ///     ' Store all files found in the top level directory, into the zip archive.
-        ///     ' note: this code does not recurse subdirectories!
-        ///     ' Status messages will be written to Console.Out
-        ///     Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
-        ///     zip.AddFiles(filenames)
-        ///     zip.Save()
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="fileName">The filename to use for the new zip archive.</param>
-        /// <param name="statusMessageWriter">A TextWriter to use for writing
-        /// verbose status messages.</param>
-        public ZipFile(string fileName, TextWriter statusMessageWriter)
-        {
-            try
-            {
-                _InitInstance(fileName, statusMessageWriter);
-            }
-            catch (Exception e1)
-            {
-                throw new ZipException(String.Format("{0} is not a valid zip file", fileName), e1);
-            }
-        }
-
-
-        /// <summary>
-        ///   Creates a new <c>ZipFile</c> instance, using the specified name for the
-        ///   filename, the specified status message writer, and the specified Encoding.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This constructor works like the <see cref="ZipFile(String)">ZipFile
-        ///   constructor that accepts a single string argument.</see> See that
-        ///   reference for detail on what this constructor does.
-        /// </para>
-        ///
-        /// <para>
-        ///   This version of the constructor allows the caller to pass in a
-        ///   <c>TextWriter</c>, and an Encoding.  The <c>TextWriter</c> will collect
-        ///   verbose messages that are generated by the library during extraction or
-        ///   creation of the zip archive.  A console application may wish to pass
-        ///   <c>System.Console.Out</c> to get messages on the Console. A graphical or
-        ///   headless application may wish to capture the messages in a different
-        ///   <c>TextWriter</c>, for example, a <c>StringWriter</c>, and then display
-        ///   the messages in a <c>TextBox</c>, or generate an audit log of
-        ///   <c>ZipFile</c> operations.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <c>Encoding</c> is used as the default alternate encoding for entries
-        ///   with filenames or comments that cannot be encoded with the IBM437 code
-        ///   page.  This is a equivalent to setting the <see
-        ///   cref="ProvisionalAlternateEncoding"/> property on the <c>ZipFile</c>
-        ///   instance after construction.
-        /// </para>
-        ///
-        /// <para>
-        ///   To encrypt the data for the files added to the <c>ZipFile</c> instance,
-        ///   set the <c>Password</c> property after creating the <c>ZipFile</c>
-        ///   instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may
-        ///   not party on a single instance with multiple threads.  You may have
-        ///   multiple threads that each use a distinct <c>ZipFile</c> instance, or you
-        ///   can synchronize multi-thread access to a single instance.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="Ionic.Zip.ZipException">
-        /// Thrown if <c>fileName</c> refers to an existing file that is not a valid zip file.
-        /// </exception>
-        ///
-        /// <param name="fileName">The filename to use for the new zip archive.</param>
-        /// <param name="statusMessageWriter">A TextWriter to use for writing verbose
-        /// status messages.</param>
-        /// <param name="encoding">
-        /// The Encoding is used as the default alternate encoding for entries with
-        /// filenames or comments that cannot be encoded with the IBM437 code page.
-        /// </param>
-        public ZipFile(string fileName, TextWriter statusMessageWriter,
-                       System.Text.Encoding encoding)
-        {
-            try
-            {
-                AlternateEncoding = encoding;
-                AlternateEncodingUsage = ZipOption.Always;
-                _InitInstance(fileName, statusMessageWriter);
-            }
-            catch (Exception e1)
-            {
-                throw new ZipException(String.Format("{0} is not a valid zip file", fileName), e1);
-            }
-        }
-
-
-
-
-        /// <summary>
-        ///   Initialize a <c>ZipFile</c> instance by reading in a zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This method is primarily useful from COM Automation environments, when
-        ///   reading or extracting zip files. In COM, it is not possible to invoke
-        ///   parameterized constructors for a class. A COM Automation application can
-        ///   update a zip file by using the <see cref="ZipFile()">default (no argument)
-        ///   constructor</see>, then calling <c>Initialize()</c> to read the contents
-        ///   of an on-disk zip archive into the <c>ZipFile</c> instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   .NET applications are encouraged to use the <c>ZipFile.Read()</c> methods
-        ///   for better clarity.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <param name="fileName">the name of the existing zip file to read in.</param>
-        public void Initialize(string fileName)
-        {
-            try
-            {
-                _InitInstance(fileName, null);
-            }
-            catch (Exception e1)
-            {
-                throw new ZipException(String.Format("{0} is not a valid zip file", fileName), e1);
-            }
-        }
-
-
-
-        private void _initEntriesDictionary()
-        {
-            // workitem 9868
-            StringComparer sc = (CaseSensitiveRetrieval) ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
-            _entries = (_entries == null)
-                ? new Dictionary<String, ZipEntry>(sc)
-                : new Dictionary<String, ZipEntry>(_entries, sc);
-        }
-
-
-        private void _InitInstance(string zipFileName, TextWriter statusMessageWriter)
-        {
-            // create a new zipfile
-            _name = zipFileName;
-            _StatusMessageTextWriter = statusMessageWriter;
-            _contentsChanged = true;
-            AddDirectoryWillTraverseReparsePoints = true;  // workitem 8617
-            CompressionLevel = OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.Default;
-#if !NETCF
-            ParallelDeflateThreshold = 512 * 1024;
-#endif
-            // workitem 7685, 9868
-            _initEntriesDictionary();
-
-            if (File.Exists(_name))
-            {
-                if (FullScan)
-                    ReadIntoInstance_Orig(this);
-                else
-                    ReadIntoInstance(this);
-                this._fileAlreadyExists = true;
-            }
-
-            return;
-        }
-        #endregion
-
-
-
-        #region Indexers and Collections
-
-        private List<ZipEntry> ZipEntriesAsList
-        {
-            get
-            {
-                if (_zipEntriesAsList == null)
-                    _zipEntriesAsList = new List<ZipEntry>(_entries.Values);
-                return _zipEntriesAsList;
-            }
-        }
-
-        /// <summary>
-        ///   This is an integer indexer into the Zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property is read-only.
-        /// </para>
-        ///
-        /// <para>
-        ///   Internally, the <c>ZipEntry</c> instances that belong to the
-        ///   <c>ZipFile</c> are stored in a Dictionary.  When you use this
-        ///   indexer the first time, it creates a read-only
-        ///   <c>List&lt;ZipEntry&gt;</c> from the Dictionary.Values Collection.
-        ///   If at any time you modify the set of entries in the <c>ZipFile</c>,
-        ///   either by adding an entry, removing an entry, or renaming an
-        ///   entry, a new List will be created, and the numeric indexes for the
-        ///   remaining entries may be different.
-        /// </para>
-        ///
-        /// <para>
-        ///   This means you cannot rename any ZipEntry from
-        ///   inside an enumeration of the zip file.
-        /// </para>
-        ///
-        /// <param name="ix">
-        ///   The index value.
-        /// </param>
-        ///
-        /// </remarks>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> within the Zip archive at the specified index. If the
-        ///   entry does not exist in the archive, this indexer throws.
-        /// </returns>
-        ///
-        public ZipEntry this[int ix]
-        {
-            // workitem 6402
-            get
-            {
-                return ZipEntriesAsList[ix];
-            }
-        }
-
-
-        /// <summary>
-        ///   This is a name-based indexer into the Zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property is read-only.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="CaseSensitiveRetrieval"/> property on the <c>ZipFile</c>
-        ///   determines whether retrieval via this indexer is done via case-sensitive
-        ///   comparisons. By default, retrieval is not case sensitive.  This makes
-        ///   sense on Windows, in which filesystems are not case sensitive.
-        /// </para>
-        ///
-        /// <para>
-        ///   Regardless of case-sensitivity, it is not always the case that
-        ///   <c>this[value].FileName == value</c>. In other words, the <c>FileName</c>
-        ///   property of the <c>ZipEntry</c> retrieved with this indexer, may or may
-        ///   not be equal to the index value.
-        /// </para>
-        ///
-        /// <para>
-        ///   This is because DotNetZip performs a normalization of filenames passed to
-        ///   this indexer, before attempting to retrieve the item.  That normalization
-        ///   includes: removal of a volume letter and colon, swapping backward slashes
-        ///   for forward slashes.  So, <c>zip["dir1\\entry1.txt"].FileName ==
-        ///   "dir1/entry.txt"</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Directory entries in the zip file may be retrieved via this indexer only
-        ///   with names that have a trailing slash. DotNetZip automatically appends a
-        ///   trailing slash to the names of any directory entries added to a zip.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example extracts only the entries in a zip file that are .txt files.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))
-        /// {
-        ///   foreach (string s1 in zip.EntryFilenames)
-        ///   {
-        ///     if (s1.EndsWith(".txt"))
-        ///       zip[s1].Extract("textfiles");
-        ///   }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        ///   Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")
-        ///       Dim s1 As String
-        ///       For Each s1 In zip.EntryFilenames
-        ///           If s1.EndsWith(".txt") Then
-        ///               zip(s1).Extract("textfiles")
-        ///           End If
-        ///       Next
-        ///   End Using
-        /// </code>
-        /// </example>
-        /// <seealso cref="Ionic.Zip.ZipFile.RemoveEntry(string)"/>
-        ///
-        /// <exception cref="System.ArgumentException">
-        ///   Thrown if the caller attempts to assign a non-null value to the indexer.
-        /// </exception>
-        ///
-        /// <param name="fileName">
-        ///   The name of the file, including any directory path, to retrieve from the
-        ///   zip.  The filename match is not case-sensitive by default; you can use the
-        ///   <see cref="CaseSensitiveRetrieval"/> property to change this behavior. The
-        ///   pathname can use forward-slashes or backward slashes.
-        /// </param>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> within the Zip archive, given by the specified
-        ///   filename. If the named entry does not exist in the archive, this indexer
-        ///   returns <c>null</c> (<c>Nothing</c> in VB).
-        /// </returns>
-        ///
-        public ZipEntry this[String fileName]
-        {
-            get
-            {
-                var key = SharedUtilities.NormalizePathForUseInZipFile(fileName);
-                if (_entries.ContainsKey(key))
-                    return _entries[key];
-                // workitem 11056
-                key = key.Replace("/", "\\");
-                if (_entries.ContainsKey(key))
-                    return _entries[key];
-                return null;
-
-#if MESSY
-                foreach (ZipEntry e in _entries.Values)
-                {
-                    if (this.CaseSensitiveRetrieval)
-                    {
-                        // check for the file match with a case-sensitive comparison.
-                        if (e.FileName == fileName) return e;
-                        // also check for equivalence
-                        if (fileName.Replace("\\", "/") == e.FileName) return e;
-                        if (e.FileName.Replace("\\", "/") == fileName) return e;
-
-                        // check for a difference only in trailing slash
-                        if (e.FileName.EndsWith("/"))
-                        {
-                            var fileNameNoSlash = e.FileName.Trim("/".ToCharArray());
-                            if (fileNameNoSlash == fileName) return e;
-                            // also check for equivalence
-                            if (fileName.Replace("\\", "/") == fileNameNoSlash) return e;
-                            if (fileNameNoSlash.Replace("\\", "/") == fileName) return e;
-                        }
-
-                    }
-                    else
-                    {
-                        // check for the file match in a case-insensitive manner.
-                        if (String.Compare(e.FileName, fileName, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-                        // also check for equivalence
-                        if (String.Compare(fileName.Replace("\\", "/"), e.FileName, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-                        if (String.Compare(e.FileName.Replace("\\", "/"), fileName, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-
-                        // check for a difference only in trailing slash
-                        if (e.FileName.EndsWith("/"))
-                        {
-                            var fileNameNoSlash = e.FileName.Trim("/".ToCharArray());
-
-                            if (String.Compare(fileNameNoSlash, fileName, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-                            // also check for equivalence
-                            if (String.Compare(fileName.Replace("\\", "/"), fileNameNoSlash, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-                            if (String.Compare(fileNameNoSlash.Replace("\\", "/"), fileName, StringComparison.CurrentCultureIgnoreCase) == 0) return e;
-
-                        }
-
-                    }
-
-                }
-                return null;
-
-#endif
-            }
-        }
-
-
-        /// <summary>
-        ///   The list of filenames for the entries contained within the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   According to the ZIP specification, the names of the entries use forward
-        ///   slashes in pathnames.  If you are scanning through the list, you may have
-        ///   to swap forward slashes for backslashes.
-        /// </remarks>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.this[string]"/>
-        ///
-        /// <example>
-        ///   This example shows one way to test if a filename is already contained
-        ///   within a zip archive.
-        /// <code>
-        /// String zipFileToRead= "PackedDocuments.zip";
-        /// string candidate = "DatedMaterial.xps";
-        /// using (ZipFile zip = new ZipFile(zipFileToRead))
-        /// {
-        ///   if (zip.EntryFilenames.Contains(candidate))
-        ///     Console.WriteLine("The file '{0}' exists in the zip archive '{1}'",
-        ///                       candidate,
-        ///                       zipFileName);
-        ///   else
-        ///     Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'",
-        ///                       candidate,
-        ///                       zipFileName);
-        ///   Console.WriteLine();
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        ///   Dim zipFileToRead As String = "PackedDocuments.zip"
-        ///   Dim candidate As String = "DatedMaterial.xps"
-        ///   Using zip As ZipFile.Read(ZipFileToRead)
-        ///       If zip.EntryFilenames.Contains(candidate) Then
-        ///           Console.WriteLine("The file '{0}' exists in the zip archive '{1}'", _
-        ///                       candidate, _
-        ///                       zipFileName)
-        ///       Else
-        ///         Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'", _
-        ///                       candidate, _
-        ///                       zipFileName)
-        ///       End If
-        ///       Console.WriteLine
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <returns>
-        ///   The list of strings for the filenames contained within the Zip archive.
-        /// </returns>
-        ///
-        public System.Collections.Generic.ICollection<String> EntryFileNames
-        {
-            get
-            {
-                return _entries.Keys;
-            }
-        }
-
-
-        /// <summary>
-        ///   Returns the readonly collection of entries in the Zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If there are no entries in the current <c>ZipFile</c>, the value returned is a
-        ///   non-null zero-element collection.  If there are entries in the zip file,
-        ///   the elements are returned in no particular order.
-        /// </para>
-        /// <para>
-        ///   This is the implied enumerator on the <c>ZipFile</c> class.  If you use a
-        ///   <c>ZipFile</c> instance in a context that expects an enumerator, you will
-        ///   get this collection.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="EntriesSorted"/>
-        public System.Collections.Generic.ICollection<ZipEntry> Entries
-        {
-            get
-            {
-                return _entries.Values;
-            }
-        }
-
-
-        /// <summary>
-        ///   Returns a readonly collection of entries in the Zip archive, sorted by FileName.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   If there are no entries in the current <c>ZipFile</c>, the value returned
-        ///   is a non-null zero-element collection.  If there are entries in the zip
-        ///   file, the elements are returned sorted by the name of the entry.
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example fills a Windows Forms ListView with the entries in a zip file.
-        ///
-        /// <code lang="C#">
-        /// using (ZipFile zip = ZipFile.Read(zipFile))
-        /// {
-        ///     foreach (ZipEntry entry in zip.EntriesSorted)
-        ///     {
-        ///         ListViewItem item = new ListViewItem(n.ToString());
-        ///         n++;
-        ///         string[] subitems = new string[] {
-        ///             entry.FileName.Replace("/","\\"),
-        ///             entry.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
-        ///             entry.UncompressedSize.ToString(),
-        ///             String.Format("{0,5:F0}%", entry.CompressionRatio),
-        ///             entry.CompressedSize.ToString(),
-        ///             (entry.UsesEncryption) ? "Y" : "N",
-        ///             String.Format("{0:X8}", entry.Crc)};
-        ///
-        ///         foreach (String s in subitems)
-        ///         {
-        ///             ListViewItem.ListViewSubItem subitem = new ListViewItem.ListViewSubItem();
-        ///             subitem.Text = s;
-        ///             item.SubItems.Add(subitem);
-        ///         }
-        ///
-        ///         this.listView1.Items.Add(item);
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <seealso cref="Entries"/>
-        public System.Collections.Generic.ICollection<ZipEntry> EntriesSorted
-        {
-            get
-            {
-                var coll = new System.Collections.Generic.List<ZipEntry>();
-                foreach (var e in this.Entries)
-                {
-                    coll.Add(e);
-                }
-                StringComparison sc = (CaseSensitiveRetrieval) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
-
-                coll.Sort((x, y) => { return String.Compare(x.FileName, y.FileName, sc); });
-                return coll.AsReadOnly();
-            }
-        }
-
-
-        /// <summary>
-        /// Returns the number of entries in the Zip archive.
-        /// </summary>
-        public int Count
-        {
-            get
-            {
-                return _entries.Count;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Removes the given <c>ZipEntry</c> from the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to
-        ///   make the changes permanent.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <exception cref="System.ArgumentException">
-        ///   Thrown if the specified <c>ZipEntry</c> does not exist in the <c>ZipFile</c>.
-        /// </exception>
-        ///
-        /// <example>
-        ///   In this example, all entries in the zip archive dating from before
-        ///   December 31st, 2007, are removed from the archive.  This is actually much
-        ///   easier if you use the RemoveSelectedEntries method.  But I needed an
-        ///   example for RemoveEntry, so here it is.
-        /// <code>
-        /// String ZipFileToRead = "ArchiveToModify.zip";
-        /// System.DateTime Threshold = new System.DateTime(2007,12,31);
-        /// using (ZipFile zip = ZipFile.Read(ZipFileToRead))
-        /// {
-        ///   var EntriesToRemove = new System.Collections.Generic.List&lt;ZipEntry&gt;();
-        ///   foreach (ZipEntry e in zip)
-        ///   {
-        ///     if (e.LastModified &lt; Threshold)
-        ///     {
-        ///       // We cannot remove the entry from the list, within the context of
-        ///       // an enumeration of said list.
-        ///       // So we add the doomed entry to a list to be removed later.
-        ///       EntriesToRemove.Add(e);
-        ///     }
-        ///   }
-        ///
-        ///   // actually remove the doomed entries.
-        ///   foreach (ZipEntry zombie in EntriesToRemove)
-        ///     zip.RemoveEntry(zombie);
-        ///
-        ///   zip.Comment= String.Format("This zip archive was updated at {0}.",
-        ///                              System.DateTime.Now.ToString("G"));
-        ///
-        ///   // save with a different name
-        ///   zip.Save("Archive-Updated.zip");
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///   Dim ZipFileToRead As String = "ArchiveToModify.zip"
-        ///   Dim Threshold As New DateTime(2007, 12, 31)
-        ///   Using zip As ZipFile = ZipFile.Read(ZipFileToRead)
-        ///       Dim EntriesToRemove As New System.Collections.Generic.List(Of ZipEntry)
-        ///       Dim e As ZipEntry
-        ///       For Each e In zip
-        ///           If (e.LastModified &lt; Threshold) Then
-        ///               ' We cannot remove the entry from the list, within the context of
-        ///               ' an enumeration of said list.
-        ///               ' So we add the doomed entry to a list to be removed later.
-        ///               EntriesToRemove.Add(e)
-        ///           End If
-        ///       Next
-        ///
-        ///       ' actually remove the doomed entries.
-        ///       Dim zombie As ZipEntry
-        ///       For Each zombie In EntriesToRemove
-        ///           zip.RemoveEntry(zombie)
-        ///       Next
-        ///       zip.Comment = String.Format("This zip archive was updated at {0}.", DateTime.Now.ToString("G"))
-        ///       'save as a different name
-        ///       zip.Save("Archive-Updated.zip")
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="entry">
-        /// The <c>ZipEntry</c> to remove from the zip.
-        /// </param>
-        ///
-        /// <seealso cref="Ionic.Zip.ZipFile.RemoveSelectedEntries(string)"/>
-        ///
-        public void RemoveEntry(ZipEntry entry)
-        {
-            //if (!_entries.Values.Contains(entry))
-            //    throw new ArgumentException("The entry you specified does not exist in the zip archive.");
-            if (entry == null)
-                throw new ArgumentNullException("entry");
-
-            _entries.Remove(SharedUtilities.NormalizePathForUseInZipFile(entry.FileName));
-            _zipEntriesAsList = null;
-
-#if NOTNEEDED
-            if (_direntries != null)
-            {
-                bool FoundAndRemovedDirEntry = false;
-                foreach (ZipDirEntry de1 in _direntries)
-                {
-                    if (entry.FileName == de1.FileName)
-                    {
-                        _direntries.Remove(de1);
-                        FoundAndRemovedDirEntry = true;
-                        break;
-                    }
-                }
-
-                if (!FoundAndRemovedDirEntry)
-                    throw new BadStateException("The entry to be removed was not found in the directory.");
-            }
-#endif
-            _contentsChanged = true;
-        }
-
-
-
-
-        /// <summary>
-        /// Removes the <c>ZipEntry</c> with the given filename from the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to
-        ///   make the changes permanent.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <exception cref="System.InvalidOperationException">
-        ///   Thrown if the <c>ZipFile</c> is not updatable.
-        /// </exception>
-        ///
-        /// <exception cref="System.ArgumentException">
-        ///   Thrown if a <c>ZipEntry</c> with the specified filename does not exist in
-        ///   the <c>ZipFile</c>.
-        /// </exception>
-        ///
-        /// <example>
-        ///
-        ///   This example shows one way to remove an entry with a given filename from
-        ///   an existing zip archive.
-        ///
-        /// <code>
-        /// String zipFileToRead= "PackedDocuments.zip";
-        /// string candidate = "DatedMaterial.xps";
-        /// using (ZipFile zip = ZipFile.Read(zipFileToRead))
-        /// {
-        ///   if (zip.EntryFilenames.Contains(candidate))
-        ///   {
-        ///     zip.RemoveEntry(candidate);
-        ///     zip.Comment= String.Format("The file '{0}' has been removed from this archive.",
-        ///                                Candidate);
-        ///     zip.Save();
-        ///   }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        ///   Dim zipFileToRead As String = "PackedDocuments.zip"
-        ///   Dim candidate As String = "DatedMaterial.xps"
-        ///   Using zip As ZipFile = ZipFile.Read(zipFileToRead)
-        ///       If zip.EntryFilenames.Contains(candidate) Then
-        ///           zip.RemoveEntry(candidate)
-        ///           zip.Comment = String.Format("The file '{0}' has been removed from this archive.", Candidate)
-        ///           zip.Save
-        ///       End If
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="fileName">
-        /// The name of the file, including any directory path, to remove from the zip.
-        /// The filename match is not case-sensitive by default; you can use the
-        /// <c>CaseSensitiveRetrieval</c> property to change this behavior. The
-        /// pathname can use forward-slashes or backward slashes.
-        /// </param>
-        ///
-        public void RemoveEntry(String fileName)
-        {
-            string modifiedName = ZipEntry.NameInArchive(fileName, null);
-            ZipEntry e = this[modifiedName];
-            if (e == null)
-                throw new ArgumentException("The entry you specified was not found in the zip archive.");
-
-            RemoveEntry(e);
-        }
-
-
-        #endregion
-
-        #region Destructors and Disposers
-
-        //         /// <summary>
-        //         /// This is the class Destructor, which gets called implicitly when the instance
-        //         /// is destroyed.  Because the <c>ZipFile</c> type implements IDisposable, this
-        //         /// method calls Dispose(false).
-        //         /// </summary>
-        //         ~ZipFile()
-        //         {
-        //             // call Dispose with false.  Since we're in the
-        //             // destructor call, the managed resources will be
-        //             // disposed of anyways.
-        //             Dispose(false);
-        //         }
-
-        /// <summary>
-        ///   Closes the read and write streams associated
-        ///   to the <c>ZipFile</c>, if necessary.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   The Dispose() method is generally employed implicitly, via a <c>using(..) {..}</c>
-        ///   statement. (<c>Using...End Using</c> in VB) If you do not employ a using
-        ///   statement, insure that your application calls Dispose() explicitly.  For
-        ///   example, in a Powershell application, or an application that uses the COM
-        ///   interop interface, you must call Dispose() explicitly.
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example extracts an entry selected by name, from the Zip file to the
-        /// Console.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipfile))
-        /// {
-        ///   foreach (ZipEntry e in zip)
-        ///   {
-        ///     if (WantThisEntry(e.FileName))
-        ///       zip.Extract(e.FileName, Console.OpenStandardOutput());
-        ///   }
-        /// } // Dispose() is called implicitly here.
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using zip As ZipFile = ZipFile.Read(zipfile)
-        ///     Dim e As ZipEntry
-        ///     For Each e In zip
-        ///       If WantThisEntry(e.FileName) Then
-        ///           zip.Extract(e.FileName, Console.OpenStandardOutput())
-        ///       End If
-        ///     Next
-        /// End Using ' Dispose is implicity called here
-        /// </code>
-        /// </example>
-        public void Dispose()
-        {
-            // dispose of the managed and unmanaged resources
-            Dispose(true);
-
-            // tell the GC that the Finalize process no longer needs
-            // to be run for this object.
-            GC.SuppressFinalize(this);
-        }
-
-        /// <summary>
-        ///   Disposes any managed resources, if the flag is set, then marks the
-        ///   instance disposed.  This method is typically not called explicitly from
-        ///   application code.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Applications should call <see cref="Dispose()">the no-arg Dispose method</see>.
-        /// </remarks>
-        ///
-        /// <param name="disposeManagedResources">
-        ///   indicates whether the method should dispose streams or not.
-        /// </param>
-        protected virtual void Dispose(bool disposeManagedResources)
-        {
-            if (!this._disposed)
-            {
-                if (disposeManagedResources)
-                {
-                    // dispose managed resources
-                    if (_ReadStreamIsOurs)
-                    {
-                        if (_readstream != null)
-                        {
-                            // workitem 7704
-#if NETCF
-                            _readstream.Close();
-#else
-                            _readstream.Dispose();
-#endif
-                            _readstream = null;
-                        }
-                    }
-                    // only dispose the writestream if there is a backing file
-                    if ((_temporaryFileName != null) && (_name != null))
-                        if (_writestream != null)
-                        {
-                            // workitem 7704
-#if NETCF
-                            _writestream.Close();
-#else
-                            _writestream.Dispose();
-#endif
-                            _writestream = null;
-                        }
-
-#if !NETCF
-                    // workitem 10030
-                    if (this.ParallelDeflater != null)
-                    {
-                        this.ParallelDeflater.Dispose();
-                        this.ParallelDeflater = null;
-                    }
-#endif
-                }
-                this._disposed = true;
-            }
-        }
-        #endregion
-
-
-        #region private properties
-
-        internal Stream ReadStream
-        {
-            get
-            {
-                if (_readstream == null)
-                {
-                    if (_readName != null || _name !=null)
-                    {
-                        _readstream = File.Open(_readName ?? _name,
-                                                FileMode.Open,
-                                                FileAccess.Read,
-                                                FileShare.Read | FileShare.Write);
-                        _ReadStreamIsOurs = true;
-                    }
-                }
-                return _readstream;
-            }
-        }
-
-
-
-        private Stream WriteStream
-        {
-            // workitem 9763
-            get
-            {
-                if (_writestream != null) return _writestream;
-                if (_name == null) return _writestream;
-
-                if (_maxOutputSegmentSize != 0)
-                {
-                    _writestream = ZipSegmentedStream.ForWriting(this._name, _maxOutputSegmentSize);
-                    return _writestream;
-                }
-
-                SharedUtilities.CreateAndOpenUniqueTempFile(TempFileFolder ?? Path.GetDirectoryName(_name),
-                                                            out _writestream,
-                                                            out _temporaryFileName);
-                return _writestream;
-            }
-            set
-            {
-                if (value != null)
-                    throw new ZipException("Cannot set the stream to a non-null value.");
-                _writestream = null;
-            }
-        }
-        #endregion
-
-        #region private fields
-        private TextWriter _StatusMessageTextWriter;
-        private bool _CaseSensitiveRetrieval;
-        private Stream _readstream;
-        private Stream _writestream;
-        private UInt16 _versionMadeBy;
-        private UInt16 _versionNeededToExtract;
-        private UInt32 _diskNumberWithCd;
-        private Int32 _maxOutputSegmentSize;
-        private UInt32 _numberOfSegmentsForMostRecentSave;
-        private ZipErrorAction _zipErrorAction;
-        private bool _disposed;
-        //private System.Collections.Generic.List<ZipEntry> _entries;
-        private System.Collections.Generic.Dictionary<String, ZipEntry> _entries;
-        private List<ZipEntry> _zipEntriesAsList;
-        private string _name;
-        private string _readName;
-        private string _Comment;
-        internal string _Password;
-        private bool _emitNtfsTimes = true;
-        private bool _emitUnixTimes;
-        private Ionic.Zlib.CompressionStrategy _Strategy = Ionic.Zlib.CompressionStrategy.Default;
-        private Ionic.Zip.CompressionMethod _compressionMethod = Ionic.Zip.CompressionMethod.Deflate;
-        private bool _fileAlreadyExists;
-        private string _temporaryFileName;
-        private bool _contentsChanged;
-        private bool _hasBeenSaved;
-        private String _TempFileFolder;
-        private bool _ReadStreamIsOurs = true;
-        private object LOCK = new object();
-        private bool _saveOperationCanceled;
-        private bool _extractOperationCanceled;
-        private bool _addOperationCanceled;
-        private EncryptionAlgorithm _Encryption;
-        private bool _JustSaved;
-        private long _locEndOfCDS = -1;
-        private uint _OffsetOfCentralDirectory;
-        private Int64 _OffsetOfCentralDirectory64;
-        private Nullable<bool> _OutputUsesZip64;
-        internal bool _inExtractAll;
-        private System.Text.Encoding _alternateEncoding = System.Text.Encoding.ASCII; // UTF-8
-        private ZipOption _alternateEncodingUsage = ZipOption.Never;
-        private static System.Text.Encoding _defaultEncoding = System.Text.Encoding.ASCII;
-
-        private int _BufferSize = BufferSizeDefault;
-
-#if !NETCF
-        internal Ionic.Zlib.ParallelDeflateOutputStream ParallelDeflater;
-        private long _ParallelDeflateThreshold;
-        private int _maxBufferPairs = 16;
-#endif
-
-        internal Zip64Option _zip64 = Zip64Option.Default;
-#pragma warning disable 649
-        private bool _SavingSfx;
-#pragma warning restore 649
-
-        /// <summary>
-        ///   Default size of the buffer used for IO.
-        /// </summary>
-        public static readonly int BufferSizeDefault = 32768;
-
-        #endregion
-    }
-
-    /// <summary>
-    ///   Options for using ZIP64 extensions when saving zip archives.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///
-    /// <para>
-    ///   Designed many years ago, the <see
-    ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">original zip
-    ///   specification from PKWARE</see> allowed for 32-bit quantities for the
-    ///   compressed and uncompressed sizes of zip entries, as well as a 32-bit quantity
-    ///   for specifying the length of the zip archive itself, and a maximum of 65535
-    ///   entries.  These limits are now regularly exceeded in many backup and archival
-    ///   scenarios.  Recently, PKWare added extensions to the original zip spec, called
-    ///   "ZIP64 extensions", to raise those limitations.  This property governs whether
-    ///   DotNetZip will use those extensions when writing zip archives. The use of
-    ///   these extensions is optional and explicit in DotNetZip because, despite the
-    ///   status of ZIP64 as a bona fide standard, many other zip tools and libraries do
-    ///   not support ZIP64, and therefore a zip file with ZIP64 extensions may be
-    ///   unreadable by some of those other tools.
-    /// </para>
-    ///
-    /// <para>
-    ///   Set this property to <see cref="Zip64Option.Always"/> to always use ZIP64
-    ///   extensions when saving, regardless of whether your zip archive needs it.
-    ///   Suppose you add 5 files, each under 100k, to a ZipFile. If you specify Always
-    ///   for this flag, you will get a ZIP64 archive, though the archive does not need
-    ///   to use ZIP64 because none of the original zip limits had been exceeded.
-    /// </para>
-    ///
-    /// <para>
-    ///   Set this property to <see cref="Zip64Option.Never"/> to tell the DotNetZip
-    ///   library to never use ZIP64 extensions.  This is useful for maximum
-    ///   compatibility and interoperability, at the expense of the capability of
-    ///   handling large files or large archives.  NB: Windows Explorer in Windows XP
-    ///   and Windows Vista cannot currently extract files from a zip64 archive, so if
-    ///   you want to guarantee that a zip archive produced by this library will work in
-    ///   Windows Explorer, use <c>Never</c>. If you set this property to <see
-    ///   cref="Zip64Option.Never"/>, and your application creates a zip that would
-    ///   exceed one of the Zip limits, the library will throw an exception while saving
-    ///   the zip file.
-    /// </para>
-    ///
-    /// <para>
-    ///   Set this property to <see cref="Zip64Option.AsNecessary"/> to tell the
-    ///   DotNetZip library to use the ZIP64 extensions when required by the
-    ///   entry. After the file is compressed, the original and compressed sizes are
-    ///   checked, and if they exceed the limits described above, then zip64 can be
-    ///   used. That is the general idea, but there is an additional wrinkle when saving
-    ///   to a non-seekable device, like the ASP.NET <c>Response.OutputStream</c>, or
-    ///   <c>Console.Out</c>.  When using non-seekable streams for output, the entry
-    ///   header - which indicates whether zip64 is in use - is emitted before it is
-    ///   known if zip64 is necessary.  It is only after all entries have been saved
-    ///   that it can be known if ZIP64 will be required.  On seekable output streams,
-    ///   after saving all entries, the library can seek backward and re-emit the zip
-    ///   file header to be consistent with the actual ZIP64 requirement.  But using a
-    ///   non-seekable output stream, the library cannot seek backward, so the header
-    ///   can never be changed. In other words, the archive's use of ZIP64 extensions is
-    ///   not alterable after the header is emitted.  Therefore, when saving to
-    ///   non-seekable streams, using <see cref="Zip64Option.AsNecessary"/> is the same
-    ///   as using <see cref="Zip64Option.Always"/>: it will always produce a zip
-    ///   archive that uses ZIP64 extensions.
-    /// </para>
-    ///
-    /// </remarks>
-    internal enum Zip64Option
-    {
-        /// <summary>
-        /// The default behavior, which is "Never".
-        /// (For COM clients, this is a 0 (zero).)
-        /// </summary>
-        Default = 0,
-        /// <summary>
-        /// Do not use ZIP64 extensions when writing zip archives.
-        /// (For COM clients, this is a 0 (zero).)
-        /// </summary>
-        Never = 0,
-        /// <summary>
-        /// Use ZIP64 extensions when writing zip archives, as necessary.
-        /// For example, when a single entry exceeds 0xFFFFFFFF in size, or when the archive as a whole
-        /// exceeds 0xFFFFFFFF in size, or when there are more than 65535 entries in an archive.
-        /// (For COM clients, this is a 1.)
-        /// </summary>
-        AsNecessary = 1,
-        /// <summary>
-        /// Always use ZIP64 extensions when writing zip archives, even when unnecessary.
-        /// (For COM clients, this is a 2.)
-        /// </summary>
-        Always
-    }
-
-
-    /// <summary>
-    ///  An enum representing the values on a three-way toggle switch
-    ///  for various options in the library. This might be used to
-    ///  specify whether to employ a particular text encoding, or to use
-    ///  ZIP64 extensions, or some other option.
-    /// </summary>
-    internal enum ZipOption
-    {
-        /// <summary>
-        /// The default behavior. This is the same as "Never".
-        /// (For COM clients, this is a 0 (zero).)
-        /// </summary>
-        Default = 0,
-        /// <summary>
-        /// Never use the associated option.
-        /// (For COM clients, this is a 0 (zero).)
-        /// </summary>
-        Never = 0,
-        /// <summary>
-        /// Use the associated behavior "as necessary."
-        /// (For COM clients, this is a 1.)
-        /// </summary>
-        AsNecessary = 1,
-        /// <summary>
-        /// Use the associated behavior Always, whether necessary or not.
-        /// (For COM clients, this is a 2.)
-        /// </summary>
-        Always
-    }
-
-
-    enum AddOrUpdateAction
-    {
-        AddOnly = 0,
-        AddOrUpdate
-    }
-
-}
-
-
-
-// ==================================================================
-//
-// Information on the ZIP format:
-//
-// From
-// http://www.pkware.com/documents/casestudies/APPNOTE.TXT
-//
-//  Overall .ZIP file format:
-//
-//     [local file header 1]
-//     [file data 1]
-//     [data descriptor 1]  ** sometimes
-//     .
-//     .
-//     .
-//     [local file header n]
-//     [file data n]
-//     [data descriptor n]   ** sometimes
-//     [archive decryption header]
-//     [archive extra data record]
-//     [central directory]
-//     [zip64 end of central directory record]
-//     [zip64 end of central directory locator]
-//     [end of central directory record]
-//
-// Local File Header format:
-//         local file header signature ... 4 bytes  (0x04034b50)
-//         version needed to extract ..... 2 bytes
-//         general purpose bit field ..... 2 bytes
-//         compression method ............ 2 bytes
-//         last mod file time ............ 2 bytes
-//         last mod file date............. 2 bytes
-//         crc-32 ........................ 4 bytes
-//         compressed size................ 4 bytes
-//         uncompressed size.............. 4 bytes
-//         file name length............... 2 bytes
-//         extra field length ............ 2 bytes
-//         file name                       varies
-//         extra field                     varies
-//
-//
-// Data descriptor:  (used only when bit 3 of the general purpose bitfield is set)
-//         (although, I have found zip files where bit 3 is not set, yet this descriptor is present!)
-//         local file header signature     4 bytes  (0x08074b50)  ** sometimes!!! Not always
-//         crc-32                          4 bytes
-//         compressed size                 4 bytes
-//         uncompressed size               4 bytes
-//
-//
-//   Central directory structure:
-//
-//       [file header 1]
-//       .
-//       .
-//       .
-//       [file header n]
-//       [digital signature]
-//
-//
-//       File header:  (This is a ZipDirEntry)
-//         central file header signature   4 bytes  (0x02014b50)
-//         version made by                 2 bytes
-//         version needed to extract       2 bytes
-//         general purpose bit flag        2 bytes
-//         compression method              2 bytes
-//         last mod file time              2 bytes
-//         last mod file date              2 bytes
-//         crc-32                          4 bytes
-//         compressed size                 4 bytes
-//         uncompressed size               4 bytes
-//         file name length                2 bytes
-//         extra field length              2 bytes
-//         file comment length             2 bytes
-//         disk number start               2 bytes
-//         internal file attributes **     2 bytes
-//         external file attributes ***    4 bytes
-//         relative offset of local header 4 bytes
-//         file name (variable size)
-//         extra field (variable size)
-//         file comment (variable size)
-//
-// ** The internal file attributes, near as I can tell,
-// uses 0x01 for a file and a 0x00 for a directory.
-//
-// ***The external file attributes follows the MS-DOS file attribute byte, described here:
-// at http://support.microsoft.com/kb/q125019/
-// 0x0010 => directory
-// 0x0020 => file
-//
-//
-// End of central directory record:
-//
-//         end of central dir signature    4 bytes  (0x06054b50)
-//         number of this disk             2 bytes
-//         number of the disk with the
-//         start of the central directory  2 bytes
-//         total number of entries in the
-//         central directory on this disk  2 bytes
-//         total number of entries in
-//         the central directory           2 bytes
-//         size of the central directory   4 bytes
-//         offset of start of central
-//         directory with respect to
-//         the starting disk number        4 bytes
-//         .ZIP file comment length        2 bytes
-//         .ZIP file comment       (variable size)
-//
-// date and time are packed values, as MSDOS did them
-// time: bits 0-4 : seconds (divided by 2)
-//            5-10: minute
-//            11-15: hour
-// date  bits 0-4 : day
-//            5-8: month
-//            9-15 year (since 1980)
-//
-// see http://msdn.microsoft.com/en-us/library/ms724274(VS.85).aspx
-
diff --git a/EPPlus/Packaging/DotNetZip/ZipFile.x-IEnumerable.cs b/EPPlus/Packaging/DotNetZip/ZipFile.x-IEnumerable.cs
deleted file mode 100644
index bb607b1..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipFile.x-IEnumerable.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-// ZipFile.x-IEnumerable.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2006, 2007, 2008, 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2009-December-26 15:13:26>
-//
-// ------------------------------------------------------------------
-//
-// This module defines smoe methods for IEnumerable support. It is
-// particularly important for COM to have these things in a separate module.
-//
-// ------------------------------------------------------------------
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-
-    // For some weird reason, the method with the DispId(-4) attribute, which is used as
-    // the _NewEnum() method, and which is required to get enumeration to work from COM
-    // environments like VBScript and Javascript (etc) must be the LAST MEMBER in the
-    // source.  In the event of Partial classes, it needs to be the last member defined
-    // in the last source module.  The source modules are ordered alphabetically by
-    // filename.  Not sure why this is true. In any case, we put the enumeration stuff
-    // here in this oddly-named module, for this reason.
-    //
-
-
-
-    internal partial class ZipFile
-    {
-
-
-
-
-        /// <summary>
-        /// Generic IEnumerator support, for use of a ZipFile in an enumeration.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// You probably do not want to call <c>GetEnumerator</c> explicitly. Instead
-        /// it is implicitly called when you use a <see langword="foreach"/> loop in C#, or a
-        /// <c>For Each</c> loop in VB.NET.
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example reads a zipfile of a given name, then enumerates the
-        /// entries in that zip file, and displays the information about each
-        /// entry on the Console.
-        /// <code>
-        /// using (ZipFile zip = ZipFile.Read(zipfile))
-        /// {
-        ///   bool header = true;
-        ///   foreach (ZipEntry e in zip)
-        ///   {
-        ///     if (header)
-        ///     {
-        ///        System.Console.WriteLine("Zipfile: {0}", zip.Name);
-        ///        System.Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded);
-        ///        System.Console.WriteLine("BitField: 0x{0:X2}", e.BitField);
-        ///        System.Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod);
-        ///        System.Console.WriteLine("\n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",
-        ///                     "Filename", "Modified", "Size", "Ratio", "Packed");
-        ///        System.Console.WriteLine(new System.String('-', 72));
-        ///        header = false;
-        ///     }
-        ///
-        ///     System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}",
-        ///                 e.FileName,
-        ///                 e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
-        ///                 e.UncompressedSize,
-        ///                 e.CompressionRatio,
-        ///                 e.CompressedSize);
-        ///
-        ///     e.Extract();
-        ///   }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        ///   Dim ZipFileToExtract As String = "c:\foo.zip"
-        ///   Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
-        ///       Dim header As Boolean = True
-        ///       Dim e As ZipEntry
-        ///       For Each e In zip
-        ///           If header Then
-        ///               Console.WriteLine("Zipfile: {0}", zip.Name)
-        ///               Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded)
-        ///               Console.WriteLine("BitField: 0x{0:X2}", e.BitField)
-        ///               Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod)
-        ///               Console.WriteLine(ChrW(10) &amp; "{1,-22} {2,-6} {3,4}   {4,-8}  {0}", _
-        ///                 "Filename", "Modified", "Size", "Ratio", "Packed" )
-        ///               Console.WriteLine(New String("-"c, 72))
-        ///               header = False
-        ///           End If
-        ///           Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}", _
-        ///             e.FileName, _
-        ///             e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"), _
-        ///             e.UncompressedSize, _
-        ///             e.CompressionRatio, _
-        ///             e.CompressedSize )
-        ///           e.Extract
-        ///       Next
-        ///   End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <returns>A generic enumerator suitable for use  within a foreach loop.</returns>
-        public System.Collections.Generic.IEnumerator<ZipEntry> GetEnumerator()
-        {
-            foreach (ZipEntry e in _entries.Values)
-                yield return e;
-        }
-
-        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-
-        /// <summary>
-        /// An IEnumerator, for use of a ZipFile in a foreach construct.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// This method is included for COM support.  An application generally does not call
-        /// this method directly.  It is called implicitly by COM clients when enumerating
-        /// the entries in the ZipFile instance.  In VBScript, this is done with a <c>For Each</c>
-        /// statement.  In Javascript, this is done with <c>new Enumerator(zipfile)</c>.
-        /// </remarks>
-        ///
-        /// <returns>
-        /// The IEnumerator over the entries in the ZipFile.
-        /// </returns>
-        [System.Runtime.InteropServices.DispId(-4)]
-        public System.Collections.IEnumerator GetNewEnum()          // the name of this method is not significant
-        {
-            return GetEnumerator();
-        }
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipInputStream.cs b/EPPlus/Packaging/DotNetZip/ZipInputStream.cs
deleted file mode 100644
index 30d15ad..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipInputStream.cs
+++ /dev/null
@@ -1,829 +0,0 @@
-// ZipInputStream.cs
-//
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2010 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-31 14:48:30>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZipInputStream class, which is a stream metaphor for
-// reading zip files.  This class does not depend on Ionic.Zip.ZipFile, but rather
-// stands alongside it as an alternative "container" for ZipEntry, when reading zips.
-//
-// It adds one interesting method to the normal "stream" interface: GetNextEntry.
-//
-// ------------------------------------------------------------------
-//
-
-using System;
-using System.Threading;
-using System.Collections.Generic;
-using System.IO;
-using Ionic.Zip;
-using OfficeOpenXml.Packaging.Ionic.Zip;
-using OfficeOpenXml.Packaging.Ionic.Crc;
-
-namespace  Ionic.Zip
-{
-    /// <summary>
-    ///   Provides a stream metaphor for reading zip files.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    ///   This class provides an alternative programming model for reading zip files to
-    ///   the one enabled by the <see cref="ZipFile"/> class.  Use this when reading zip
-    ///   files, as an alternative to the <see cref="ZipFile"/> class, when you would
-    ///   like to use a Stream class to read the file.
-    /// </para>
-    ///
-    /// <para>
-    ///   Some application designs require a readable stream for input. This stream can
-    ///   be used to read a zip file, and extract entries.
-    /// </para>
-    ///
-    /// <para>
-    ///   Both the <c>ZipInputStream</c> class and the <c>ZipFile</c> class can be used
-    ///   to read and extract zip files.  Both of them support many of the common zip
-    ///   features, including Unicode, different compression levels, and ZIP64.  The
-    ///   programming models differ. For example, when extracting entries via calls to
-    ///   the <c>GetNextEntry()</c> and <c>Read()</c> methods on the
-    ///   <c>ZipInputStream</c> class, the caller is responsible for creating the file,
-    ///   writing the bytes into the file, setting the attributes on the file, and
-    ///   setting the created, last modified, and last accessed timestamps on the
-    ///   file. All of these things are done automatically by a call to <see
-    ///   cref="ZipEntry.Extract()">ZipEntry.Extract()</see>.  For this reason, the
-    ///   <c>ZipInputStream</c> is generally recommended for when your application wants
-    ///   to extract the data, without storing that data into a file.
-    /// </para>
-    ///
-    /// <para>
-    ///   Aside from the obvious differences in programming model, there are some
-    ///   differences in capability between the <c>ZipFile</c> class and the
-    ///   <c>ZipInputStream</c> class.
-    /// </para>
-    ///
-    /// <list type="bullet">
-    ///   <item>
-    ///     <c>ZipFile</c> can be used to create or update zip files, or read and
-    ///     extract zip files. <c>ZipInputStream</c> can be used only to read and
-    ///     extract zip files. If you want to use a stream to create zip files, check
-    ///     out the <see cref="ZipOutputStream"/>.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipInputStream</c> cannot read segmented or spanned
-    ///     zip files.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipInputStream</c> will not read Zip file comments.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     When reading larger files, <c>ZipInputStream</c> will always underperform
-    ///     <c>ZipFile</c>. This is because the <c>ZipInputStream</c> does a full scan on the
-    ///     zip file, while the <c>ZipFile</c> class reads the central directory of the
-    ///     zip file.
-    ///   </item>
-    ///
-    /// </list>
-    ///
-    /// </remarks>
-    internal class ZipInputStream : Stream
-    {
-        /// <summary>
-        ///   Create a <c>ZipInputStream</c>, wrapping it around an existing stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   While the <see cref="ZipFile"/> class is generally easier
-        ///   to use, this class provides an alternative to those
-        ///   applications that want to read from a zipfile directly,
-        ///   using a <see cref="System.IO.Stream"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Both the <c>ZipInputStream</c> class and the <c>ZipFile</c> class can be used
-        ///   to read and extract zip files.  Both of them support many of the common zip
-        ///   features, including Unicode, different compression levels, and ZIP64.  The
-        ///   programming models differ. For example, when extracting entries via calls to
-        ///   the <c>GetNextEntry()</c> and <c>Read()</c> methods on the
-        ///   <c>ZipInputStream</c> class, the caller is responsible for creating the file,
-        ///   writing the bytes into the file, setting the attributes on the file, and
-        ///   setting the created, last modified, and last accessed timestamps on the
-        ///   file. All of these things are done automatically by a call to <see
-        ///   cref="ZipEntry.Extract()">ZipEntry.Extract()</see>.  For this reason, the
-        ///   <c>ZipInputStream</c> is generally recommended for when your application wants
-        ///   to extract the data, without storing that data into a file.
-        /// </para>
-        ///
-        /// <para>
-        ///   Aside from the obvious differences in programming model, there are some
-        ///   differences in capability between the <c>ZipFile</c> class and the
-        ///   <c>ZipInputStream</c> class.
-        /// </para>
-        ///
-        /// <list type="bullet">
-        ///   <item>
-        ///   <c>ZipFile</c> can be used to create or update zip files, or read and extract
-        ///   zip files. <c>ZipInputStream</c> can be used only to read and extract zip
-        ///     files. If you want to use a stream to create zip files, check out the <see
-        ///     cref="ZipOutputStream"/>.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <c>ZipInputStream</c> cannot read segmented or spanned
-        ///     zip files.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     <c>ZipInputStream</c> will not read Zip file comments.
-        ///   </item>
-        ///
-        ///   <item>
-        ///     When reading larger files, <c>ZipInputStream</c> will always underperform
-        ///     <c>ZipFile</c>. This is because the <c>ZipInputStream</c> does a full scan on the
-        ///     zip file, while the <c>ZipFile</c> class reads the central directory of the
-        ///     zip file.
-        ///   </item>
-        ///
-        /// </list>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The stream to read. It must be readable. This stream will be closed at
-        ///   the time the <c>ZipInputStream</c> is closed.
-        /// </param>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to read a zip file, and extract entries, using the
-        ///   <c>ZipInputStream</c> class.
-        ///
-        /// <code lang="C#">
-        /// private void Unzip()
-        /// {
-        ///     byte[] buffer= new byte[2048];
-        ///     int n;
-        ///     using (var raw = File.Open(inputFileName, FileMode.Open, FileAccess.Read))
-        ///     {
-        ///         using (var input= new ZipInputStream(raw))
-        ///         {
-        ///             ZipEntry e;
-        ///             while (( e = input.GetNextEntry()) != null)
-        ///             {
-        ///                 if (e.IsDirectory) continue;
-        ///                 string outputPath = Path.Combine(extractDir, e.FileName);
-        ///                 using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))
-        ///                 {
-        ///                     while ((n= input.Read(buffer, 0, buffer.Length)) > 0)
-        ///                     {
-        ///                         output.Write(buffer,0,n);
-        ///                     }
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub UnZip()
-        ///     Dim inputFileName As String = "MyArchive.zip"
-        ///     Dim extractDir As String = "extract"
-        ///     Dim buffer As Byte() = New Byte(2048) {}
-        ///     Using raw As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read)
-        ///         Using input As ZipInputStream = New ZipInputStream(raw)
-        ///             Dim e As ZipEntry
-        ///             Do While (Not e = input.GetNextEntry Is Nothing)
-        ///                 If Not e.IsDirectory Then
-        ///                     Using output As FileStream = File.Open(Path.Combine(extractDir, e.FileName), _
-        ///                                                            FileMode.Create, FileAccess.ReadWrite)
-        ///                         Dim n As Integer
-        ///                         Do While (n = input.Read(buffer, 0, buffer.Length) > 0)
-        ///                             output.Write(buffer, 0, n)
-        ///                         Loop
-        ///                     End Using
-        ///                 End If
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipInputStream(Stream stream)  : this (stream, false) { }
-
-
-
-        /// <summary>
-        ///   Create a <c>ZipInputStream</c>, given the name of an existing zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This constructor opens a <c>FileStream</c> for the given zipfile, and
-        ///   wraps a <c>ZipInputStream</c> around that.  See the documentation for the
-        ///   <see cref="ZipInputStream(Stream)"/> constructor for full details.
-        /// </para>
-        ///
-        /// <para>
-        ///   While the <see cref="ZipFile"/> class is generally easier
-        ///   to use, this class provides an alternative to those
-        ///   applications that want to read from a zipfile directly,
-        ///   using a <see cref="System.IO.Stream"/>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="fileName">
-        ///   The name of the filesystem file to read.
-        /// </param>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to read a zip file, and extract entries, using the
-        ///   <c>ZipInputStream</c> class.
-        ///
-        /// <code lang="C#">
-        /// private void Unzip()
-        /// {
-        ///     byte[] buffer= new byte[2048];
-        ///     int n;
-        ///     using (var input= new ZipInputStream(inputFileName))
-        ///     {
-        ///         ZipEntry e;
-        ///         while (( e = input.GetNextEntry()) != null)
-        ///         {
-        ///             if (e.IsDirectory) continue;
-        ///             string outputPath = Path.Combine(extractDir, e.FileName);
-        ///             using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))
-        ///             {
-        ///                 while ((n= input.Read(buffer, 0, buffer.Length)) > 0)
-        ///                 {
-        ///                     output.Write(buffer,0,n);
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub UnZip()
-        ///     Dim inputFileName As String = "MyArchive.zip"
-        ///     Dim extractDir As String = "extract"
-        ///     Dim buffer As Byte() = New Byte(2048) {}
-        ///     Using input As ZipInputStream = New ZipInputStream(inputFileName)
-        ///         Dim e As ZipEntry
-        ///         Do While (Not e = input.GetNextEntry Is Nothing)
-        ///             If Not e.IsDirectory Then
-        ///                 Using output As FileStream = File.Open(Path.Combine(extractDir, e.FileName), _
-        ///                                                        FileMode.Create, FileAccess.ReadWrite)
-        ///                     Dim n As Integer
-        ///                     Do While (n = input.Read(buffer, 0, buffer.Length) > 0)
-        ///                         output.Write(buffer, 0, n)
-        ///                     Loop
-        ///                 End Using
-        ///             End If
-        ///         Loop
-        ///     End Using
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipInputStream(String fileName)
-        {
-            Stream stream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read );
-            _Init(stream, false, fileName);
-        }
-
-
-        /// <summary>
-        ///   Create a <c>ZipInputStream</c>, explicitly specifying whether to
-        ///   keep the underlying stream open.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   See the documentation for the <see
-        ///   cref="ZipInputStream(Stream)">ZipInputStream(Stream)</see>
-        ///   constructor for a discussion of the class, and an example of how to use the class.
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The stream to read from. It must be readable.
-        /// </param>
-        ///
-        /// <param name="leaveOpen">
-        ///   true if the application would like the stream
-        ///   to remain open after the <c>ZipInputStream</c> has been closed.
-        /// </param>
-        public ZipInputStream(Stream stream, bool leaveOpen)
-        {
-            _Init(stream, leaveOpen, null);
-        }
-
-        private void _Init(Stream stream, bool leaveOpen, string name)
-        {
-            _inputStream = stream;
-            if (!_inputStream.CanRead)
-                throw new ZipException("The stream must be readable.");
-            _container= new ZipContainer(this);
-            _provisionalAlternateEncoding = System.Text.Encoding.ASCII;
-            _leaveUnderlyingStreamOpen = leaveOpen;
-            _findRequired= true;
-            _name = name ?? "(stream)";
-        }
-
-
-        /// <summary>Provides a string representation of the instance.</summary>
-        /// <remarks>
-        ///   <para>
-        ///     This can be useful for debugging purposes.
-        ///   </para>
-        /// </remarks>
-        /// <returns>a string representation of the instance.</returns>
-        public override String ToString()
-        {
-            return String.Format ("ZipInputStream::{0}(leaveOpen({1})))", _name, _leaveUnderlyingStreamOpen);
-        }
-
-
-        /// <summary>
-        ///   The text encoding to use when reading entries into the zip archive, for
-        ///   those entries whose filenames or comments cannot be encoded with the
-        ///   default (IBM437) encoding.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its
-        ///   zip specification</see>, PKWare describes two options for encoding
-        ///   filenames and comments: using IBM437 or UTF-8.  But, some archiving tools
-        ///   or libraries do not follow the specification, and instead encode
-        ///   characters using the system default code page.  For example, WinRAR when
-        ///   run on a machine in Shanghai may encode filenames with the Big-5 Chinese
-        ///   (950) code page.  This behavior is contrary to the Zip specification, but
-        ///   it occurs anyway.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using DotNetZip to read zip archives that use something other than
-        ///   UTF-8 or IBM437, set this property to specify the code page to use when
-        ///   reading encoded filenames and comments for each <c>ZipEntry</c> in the zip
-        ///   file.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is "provisional". When the entry in the zip archive is not
-        ///   explicitly marked as using UTF-8, then IBM437 is used to decode filenames
-        ///   and comments. If a loss of data would result from using IBM436 -
-        ///   specifically when encoding and decoding is not reflexive - the codepage
-        ///   specified here is used. It is possible, therefore, to have a given entry
-        ///   with a <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with
-        ///   the specified "provisional" codepage.
-        /// </para>
-        ///
-        /// <para>
-        ///   When a zip file uses an arbitrary, non-UTF8 code page for encoding, there
-        ///   is no standard way for the reader application - whether DotNetZip, WinZip,
-        ///   WinRar, or something else - to know which codepage has been used for the
-        ///   entries. Readers of zip files are not able to inspect the zip file and
-        ///   determine the codepage that was used for the entries contained within it.
-        ///   It is left to the application or user to determine the necessary codepage
-        ///   when reading zip files encoded this way.  If you use an incorrect codepage
-        ///   when reading a zipfile, you will get entries with filenames that are
-        ///   incorrect, and the incorrect filenames may even contain characters that
-        ///   are not legal for use within filenames in Windows. Extracting entries with
-        ///   illegal characters in the filenames will lead to exceptions. It's too bad,
-        ///   but this is just the way things are with code pages in zip files. Caveat
-        ///   Emptor.
-        /// </para>
-        ///
-        /// </remarks>
-        public System.Text.Encoding ProvisionalAlternateEncoding
-        {
-            get
-            {
-                return _provisionalAlternateEncoding;
-            }
-            set
-            {
-                _provisionalAlternateEncoding = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   Size of the work buffer to use for the ZLIB codec during decompression.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Setting this affects the performance and memory efficiency of compression
-        ///   and decompression.  For larger files, setting this to a larger size may
-        ///   improve performance, but the exact numbers vary depending on available
-        ///   memory, and a bunch of other variables. I don't have good firm
-        ///   recommendations on how to set it.  You'll have to test it yourself. Or
-        ///   just leave it alone and accept the default.
-        /// </remarks>
-        public int CodecBufferSize
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   Sets the password to be used on the <c>ZipInputStream</c> instance.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When reading a zip archive, this password is used to read and decrypt the
-        ///   entries that are encrypted within the zip file. When entries within a zip
-        ///   file use different passwords, set the appropriate password for the entry
-        ///   before the first call to <c>Read()</c> for each entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   When reading an entry that is not encrypted, the value of this property is
-        ///   ignored.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example uses the ZipInputStream to read and extract entries from a
-        ///   zip file, using a potentially different password for each entry.
-        ///
-        /// <code lang="C#">
-        /// byte[] buffer= new byte[2048];
-        /// int n;
-        /// using (var raw = File.Open(_inputFileName, FileMode.Open, FileAccess.Read ))
-        /// {
-        ///     using (var input= new ZipInputStream(raw))
-        ///     {
-        ///         ZipEntry e;
-        ///         while (( e = input.GetNextEntry()) != null)
-        ///         {
-        ///             input.Password = PasswordForEntry(e.FileName);
-        ///             if (e.IsDirectory) continue;
-        ///             string outputPath = Path.Combine(_extractDir, e.FileName);
-        ///             using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))
-        ///             {
-        ///                 while ((n= input.Read(buffer,0,buffer.Length)) > 0)
-        ///                 {
-        ///                     output.Write(buffer,0,n);
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        ///
-        /// </code>
-        /// </example>
-        public String Password
-        {
-            set
-            {
-                if (_closed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-                _Password = value;
-            }
-        }
-
-
-        private void SetupStream()
-        {
-            // Seek to the correct posn in the file, and open a
-            // stream that can be read.
-            _crcStream= _currentEntry.InternalOpenReader(_Password);
-            _LeftToRead = _crcStream.Length;
-            _needSetup = false;
-        }
-
-
-
-        internal Stream ReadStream
-        {
-            get
-            {
-                return _inputStream;
-            }
-        }
-
-
-        /// <summary>
-        ///   Read the data from the stream into the buffer.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The data for the zipentry will be decrypted and uncompressed, as
-        ///   necessary, before being copied into the buffer.
-        /// </para>
-        ///
-        /// <para>
-        ///   You must set the <see cref="Password"/> property before calling
-        ///   <c>Read()</c> the first time for an encrypted entry.  To determine if an
-        ///   entry is encrypted and requires a password, check the <see
-        ///   cref="ZipEntry.Encryption">ZipEntry.Encryption</see> property.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="buffer">The buffer to hold the data read from the stream.</param>
-        /// <param name="offset">the offset within the buffer to copy the first byte read.</param>
-        /// <param name="count">the number of bytes to read.</param>
-        /// <returns>the number of bytes read, after decryption and decompression.</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_closed)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("The stream has been closed.");
-            }
-
-            if (_needSetup)
-                SetupStream();
-
-            if (_LeftToRead == 0) return 0;
-
-            int len = (_LeftToRead > count) ? count : (int)_LeftToRead;
-            int n = _crcStream.Read(buffer, offset, len);
-
-            _LeftToRead -= n;
-
-            if (_LeftToRead == 0)
-            {
-                int CrcResult = _crcStream.Crc;
-                _currentEntry.VerifyCrcAfterExtract(CrcResult);
-                _inputStream.Seek(_endOfEntry, SeekOrigin.Begin);
-                // workitem 10178
-                SharedUtilities.Workaround_Ladybug318918(_inputStream);
-            }
-
-            return n;
-        }
-
-
-
-        /// <summary>
-        ///   Read the next entry from the zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Call this method just before calling <see cref="Read(byte[], int, int)"/>,
-        ///   to position the pointer in the zip file to the next entry that can be
-        ///   read.  Subsequent calls to <c>Read()</c>, will decrypt and decompress the
-        ///   data in the zip file, until <c>Read()</c> returns 0.
-        /// </para>
-        ///
-        /// <para>
-        ///   Each time you call <c>GetNextEntry()</c>, the pointer in the wrapped
-        ///   stream is moved to the next entry in the zip file.  If you call <see
-        ///   cref="Seek(long, SeekOrigin)"/>, and thus re-position the pointer within
-        ///   the file, you will need to call <c>GetNextEntry()</c> again, to insure
-        ///   that the file pointer is positioned at the beginning of a zip entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method returns the <c>ZipEntry</c>. Using a stream approach, you will
-        ///   read the raw bytes for an entry in a zip file via calls to <c>Read()</c>.
-        ///   Alternatively, you can extract an entry into a file, or a stream, by
-        ///   calling <see cref="ZipEntry.Extract()"/>, or one of its siblings.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <returns>
-        ///   The <c>ZipEntry</c> read. Returns null (or Nothing in VB) if there are no more
-        ///   entries in the zip file.
-        /// </returns>
-        ///
-        public ZipEntry GetNextEntry()
-        {
-            if (_findRequired)
-            {
-                // find the next signature
-                long d = SharedUtilities.FindSignature(_inputStream, ZipConstants.ZipEntrySignature);
-                if (d == -1) return null;
-                // back up 4 bytes: ReadEntry assumes the file pointer is positioned before the entry signature
-                _inputStream.Seek(-4, SeekOrigin.Current);
-                // workitem 10178
-                SharedUtilities.Workaround_Ladybug318918(_inputStream);
-            }
-            // workitem 10923
-            else if (_firstEntry)
-            {
-                // we've already read one entry.
-                // Seek to the end of it.
-                _inputStream.Seek(_endOfEntry, SeekOrigin.Begin);
-                SharedUtilities.Workaround_Ladybug318918(_inputStream);
-            }
-
-            _currentEntry = ZipEntry.ReadEntry(_container, !_firstEntry);
-            // ReadEntry leaves the file position after all the entry
-            // data and the optional bit-3 data descriptpr.  This is
-            // where the next entry would normally start.
-            _endOfEntry = _inputStream.Position;
-            _firstEntry = true;
-            _needSetup = true;
-            _findRequired= false;
-            return _currentEntry;
-        }
-
-
-        /// <summary>
-        ///   Dispose the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method disposes the ZipInputStream.  It may also close the
-        ///   underlying stream, depending on which constructor was used.
-        /// </para>
-        ///
-        /// <para>
-        ///   Typically the application will call <c>Dispose()</c> implicitly, via
-        ///   a <c>using</c> statement in C#, or a <c>Using</c> statement in VB.
-        /// </para>
-        ///
-        ///   <para>
-        ///     Application code won't call this code directly.  This method may
-        ///     be invoked in two distinct scenarios.  If disposing == true, the
-        ///     method has been called directly or indirectly by a user's code,
-        ///     for example via the public Dispose() method. In this case, both
-        ///     managed and unmanaged resources can be referenced and disposed.
-        ///     If disposing == false, the method has been called by the runtime
-        ///     from inside the object finalizer and this method should not
-        ///     reference other objects; in that case only unmanaged resources
-        ///     must be referenced or disposed.
-        ///   </para>
-        /// </remarks>
-        ///
-        /// <param name="disposing">
-        ///   true if the Dispose method was invoked by user code.
-        /// </param>
-        protected override void Dispose(bool disposing)
-        {
-            if (_closed) return;
-
-            if (disposing) // not called from finalizer
-            {
-                // When ZipInputStream is used within a using clause, and an
-                // exception is thrown, Close() is invoked.  But we don't want to
-                // try to write anything in that case.  Eventually the exception
-                // will be propagated to the application.
-                if (_exceptionPending) return;
-
-                if (!_leaveUnderlyingStreamOpen)
-                {
-#if NETCF
-                    _inputStream.Close();
-#else
-                    _inputStream.Dispose();
-#endif
-                }
-            }
-            _closed= true;
-        }
-
-
-        /// <summary>
-        /// Always returns true.
-        /// </summary>
-        public override bool CanRead  { get { return true; }}
-
-        /// <summary>
-        /// Returns the value of <c>CanSeek</c> for the underlying (wrapped) stream.
-        /// </summary>
-        public override bool CanSeek  { get { return _inputStream.CanSeek; } }
-
-        /// <summary>
-        /// Always returns false.
-        /// </summary>
-        public override bool CanWrite { get { return false; } }
-
-        /// <summary>
-        /// Returns the length of the underlying stream.
-        /// </summary>
-        public override long Length   { get { return _inputStream.Length; }}
-
-        /// <summary>
-        /// Gets or sets the position of the underlying stream.
-        /// </summary>
-        /// <remarks>
-        /// Setting the position is equivalent to calling <c>Seek(value, SeekOrigin.Begin)</c>.
-        /// </remarks>
-        public override long Position
-        {
-            get { return _inputStream.Position;}
-            set { Seek(value, SeekOrigin.Begin); }
-        }
-
-        /// <summary>
-        /// This is a no-op.
-        /// </summary>
-        public override void Flush()
-        {
-            throw new NotSupportedException("Flush");
-        }
-
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="buffer">ignored</param>
-        /// <param name="offset">ignored</param>
-        /// <param name="count">ignored</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException("Write");
-        }
-
-
-        /// <summary>
-        ///   This method seeks in the underlying stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Call this method if you want to seek around within the zip file for random access.
-        /// </para>
-        ///
-        /// <para>
-        ///   Applications can intermix calls to <c>Seek()</c> with calls to <see
-        ///   cref="GetNextEntry()"/>.  After a call to <c>Seek()</c>,
-        ///   <c>GetNextEntry()</c> will get the next <c>ZipEntry</c> that falls after
-        ///   the current position in the input stream. You're on your own for finding
-        ///   out just where to seek in the stream, to get to the various entries.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="offset">the offset point to seek to</param>
-        /// <param name="origin">the reference point from which to seek</param>
-        /// <returns>The new position</returns>
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            _findRequired= true;
-            var x = _inputStream.Seek(offset, origin);
-            // workitem 10178
-            SharedUtilities.Workaround_Ladybug318918(_inputStream);
-            return x;
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="value">ignored</param>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-
-        private Stream _inputStream;
-        private System.Text.Encoding _provisionalAlternateEncoding;
-        private ZipEntry _currentEntry;
-        private bool _firstEntry;
-        private bool _needSetup;
-        private ZipContainer _container;
-        private CrcCalculatorStream _crcStream;
-        private Int64 _LeftToRead;
-        internal String _Password;
-        private Int64 _endOfEntry;
-        private string _name;
-
-        private bool _leaveUnderlyingStreamOpen;
-        private bool _closed;
-        private bool _findRequired;
-        private bool _exceptionPending;
-    }
-
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipOutputStream.cs b/EPPlus/Packaging/DotNetZip/ZipOutputStream.cs
deleted file mode 100644
index 6ad801a..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipOutputStream.cs
+++ /dev/null
@@ -1,1818 +0,0 @@
-// ZipOutputStream.cs
-//
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-28 06:34:30>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZipOutputStream class, which is a stream metaphor for
-// generating zip files.  This class does not depend on Ionic.Zip.ZipFile, but rather
-// stands alongside it as an alternative "container" for ZipEntry.  It replicates a
-// subset of the properties, including these:
-//
-//  - Comment
-//  - Encryption
-//  - Password
-//  - CodecBufferSize
-//  - CompressionLevel
-//  - CompressionMethod
-//  - EnableZip64 (UseZip64WhenSaving)
-//  - IgnoreCase (!CaseSensitiveRetrieval)
-//
-// It adds these novel methods:
-//
-//  - PutNextEntry
-//
-//
-// ------------------------------------------------------------------
-//
-
-using System;
-using System.Threading;
-using System.Collections.Generic;
-using System.IO;
-using Ionic.Zip;
-using OfficeOpenXml.Packaging.Ionic.Zlib;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    /// <summary>
-    ///   Provides a stream metaphor for generating zip files.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    ///   This class writes zip files, as defined in the <see
-    ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specification
-    ///   for zip files described by PKWare</see>.  The compression for this
-    ///   implementation is provided by a managed-code version of Zlib, included with
-    ///   DotNetZip in the classes in the Ionic.Zlib namespace.
-    /// </para>
-    ///
-    /// <para>
-    ///   This class provides an alternative programming model to the one enabled by the
-    ///   <see cref="ZipFile"/> class. Use this when creating zip files, as an
-    ///   alternative to the <see cref="ZipFile"/> class, when you would like to use a
-    ///   <c>Stream</c> type to write the zip file.
-    /// </para>
-    ///
-    /// <para>
-    ///   Both the <c>ZipOutputStream</c> class and the <c>ZipFile</c> class can be used
-    ///   to create zip files. Both of them support many of the common zip features,
-    ///   including Unicode, different compression levels, and ZIP64.   They provide
-    ///   very similar performance when creating zip files.
-    /// </para>
-    ///
-    /// <para>
-    ///   The <c>ZipFile</c> class is generally easier to use than
-    ///   <c>ZipOutputStream</c> and should be considered a higher-level interface.  For
-    ///   example, when creating a zip file via calls to the <c>PutNextEntry()</c> and
-    ///   <c>Write()</c> methods on the <c>ZipOutputStream</c> class, the caller is
-    ///   responsible for opening the file, reading the bytes from the file, writing
-    ///   those bytes into the <c>ZipOutputStream</c>, setting the attributes on the
-    ///   <c>ZipEntry</c>, and setting the created, last modified, and last accessed
-    ///   timestamps on the zip entry. All of these things are done automatically by a
-    ///   call to <see cref="ZipFile.AddFile(string,string)">ZipFile.AddFile()</see>.
-    ///   For this reason, the <c>ZipOutputStream</c> is generally recommended for use
-    ///   only when your application emits arbitrary data, not necessarily data from a
-    ///   filesystem file, directly into a zip file, and does so using a <c>Stream</c>
-    ///   metaphor.
-    /// </para>
-    ///
-    /// <para>
-    ///   Aside from the differences in programming model, there are other
-    ///   differences in capability between the two classes.
-    /// </para>
-    ///
-    /// <list type="bullet">
-    ///   <item>
-    ///     <c>ZipFile</c> can be used to read and extract zip files, in addition to
-    ///     creating zip files. <c>ZipOutputStream</c> cannot read zip files. If you want
-    ///     to use a stream to read zip files, check out the <see cref="ZipInputStream"/> class.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipOutputStream</c> does not support the creation of segmented or spanned
-    ///     zip files.
-    ///   </item>
-    ///
-    ///   <item>
-    ///     <c>ZipOutputStream</c> cannot produce a self-extracting archive.
-    ///   </item>
-    /// </list>
-    ///
-    /// <para>
-    ///   Be aware that the <c>ZipOutputStream</c> class implements the <see
-    ///   cref="System.IDisposable"/> interface.  In order for
-    ///   <c>ZipOutputStream</c> to produce a valid zip file, you use use it within
-    ///   a using clause (<c>Using</c> in VB), or call the <c>Dispose()</c> method
-    ///   explicitly.  See the examples for how to employ a using clause.
-    /// </para>
-    ///
-    /// <para>
-    ///   Also, a note regarding compression performance: On the desktop .NET
-    ///   Framework, DotNetZip can use a multi-threaded compression implementation
-    ///   that provides significant speed increases on large files, over 300k or so,
-    ///   at the cost of increased memory use at runtime.  (The output of the
-    ///   compression is almost exactly the same size).  But, the multi-threaded
-    ///   approach incurs a performance hit on smaller files. There's no way for the
-    ///   ZipOutputStream to know whether parallel compression will be beneficial,
-    ///   because the ZipOutputStream does not know how much data you will write
-    ///   through the stream.  You may wish to set the <see
-    ///   cref="ParallelDeflateThreshold"/> property to zero, if you are compressing
-    ///   large files through <c>ZipOutputStream</c>.  This will cause parallel
-    ///   compression to be used, always.
-    /// </para>
-    /// </remarks>
-    internal class ZipOutputStream : Stream
-    {
-        /// <summary>
-        ///   Create a ZipOutputStream, wrapping an existing stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The <see cref="ZipFile"/> class is generally easier to use when creating
-        ///   zip files. The ZipOutputStream offers a different metaphor for creating a
-        ///   zip file, based on the <see cref="System.IO.Stream"/> class.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        /// The stream to wrap. It must be writable. This stream will be closed at
-        /// the time the ZipOutputStream is closed.
-        /// </param>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to create a zip file, using the
-        ///   ZipOutputStream class.
-        ///
-        /// <code lang="C#">
-        /// private void Zipup()
-        /// {
-        ///     if (filesToZip.Count == 0)
-        ///     {
-        ///         System.Console.WriteLine("Nothing to do.");
-        ///         return;
-        ///     }
-        ///
-        ///     using (var raw = File.Open(_outputFileName, FileMode.Create, FileAccess.ReadWrite ))
-        ///     {
-        ///         using (var output= new ZipOutputStream(raw))
-        ///         {
-        ///             output.Password = "VerySecret!";
-        ///             output.Encryption = EncryptionAlgorithm.WinZipAes256;
-        ///
-        ///             foreach (string inputFileName in filesToZip)
-        ///             {
-        ///                 System.Console.WriteLine("file: {0}", inputFileName);
-        ///
-        ///                 output.PutNextEntry(inputFileName);
-        ///                 using (var input = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write ))
-        ///                 {
-        ///                     byte[] buffer= new byte[2048];
-        ///                     int n;
-        ///                     while ((n= input.Read(buffer,0,buffer.Length)) > 0)
-        ///                     {
-        ///                         output.Write(buffer,0,n);
-        ///                     }
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub Zipup()
-        ///     Dim outputFileName As String = "XmlData.zip"
-        ///     Dim filesToZip As String() = Directory.GetFiles(".", "*.xml")
-        ///     If (filesToZip.Length = 0) Then
-        ///         Console.WriteLine("Nothing to do.")
-        ///     Else
-        ///         Using raw As FileStream = File.Open(outputFileName, FileMode.Create, FileAccess.ReadWrite)
-        ///             Using output As ZipOutputStream = New ZipOutputStream(raw)
-        ///                 output.Password = "VerySecret!"
-        ///                 output.Encryption = EncryptionAlgorithm.WinZipAes256
-        ///                 Dim inputFileName As String
-        ///                 For Each inputFileName In filesToZip
-        ///                     Console.WriteLine("file: {0}", inputFileName)
-        ///                     output.PutNextEntry(inputFileName)
-        ///                     Using input As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
-        ///                         Dim n As Integer
-        ///                         Dim buffer As Byte() = New Byte(2048) {}
-        ///                         Do While (n = input.Read(buffer, 0, buffer.Length) > 0)
-        ///                             output.Write(buffer, 0, n)
-        ///                         Loop
-        ///                     End Using
-        ///                 Next
-        ///             End Using
-        ///         End Using
-        ///     End If
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipOutputStream(Stream stream) : this(stream, false) { }
-
-
-        /// <summary>
-        ///   Create a ZipOutputStream that writes to a filesystem file.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   The <see cref="ZipFile"/> class is generally easier to use when creating
-        ///   zip files. The ZipOutputStream offers a different metaphor for creating a
-        ///   zip file, based on the <see cref="System.IO.Stream"/> class.
-        /// </remarks>
-        ///
-        /// <param name="fileName">
-        ///   The name of the zip file to create.
-        /// </param>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to create a zip file, using the
-        ///   ZipOutputStream class.
-        ///
-        /// <code lang="C#">
-        /// private void Zipup()
-        /// {
-        ///     if (filesToZip.Count == 0)
-        ///     {
-        ///         System.Console.WriteLine("Nothing to do.");
-        ///         return;
-        ///     }
-        ///
-        ///     using (var output= new ZipOutputStream(outputFileName))
-        ///     {
-        ///         output.Password = "VerySecret!";
-        ///         output.Encryption = EncryptionAlgorithm.WinZipAes256;
-        ///
-        ///         foreach (string inputFileName in filesToZip)
-        ///         {
-        ///             System.Console.WriteLine("file: {0}", inputFileName);
-        ///
-        ///             output.PutNextEntry(inputFileName);
-        ///             using (var input = File.Open(inputFileName, FileMode.Open, FileAccess.Read,
-        ///                                          FileShare.Read | FileShare.Write ))
-        ///             {
-        ///                 byte[] buffer= new byte[2048];
-        ///                 int n;
-        ///                 while ((n= input.Read(buffer,0,buffer.Length)) > 0)
-        ///                 {
-        ///                     output.Write(buffer,0,n);
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub Zipup()
-        ///     Dim outputFileName As String = "XmlData.zip"
-        ///     Dim filesToZip As String() = Directory.GetFiles(".", "*.xml")
-        ///     If (filesToZip.Length = 0) Then
-        ///         Console.WriteLine("Nothing to do.")
-        ///     Else
-        ///         Using output As ZipOutputStream = New ZipOutputStream(outputFileName)
-        ///             output.Password = "VerySecret!"
-        ///             output.Encryption = EncryptionAlgorithm.WinZipAes256
-        ///             Dim inputFileName As String
-        ///             For Each inputFileName In filesToZip
-        ///                 Console.WriteLine("file: {0}", inputFileName)
-        ///                 output.PutNextEntry(inputFileName)
-        ///                 Using input As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
-        ///                     Dim n As Integer
-        ///                     Dim buffer As Byte() = New Byte(2048) {}
-        ///                     Do While (n = input.Read(buffer, 0, buffer.Length) > 0)
-        ///                         output.Write(buffer, 0, n)
-        ///                     Loop
-        ///                 End Using
-        ///             Next
-        ///         End Using
-        ///     End If
-        /// End Sub
-        /// </code>
-        /// </example>
-        public ZipOutputStream(String fileName)
-        {
-            Stream stream = File.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
-            _Init(stream, false, fileName);
-        }
-
-
-        /// <summary>
-        ///   Create a ZipOutputStream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   See the documentation for the <see
-        ///   cref="ZipOutputStream(Stream)">ZipOutputStream(Stream)</see>
-        ///   constructor for an example.
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The stream to wrap. It must be writable.
-        /// </param>
-        ///
-        /// <param name="leaveOpen">
-        ///   true if the application would like the stream
-        ///   to remain open after the <c>ZipOutputStream</c> has been closed.
-        /// </param>
-        public ZipOutputStream(Stream stream, bool leaveOpen)
-        {
-            _Init(stream, leaveOpen, null);
-        }
-
-        private void _Init(Stream stream, bool leaveOpen, string name)
-        {
-            // workitem 9307
-            _outputStream = stream.CanRead ? stream : new CountingStream(stream);
-            CompressionLevel = OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel.Default;
-            CompressionMethod = OfficeOpenXml.Packaging.Ionic.Zip.CompressionMethod.Deflate;
-            _encryption = EncryptionAlgorithm.None;
-            _entriesWritten = new Dictionary<String, ZipEntry>(StringComparer.Ordinal);
-            _zip64 = Zip64Option.Never;
-            _leaveUnderlyingStreamOpen = leaveOpen;
-            Strategy = Ionic.Zlib.CompressionStrategy.Default;
-            _name = name ?? "(stream)";
-#if !NETCF
-            ParallelDeflateThreshold = -1L;
-#endif
-        }
-
-
-        /// <summary>Provides a string representation of the instance.</summary>
-        /// <remarks>
-        ///   <para>
-        ///     This can be useful for debugging purposes.
-        ///   </para>
-        /// </remarks>
-        /// <returns>a string representation of the instance.</returns>
-        public override String ToString()
-        {
-            return String.Format ("ZipOutputStream::{0}(leaveOpen({1})))", _name, _leaveUnderlyingStreamOpen);
-        }
-
-
-        /// <summary>
-        ///   Sets the password to be used on the <c>ZipOutputStream</c> instance.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When writing a zip archive, this password is applied to the entries, not
-        ///   to the zip archive itself. It applies to any <c>ZipEntry</c> subsequently
-        ///   written to the <c>ZipOutputStream</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   Using a password does not encrypt or protect the "directory" of the
-        ///   archive - the list of entries contained in the archive.  If you set the
-        ///   <c>Password</c> property, the password actually applies to individual
-        ///   entries that are added to the archive, subsequent to the setting of this
-        ///   property.  The list of filenames in the archive that is eventually created
-        ///   will appear in clear text, but the contents of the individual files are
-        ///   encrypted.  This is how Zip encryption works.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set this property, and then add a set of entries to the archive via
-        ///   calls to <c>PutNextEntry</c>, then each entry is encrypted with that
-        ///   password.  You may also want to change the password between adding
-        ///   different entries. If you set the password, add an entry, then set the
-        ///   password to <c>null</c> (<c>Nothing</c> in VB), and add another entry, the
-        ///   first entry is encrypted and the second is not.
-        /// </para>
-        ///
-        /// <para>
-        ///   When setting the <c>Password</c>, you may also want to explicitly set the <see
-        ///   cref="Encryption"/> property, to specify how to encrypt the entries added
-        ///   to the ZipFile.  If you set the <c>Password</c> to a non-null value and do not
-        ///   set <see cref="Encryption"/>, then PKZip 2.0 ("Weak") encryption is used.
-        ///   This encryption is relatively weak but is very interoperable. If
-        ///   you set the password to a <c>null</c> value (<c>Nothing</c> in VB),
-        ///   <c>Encryption</c> is reset to None.
-        /// </para>
-        ///
-        /// <para>
-        ///   Special case: if you wrap a ZipOutputStream around a non-seekable stream,
-        ///   and use encryption, and emit an entry of zero bytes, the <c>Close()</c> or
-        ///   <c>PutNextEntry()</c> following the entry will throw an exception.
-        /// </para>
-        ///
-        /// </remarks>
-        public String Password
-        {
-            set
-            {
-                if (_disposed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-
-                _password = value;
-                if (_password == null)
-                {
-                    _encryption = EncryptionAlgorithm.None;
-                }
-                else if (_encryption == EncryptionAlgorithm.None)
-                {
-                    _encryption = EncryptionAlgorithm.PkzipWeak;
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///   The Encryption to use for entries added to the <c>ZipOutputStream</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The specified Encryption is applied to the entries subsequently
-        ///   written to the <c>ZipOutputStream</c> instance.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you set this to something other than
-        ///   EncryptionAlgorithm.None, you will also need to set the
-        ///   <see cref="Password"/> to a non-null, non-empty value in
-        ///   order to actually get encryption on the entry.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <seealso cref="Password">ZipOutputStream.Password</seealso>
-        /// <seealso cref="ZipEntry.Encryption">ZipEntry.Encryption</seealso>
-        public EncryptionAlgorithm Encryption
-        {
-            get
-            {
-                return _encryption;
-            }
-            set
-            {
-                if (_disposed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-                if (value == EncryptionAlgorithm.Unsupported)
-                {
-                    _exceptionPending = true;
-                    throw new InvalidOperationException("You may not set Encryption to that value.");
-                }
-                _encryption = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   Size of the work buffer to use for the ZLIB codec during compression.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Setting this may affect performance.  For larger files, setting this to a
-        ///   larger size may improve performance, but I'm not sure.  Sorry, I don't
-        ///   currently have good recommendations on how to set it.  You can test it if
-        ///   you like.
-        /// </remarks>
-        public int CodecBufferSize
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The compression strategy to use for all entries.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Set the Strategy used by the ZLIB-compatible compressor, when compressing
-        ///   data for the entries in the zip archive. Different compression strategies
-        ///   work better on different sorts of data. The strategy parameter can affect
-        ///   the compression ratio and the speed of compression but not the correctness
-        ///   of the compresssion.  For more information see <see
-        ///   cref="Ionic.Zlib.CompressionStrategy "/>.
-        /// </remarks>
-        public CompressionStrategy Strategy
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   The type of timestamp attached to the ZipEntry.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Set this in order to specify the kind of timestamp that should be emitted
-        ///   into the zip file for each entry.
-        /// </remarks>
-        public ZipEntryTimestamp Timestamp
-        {
-            get
-            {
-                return _timestamp;
-            }
-            set
-            {
-                if (_disposed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-                _timestamp = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   Sets the compression level to be used for entries subsequently added to
-        ///   the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///  <para>
-        ///    Varying the compression level used on entries can affect the
-        ///    size-vs-speed tradeoff when compression and decompressing data streams
-        ///    or files.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    As with some other properties on the <c>ZipOutputStream</c> class, like <see
-        ///    cref="Password"/>, and <see cref="Encryption"/>,
-        ///    setting this property on a <c>ZipOutputStream</c>
-        ///    instance will cause the specified <c>CompressionLevel</c> to be used on all
-        ///    <see cref="ZipEntry"/> items that are subsequently added to the
-        ///    <c>ZipOutputStream</c> instance.
-        ///  </para>
-        ///
-        ///  <para>
-        ///    If you do not set this property, the default compression level is used,
-        ///    which normally gives a good balance of compression efficiency and
-        ///    compression speed.  In some tests, using <c>BestCompression</c> can
-        ///    double the time it takes to compress, while delivering just a small
-        ///    increase in compression efficiency.  This behavior will vary with the
-        ///    type of data you compress.  If you are in doubt, just leave this setting
-        ///    alone, and accept the default.
-        ///  </para>
-        /// </remarks>
-        public OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel CompressionLevel
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   The compression method used on each entry added to the ZipOutputStream.
-        /// </summary>
-        public CompressionMethod CompressionMethod
-        {
-            get;
-            set;
-        }
-
-
-        /// <summary>
-        ///   A comment attached to the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The application sets this property to specify a comment to be embedded
-        ///   into the generated zip archive.
-        /// </para>
-        ///
-        /// <para>
-        ///   According to <see
-        ///   href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's
-        ///   zip specification</see>, the comment is not encrypted, even if there is a
-        ///   password set on the zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   The specification does not describe how to indicate the encoding used
-        ///   on a comment string. Many "compliant" zip tools and libraries use
-        ///   IBM437 as the code page for comments; DotNetZip, too, follows that
-        ///   practice.  On the other hand, there are situations where you want a
-        ///   Comment to be encoded with something else, for example using code page
-        ///   950 "Big-5 Chinese". To fill that need, DotNetZip will encode the
-        ///   comment following the same procedure it follows for encoding
-        ///   filenames: (a) if <see cref="AlternateEncodingUsage"/> is
-        ///   <c>Never</c>, it uses the default encoding (IBM437). (b) if <see
-        ///   cref="AlternateEncodingUsage"/> is <c>Always</c>, it always uses the
-        ///   alternate encoding (<see cref="AlternateEncoding"/>). (c) if <see
-        ///   cref="AlternateEncodingUsage"/> is <c>AsNecessary</c>, it uses the
-        ///   alternate encoding only if the default encoding is not sufficient for
-        ///   encoding the comment - in other words if decoding the result does not
-        ///   produce the original string.  This decision is taken at the time of
-        ///   the call to <c>ZipFile.Save()</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        public string Comment
-        {
-            get { return _comment; }
-            set
-            {
-                if (_disposed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-                _comment = value;
-            }
-        }
-
-
-
-        /// <summary>
-        ///   Specify whether to use ZIP64 extensions when saving a zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The default value for the property is <see
-        ///   cref="Zip64Option.Never"/>. <see cref="Zip64Option.AsNecessary"/> is
-        ///   safest, in the sense that you will not get an Exception if a
-        ///   pre-ZIP64 limit is exceeded.
-        /// </para>
-        ///
-        /// <para>
-        ///   You must set this property before calling <c>Write()</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        public Zip64Option EnableZip64
-        {
-            get
-            {
-                return _zip64;
-            }
-            set
-            {
-                if (_disposed)
-                {
-                    _exceptionPending = true;
-                    throw new System.InvalidOperationException("The stream has been closed.");
-                }
-                _zip64 = value;
-            }
-        }
-
-
-        /// <summary>
-        ///   Indicates whether ZIP64 extensions were used when saving the zip archive.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   The value is defined only after the <c>ZipOutputStream</c> has been closed.
-        /// </remarks>
-        public bool OutputUsedZip64
-        {
-            get
-            {
-                return _anyEntriesUsedZip64 || _directoryNeededZip64;
-            }
-        }
-
-
-        /// <summary>
-        ///   Whether the ZipOutputStream should use case-insensitive comparisons when
-        ///   checking for uniqueness of zip entries.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   <para>
-        ///   Though the zip specification doesn't prohibit zipfiles with duplicate
-        ///   entries, Sane zip files have no duplicates, and the DotNetZip library
-        ///   cannot create zip files with duplicate entries. If an application attempts
-        ///   to call <see cref="PutNextEntry(String)"/> with a name that duplicates one
-        ///   already used within the archive, the library will throw an Exception.
-        ///   </para>
-        ///   <para>
-        ///   This property allows the application to specify whether the
-        ///   ZipOutputStream instance considers ordinal case when checking for
-        ///   uniqueness of zip entries.
-        ///   </para>
-        /// </remarks>
-        public bool IgnoreCase
-        {
-          get
-          {
-              return !_DontIgnoreCase;
-          }
-
-          set
-          {
-              _DontIgnoreCase = !value;
-          }
-
-        }
-
-
-        /// <summary>
-        ///   Indicates whether to encode entry filenames and entry comments using
-        ///   Unicode (UTF-8).
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The
-        ///   PKWare zip specification</see> provides for encoding file names and file
-        ///   comments in either the IBM437 code page, or in UTF-8.  This flag selects
-        ///   the encoding according to that specification.  By default, this flag is
-        ///   false, and filenames and comments are encoded into the zip file in the
-        ///   IBM437 codepage.  Setting this flag to true will specify that filenames
-        ///   and comments that cannot be encoded with IBM437 will be encoded with
-        ///   UTF-8.
-        /// </para>
-        ///
-        /// <para>
-        ///   Zip files created with strict adherence to the PKWare specification with
-        ///   respect to UTF-8 encoding can contain entries with filenames containing
-        ///   any combination of Unicode characters, including the full range of
-        ///   characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many other
-        ///   alphabets.  However, because at this time, the UTF-8 portion of the PKWare
-        ///   specification is not broadly supported by other zip libraries and
-        ///   utilities, such zip files may not be readable by your favorite zip tool or
-        ///   archiver. In other words, interoperability will decrease if you set this
-        ///   flag to true.
-        /// </para>
-        ///
-        /// <para>
-        ///   In particular, Zip files created with strict adherence to the PKWare
-        ///   specification with respect to UTF-8 encoding will not work well with
-        ///   Explorer in Windows XP or Windows Vista, because Windows compressed
-        ///   folders, as far as I know, do not support UTF-8 in zip files.  Vista can
-        ///   read the zip files, but shows the filenames incorrectly. Unpacking from
-        ///   Windows Vista Explorer will result in filenames that have rubbish
-        ///   characters in place of the high-order UTF-8 bytes.
-        /// </para>
-        ///
-        /// <para>
-        ///   Also, zip files that use UTF-8 encoding will not work well with Java
-        ///   applications that use the java.util.zip classes, as of v5.0 of the Java
-        ///   runtime. The Java runtime does not correctly implement the PKWare
-        ///   specification in this regard.
-        /// </para>
-        ///
-        /// <para>
-        ///   As a result, we have the unfortunate situation that "correct" behavior by
-        ///   the DotNetZip library with regard to Unicode encoding of filenames during
-        ///   zip creation will result in zip files that are readable by strictly
-        ///   compliant and current tools (for example the most recent release of the
-        ///   commercial WinZip tool); but these zip files will not be readable by
-        ///   various other tools or libraries, including Windows Explorer.
-        /// </para>
-        ///
-        /// <para>
-        ///   The DotNetZip library can read and write zip files with UTF8-encoded
-        ///   entries, according to the PKware spec.  If you use DotNetZip for both
-        ///   creating and reading the zip file, and you use UTF-8, there will be no
-        ///   loss of information in the filenames. For example, using a self-extractor
-        ///   created by this library will allow you to unpack files correctly with no
-        ///   loss of information in the filenames.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you do not set this flag, it will remain false.  If this flag is false,
-        ///   the <c>ZipOutputStream</c> will encode all filenames and comments using
-        ///   the IBM437 codepage.  This can cause "loss of information" on some
-        ///   filenames, but the resulting zipfile will be more interoperable with other
-        ///   utilities. As an example of the loss of information, diacritics can be
-        ///   lost.  The o-tilde character will be down-coded to plain o.  The c with a
-        ///   cedilla (Unicode 0xE7) used in Portugese will be downcoded to a c.
-        ///   Likewise, the O-stroke character (Unicode 248), used in Danish and
-        ///   Norwegian, will be down-coded to plain o. Chinese characters cannot be
-        ///   represented in codepage IBM437; when using the default encoding, Chinese
-        ///   characters in filenames will be represented as ?. These are all examples
-        ///   of "information loss".
-        /// </para>
-        ///
-        /// <para>
-        ///   The loss of information associated to the use of the IBM437 encoding is
-        ///   inconvenient, and can also lead to runtime errors. For example, using
-        ///   IBM437, any sequence of 4 Chinese characters will be encoded as ????.  If
-        ///   your application creates a <c>ZipOutputStream</c>, does not set the
-        ///   encoding, then adds two files, each with names of four Chinese characters
-        ///   each, this will result in a duplicate filename exception.  In the case
-        ///   where you add a single file with a name containing four Chinese
-        ///   characters, the zipfile will save properly, but extracting that file
-        ///   later, with any zip tool, will result in an error, because the question
-        ///   mark is not legal for use within filenames on Windows.  These are just a
-        ///   few examples of the problems associated to loss of information.
-        /// </para>
-        ///
-        /// <para>
-        ///   This flag is independent of the encoding of the content within the entries
-        ///   in the zip file. Think of the zip file as a container - it supports an
-        ///   encoding.  Within the container are other "containers" - the file entries
-        ///   themselves.  The encoding within those entries is independent of the
-        ///   encoding of the zip archive container for those entries.
-        /// </para>
-        ///
-        /// <para>
-        ///   Rather than specify the encoding in a binary fashion using this flag, an
-        ///   application can specify an arbitrary encoding via the <see
-        ///   cref="ProvisionalAlternateEncoding"/> property.  Setting the encoding
-        ///   explicitly when creating zip archives will result in non-compliant zip
-        ///   files that, curiously, are fairly interoperable.  The challenge is, the
-        ///   PKWare specification does not provide for a way to specify that an entry
-        ///   in a zip archive uses a code page that is neither IBM437 nor UTF-8.
-        ///   Therefore if you set the encoding explicitly when creating a zip archive,
-        ///   you must take care upon reading the zip archive to use the same code page.
-        ///   If you get it wrong, the behavior is undefined and may result in incorrect
-        ///   filenames, exceptions, stomach upset, hair loss, and acne.
-        /// </para>
-        /// </remarks>
-        /// <seealso cref="ProvisionalAlternateEncoding"/>
-        [Obsolete("Beginning with v1.9.1.6 of DotNetZip, this property is obsolete. It will be removed in a future version of the library. Use AlternateEncoding and AlternateEncodingUsage instead.")]
-        public bool UseUnicodeAsNecessary
-        {
-            get
-            {
-                return (_alternateEncoding == System.Text.Encoding.UTF8) &&
-                    (AlternateEncodingUsage == ZipOption.AsNecessary);
-            }
-            set
-            {
-                if (value)
-                {
-                    _alternateEncoding = System.Text.Encoding.UTF8;
-                    _alternateEncodingUsage = ZipOption.AsNecessary;
-
-                }
-                else
-                {
-                    _alternateEncoding = Ionic.Zip.ZipOutputStream.DefaultEncoding;
-                    _alternateEncodingUsage = ZipOption.Never;
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///   The text encoding to use when emitting entries into the zip archive, for
-        ///   those entries whose filenames or comments cannot be encoded with the
-        ///   default (IBM437) encoding.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its
-        ///   zip specification</see>, PKWare describes two options for encoding
-        ///   filenames and comments: using IBM437 or UTF-8.  But, some archiving tools
-        ///   or libraries do not follow the specification, and instead encode
-        ///   characters using the system default code page.  For example, WinRAR when
-        ///   run on a machine in Shanghai may encode filenames with the Big-5 Chinese
-        ///   (950) code page.  This behavior is contrary to the Zip specification, but
-        ///   it occurs anyway.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using DotNetZip to write zip archives that will be read by one of
-        ///   these other archivers, set this property to specify the code page to use
-        ///   when encoding the <see cref="ZipEntry.FileName"/> and <see
-        ///   cref="ZipEntry.Comment"/> for each <c>ZipEntry</c> in the zip file, for
-        ///   values that cannot be encoded with the default codepage for zip files,
-        ///   IBM437.  This is why this property is "provisional".  In all cases, IBM437
-        ///   is used where possible, in other words, where no loss of data would
-        ///   result. It is possible, therefore, to have a given entry with a
-        ///   <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with the
-        ///   specified "provisional" codepage.
-        /// </para>
-        ///
-        /// <para>
-        ///   Be aware that a zip file created after you've explicitly set the
-        ///   <c>ProvisionalAlternateEncoding</c> property to a value other than
-        ///   IBM437 may not be compliant to the PKWare specification, and may not be
-        ///   readable by compliant archivers.  On the other hand, many (most?)
-        ///   archivers are non-compliant and can read zip files created in arbitrary
-        ///   code pages.  The trick is to use or specify the proper codepage when
-        ///   reading the zip.
-        /// </para>
-        ///
-        /// <para>
-        ///   When creating a zip archive using this library, it is possible to change
-        ///   the value of <c>ProvisionalAlternateEncoding</c> between each entry you
-        ///   add, and between adding entries and the call to <c>Close()</c>. Don't do
-        ///   this. It will likely result in a zipfile that is not readable.  For best
-        ///   interoperability, either leave <c>ProvisionalAlternateEncoding</c>
-        ///   alone, or specify it only once, before adding any entries to the
-        ///   <c>ZipOutputStream</c> instance.  There is one exception to this
-        ///   recommendation, described later.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using an arbitrary, non-UTF8 code page for encoding, there is no
-        ///   standard way for the creator application - whether DotNetZip, WinZip,
-        ///   WinRar, or something else - to formally specify in the zip file which
-        ///   codepage has been used for the entries. As a result, readers of zip files
-        ///   are not able to inspect the zip file and determine the codepage that was
-        ///   used for the entries contained within it.  It is left to the application
-        ///   or user to determine the necessary codepage when reading zip files encoded
-        ///   this way.  If you use an incorrect codepage when reading a zipfile, you
-        ///   will get entries with filenames that are incorrect, and the incorrect
-        ///   filenames may even contain characters that are not legal for use within
-        ///   filenames in Windows. Extracting entries with illegal characters in the
-        ///   filenames will lead to exceptions. It's too bad, but this is just the way
-        ///   things are with code pages in zip files. Caveat Emptor.
-        /// </para>
-        ///
-        /// <para>
-        ///   One possible approach for specifying the code page for a given zip file is
-        ///   to describe the code page in a human-readable form in the Zip comment. For
-        ///   example, the comment may read "Entries in this archive are encoded in the
-        ///   Big5 code page".  For maximum interoperability, the zip comment in this
-        ///   case should be encoded in the default, IBM437 code page.  In this case,
-        ///   the zip comment is encoded using a different page than the filenames.  To
-        ///   do this, Specify <c>ProvisionalAlternateEncoding</c> to your desired
-        ///   region-specific code page, once before adding any entries, and then set
-        ///   the <see cref="Comment"/> property and reset
-        ///   <c>ProvisionalAlternateEncoding</c> to IBM437 before calling <c>Close()</c>.
-        /// </para>
-        /// </remarks>
-        [Obsolete("use AlternateEncoding and AlternateEncodingUsage instead.")]
-        public System.Text.Encoding ProvisionalAlternateEncoding
-        {
-            get
-            {
-                if (_alternateEncodingUsage == ZipOption.AsNecessary)
-                    return _alternateEncoding;
-                return null;
-            }
-            set
-            {
-                _alternateEncoding = value;
-                _alternateEncodingUsage = ZipOption.AsNecessary;
-            }
-        }
-
-        /// <summary>
-        ///   A Text Encoding to use when encoding the filenames and comments for
-        ///   all the ZipEntry items, during a ZipFile.Save() operation.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Whether the encoding specified here is used during the save depends
-        ///     on <see cref="AlternateEncodingUsage"/>.
-        ///   </para>
-        /// </remarks>
-        public System.Text.Encoding AlternateEncoding
-        {
-            get
-            {
-                return _alternateEncoding;
-            }
-            set
-            {
-                _alternateEncoding = value;
-            }
-        }
-
-        /// <summary>
-        ///   A flag that tells if and when this instance should apply
-        ///   AlternateEncoding to encode the filenames and comments associated to
-        ///   of ZipEntry objects contained within this instance.
-        /// </summary>
-        public ZipOption AlternateEncodingUsage
-        {
-            get
-            {
-                return _alternateEncodingUsage;
-            }
-            set
-            {
-                _alternateEncodingUsage = value;
-            }
-        }
-
-        /// <summary>
-        /// The default text encoding used in zip archives.  It is numeric 437, also
-        /// known as IBM437.
-        /// </summary>
-        /// <seealso cref="Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>
-        public static System.Text.Encoding DefaultEncoding
-        {
-            get
-            {
-                return System.Text.Encoding.ASCII;
-            }
-        }
-
-
-#if !NETCF
-        /// <summary>
-        ///   The size threshold for an entry, above which a parallel deflate is used.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        ///   <para>
-        ///     DotNetZip will use multiple threads to compress any ZipEntry, when
-        ///     the <c>CompressionMethod</c> is Deflate, and if the entry is
-        ///     larger than the given size.  Zero means "always use parallel
-        ///     deflate", while -1 means "never use parallel deflate".
-        ///   </para>
-        ///
-        ///   <para>
-        ///     If the entry size cannot be known before compression, as with any entry
-        ///     added via a ZipOutputStream, then Parallel deflate will never be
-        ///     performed, unless the value of this property is zero.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     A parallel deflate operations will speed up the compression of
-        ///     large files, on computers with multiple CPUs or multiple CPU
-        ///     cores.  For files above 1mb, on a dual core or dual-cpu (2p)
-        ///     machine, the time required to compress the file can be 70% of the
-        ///     single-threaded deflate.  For very large files on 4p machines the
-        ///     compression can be done in 30% of the normal time.  The downside
-        ///     is that parallel deflate consumes extra memory during the deflate,
-        ///     and the deflation is slightly less effective.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     Parallel deflate tends to not be as effective as single-threaded deflate
-        ///     because the original data stream is split into multiple independent
-        ///     buffers, each of which is compressed in parallel.  But because they are
-        ///     treated independently, there is no opportunity to share compression
-        ///     dictionaries, and additional framing bytes must be added to the output
-        ///     stream.  For that reason, a deflated stream may be slightly larger when
-        ///     compressed using parallel deflate, as compared to a traditional
-        ///     single-threaded deflate. For files of about 512k, the increase over the
-        ///     normal deflate is as much as 5% of the total compressed size. For larger
-        ///     files, the difference can be as small as 0.1%.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     Multi-threaded compression does not give as much an advantage when using
-        ///     Encryption. This is primarily because encryption tends to slow down
-        ///     the entire pipeline. Also, multi-threaded compression gives less of an
-        ///     advantage when using lower compression levels, for example <see
-        ///     cref="Ionic.Zlib.CompressionLevel.BestSpeed"/>.  You may have to perform
-        ///     some tests to determine the best approach for your situation.
-        ///   </para>
-        ///
-        ///   <para>
-        ///     The default value for this property is -1, which means parallel
-        ///     compression will not be performed unless you set it to zero.
-        ///   </para>
-        ///
-        /// </remarks>
-        public long ParallelDeflateThreshold
-        {
-            set
-            {
-                if ((value != 0) && (value != -1) && (value < 64 * 1024))
-                    throw new ArgumentOutOfRangeException("value must be greater than 64k, or 0, or -1");
-                _ParallelDeflateThreshold = value;
-            }
-            get
-            {
-                return _ParallelDeflateThreshold;
-            }
-        }
-
-
-        /// <summary>
-        ///   The maximum number of buffer pairs to use when performing
-        ///   parallel compression.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property sets an upper limit on the number of memory
-        ///   buffer pairs to create when performing parallel
-        ///   compression.  The implementation of the parallel
-        ///   compression stream allocates multiple buffers to
-        ///   facilitate parallel compression.  As each buffer fills up,
-        ///   the stream uses <see
-        ///   cref="System.Threading.ThreadPool.QueueUserWorkItem(WaitCallback)">
-        ///   ThreadPool.QueueUserWorkItem()</see> to compress those
-        ///   buffers in a background threadpool thread. After a buffer
-        ///   is compressed, it is re-ordered and written to the output
-        ///   stream.
-        /// </para>
-        ///
-        /// <para>
-        ///   A higher number of buffer pairs enables a higher degree of
-        ///   parallelism, which tends to increase the speed of compression on
-        ///   multi-cpu computers.  On the other hand, a higher number of buffer
-        ///   pairs also implies a larger memory consumption, more active worker
-        ///   threads, and a higher cpu utilization for any compression. This
-        ///   property enables the application to limit its memory consumption and
-        ///   CPU utilization behavior depending on requirements.
-        /// </para>
-        ///
-        /// <para>
-        ///   For each compression "task" that occurs in parallel, there are 2
-        ///   buffers allocated: one for input and one for output.  This property
-        ///   sets a limit for the number of pairs.  The total amount of storage
-        ///   space allocated for buffering will then be (N*S*2), where N is the
-        ///   number of buffer pairs, S is the size of each buffer (<see
-        ///   cref="CodecBufferSize"/>).  By default, DotNetZip allocates 4 buffer
-        ///   pairs per CPU core, so if your machine has 4 cores, and you retain
-        ///   the default buffer size of 128k, then the
-        ///   ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer
-        ///   memory in total, or 4mb, in blocks of 128kb.  If you then set this
-        ///   property to 8, then the number will be 8 * 2 * 128kb of buffer
-        ///   memory, or 2mb.
-        /// </para>
-        ///
-        /// <para>
-        ///   CPU utilization will also go up with additional buffers, because a
-        ///   larger number of buffer pairs allows a larger number of background
-        ///   threads to compress in parallel. If you find that parallel
-        ///   compression is consuming too much memory or CPU, you can adjust this
-        ///   value downward.
-        /// </para>
-        ///
-        /// <para>
-        ///   The default value is 16. Different values may deliver better or
-        ///   worse results, depending on your priorities and the dynamic
-        ///   performance characteristics of your storage and compute resources.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not the number of buffer pairs to use; it is an
-        ///   upper limit. An illustration: Suppose you have an application that
-        ///   uses the default value of this property (which is 16), and it runs
-        ///   on a machine with 2 CPU cores. In that case, DotNetZip will allocate
-        ///   4 buffer pairs per CPU core, for a total of 8 pairs.  The upper
-        ///   limit specified by this property has no effect.
-        /// </para>
-        ///
-        /// <para>
-        ///   The application can set this value at any time, but it is
-        ///   effective only if set before calling
-        ///   <c>ZipOutputStream.Write()</c> for the first time.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <seealso cref="ParallelDeflateThreshold"/>
-        ///
-        public int ParallelDeflateMaxBufferPairs
-        {
-            get
-            {
-                return _maxBufferPairs;
-            }
-            set
-            {
-                if (value < 4)
-                    throw new ArgumentOutOfRangeException("ParallelDeflateMaxBufferPairs",
-                                                "Value must be 4 or greater.");
-                _maxBufferPairs = value;
-            }
-        }
-#endif
-
-
-        private void InsureUniqueEntry(ZipEntry ze1)
-        {
-            if (_entriesWritten.ContainsKey(ze1.FileName))
-            {
-                _exceptionPending = true;
-                throw new ArgumentException(String.Format("The entry '{0}' already exists in the zip archive.", ze1.FileName));
-            }
-        }
-
-
-        internal Stream OutputStream
-        {
-            get
-            {
-                return _outputStream;
-            }
-        }
-
-        internal String Name
-        {
-            get
-            {
-                return _name;
-            }
-        }
-
-        /// <summary>
-        ///   Returns true if an entry by the given name has already been written
-        ///   to the ZipOutputStream.
-        /// </summary>
-        ///
-        /// <param name="name">
-        ///   The name of the entry to scan for.
-        /// </param>
-        ///
-        /// <returns>
-        /// true if an entry by the given name has already been written.
-        /// </returns>
-        public bool ContainsEntry(string name)
-        {
-            return _entriesWritten.ContainsKey(SharedUtilities.NormalizePathForUseInZipFile(name));
-        }
-
-
-        /// <summary>
-        ///   Write the data from the buffer to the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   As the application writes data into this stream, the data may be
-        ///   compressed and encrypted before being written out to the underlying
-        ///   stream, depending on the settings of the <see cref="CompressionLevel"/>
-        ///   and the <see cref="Encryption"/> properties.
-        /// </remarks>
-        ///
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (_disposed)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("The stream has been closed.");
-            }
-
-            if (buffer==null)
-            {
-                _exceptionPending = true;
-                throw new System.ArgumentNullException("buffer");
-            }
-
-            if (_currentEntry == null)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("You must call PutNextEntry() before calling Write().");
-            }
-
-            if (_currentEntry.IsDirectory)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("You cannot Write() data for an entry that is a directory.");
-            }
-
-            if (_needToWriteEntryHeader)
-                _InitiateCurrentEntry(false);
-
-            if (count != 0)
-                _entryOutputStream.Write(buffer, offset, count);
-        }
-
-
-
-        /// <summary>
-        ///   Specify the name of the next entry that will be written to the zip file.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   Call this method just before calling <see cref="Write(byte[], int, int)"/>, to
-        ///   specify the name of the entry that the next set of bytes written to
-        ///   the <c>ZipOutputStream</c> belongs to. All subsequent calls to <c>Write</c>,
-        ///   until the next call to <c>PutNextEntry</c>,
-        ///   will be inserted into the named entry in the zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   If the <paramref name="entryName"/> used in <c>PutNextEntry()</c> ends in
-        ///   a slash, then the entry added is marked as a directory. Because directory
-        ///   entries do not contain data, a call to <c>Write()</c>, before an
-        ///   intervening additional call to <c>PutNextEntry()</c>, will throw an
-        ///   exception.
-        /// </para>
-        ///
-        /// <para>
-        ///   If you don't call <c>Write()</c> between two calls to
-        ///   <c>PutNextEntry()</c>, the first entry is inserted into the zip file as a
-        ///   file of zero size.  This may be what you want.
-        /// </para>
-        ///
-        /// <para>
-        ///   Because <c>PutNextEntry()</c> closes out the prior entry, if any, this
-        ///   method may throw if there is a problem with the prior entry.
-        /// </para>
-        ///
-        /// <para>
-        ///   This method returns the <c>ZipEntry</c>.  You can modify public properties
-        ///   on the <c>ZipEntry</c>, such as <see cref="ZipEntry.Encryption"/>, <see
-        ///   cref="ZipEntry.Password"/>, and so on, until the first call to
-        ///   <c>ZipOutputStream.Write()</c>, or until the next call to
-        ///   <c>PutNextEntry()</c>.  If you modify the <c>ZipEntry</c> <em>after</em>
-        ///   having called <c>Write()</c>, you may get a runtime exception, or you may
-        ///   silently get an invalid zip archive.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to create a zip file, using the
-        ///   <c>ZipOutputStream</c> class.
-        ///
-        /// <code>
-        /// private void Zipup()
-        /// {
-        ///     using (FileStream fs raw = File.Open(_outputFileName, FileMode.Create, FileAccess.ReadWrite ))
-        ///     {
-        ///         using (var output= new ZipOutputStream(fs))
-        ///         {
-        ///             output.Password = "VerySecret!";
-        ///             output.Encryption = EncryptionAlgorithm.WinZipAes256;
-        ///             output.PutNextEntry("entry1.txt");
-        ///             byte[] buffer= System.Text.Encoding.ASCII.GetBytes("This is the content for entry #1.");
-        ///             output.Write(buffer,0,buffer.Length);
-        ///             output.PutNextEntry("entry2.txt");  // this will be zero length
-        ///             output.PutNextEntry("entry3.txt");
-        ///             buffer= System.Text.Encoding.ASCII.GetBytes("This is the content for entry #3.");
-        ///             output.Write(buffer,0,buffer.Length);
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="entryName">
-        ///   The name of the entry to be added, including any path to be used
-        ///   within the zip file.
-        /// </param>
-        ///
-        /// <returns>
-        ///   The ZipEntry created.
-        /// </returns>
-        ///
-        public ZipEntry PutNextEntry(String entryName)
-        {
-            if (String.IsNullOrEmpty(entryName))
-                throw new ArgumentNullException("entryName");
-
-            if (_disposed)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("The stream has been closed.");
-            }
-
-            _FinishCurrentEntry();
-            _currentEntry = ZipEntry.CreateForZipOutputStream(entryName);
-            _currentEntry._container = new ZipContainer(this);
-            _currentEntry._BitField |= 0x0008;  // workitem 8932
-            _currentEntry.SetEntryTimes(DateTime.Now, DateTime.Now, DateTime.Now);
-            _currentEntry.CompressionLevel = this.CompressionLevel;
-            _currentEntry.CompressionMethod = this.CompressionMethod;
-            _currentEntry.Password = _password; // workitem 13909
-            _currentEntry.Encryption = this.Encryption;
-            // workitem 12634
-            _currentEntry.AlternateEncoding = this.AlternateEncoding;
-            _currentEntry.AlternateEncodingUsage = this.AlternateEncodingUsage;
-
-            if (entryName.EndsWith("/"))  _currentEntry.MarkAsDirectory();
-
-            _currentEntry.EmitTimesInWindowsFormatWhenSaving = ((_timestamp & ZipEntryTimestamp.Windows) != 0);
-            _currentEntry.EmitTimesInUnixFormatWhenSaving = ((_timestamp & ZipEntryTimestamp.Unix) != 0);
-            InsureUniqueEntry(_currentEntry);
-            _needToWriteEntryHeader = true;
-
-            return _currentEntry;
-        }
-
-
-
-        private void _InitiateCurrentEntry(bool finishing)
-        {
-            // If finishing==true, this means we're initiating the entry at the time of
-            // Close() or PutNextEntry().  If this happens, it means no data was written
-            // for the entry - Write() was never called.  (The usual case us to call
-            // _InitiateCurrentEntry(bool) from within Write().)  If finishing==true,
-            // the entry could be either a zero-byte file or a directory.
-
-            _entriesWritten.Add(_currentEntry.FileName,_currentEntry);
-            _entryCount++; // could use _entriesWritten.Count, but I don't want to incur
-            // the cost.
-
-            if (_entryCount > 65534 && _zip64 == Zip64Option.Never)
-            {
-                _exceptionPending = true;
-                throw new System.InvalidOperationException("Too many entries. Consider setting ZipOutputStream.EnableZip64.");
-            }
-
-            // Write out the header.
-            //
-            // If finishing, and encryption is in use, then we don't want to emit the
-            // normal encryption header.  Signal that with a cycle=99 to turn off
-            // encryption for zero-byte entries or directories.
-            //
-            // If finishing, then we know the stream length is zero.  Else, unknown
-            // stream length.  Passing stream length == 0 allows an optimization so as
-            // not to setup an encryption or deflation stream, when stream length is
-            // zero.
-
-            _currentEntry.WriteHeader(_outputStream, finishing ? 99 : 0);
-            _currentEntry.StoreRelativeOffset();
-
-            if (!_currentEntry.IsDirectory)
-            {
-                _currentEntry.WriteSecurityMetadata(_outputStream);
-                _currentEntry.PrepOutputStream(_outputStream,
-                                               finishing ? 0 : -1,
-                                               out _outputCounter,
-                                               out _encryptor,
-                                               out _deflater,
-                                               out _entryOutputStream);
-            }
-            _needToWriteEntryHeader = false;
-        }
-
-
-
-        private void _FinishCurrentEntry()
-        {
-            if (_currentEntry != null)
-            {
-                if (_needToWriteEntryHeader)
-                    _InitiateCurrentEntry(true); // an empty entry - no writes
-
-                _currentEntry.FinishOutputStream(_outputStream, _outputCounter, _encryptor, _deflater, _entryOutputStream);
-                _currentEntry.PostProcessOutput(_outputStream);
-                // workitem 12964
-                if (_currentEntry.OutputUsedZip64!=null)
-                    _anyEntriesUsedZip64 |= _currentEntry.OutputUsedZip64.Value;
-
-                // reset all the streams
-                _outputCounter = null; _encryptor = _deflater = null; _entryOutputStream = null;
-            }
-        }
-
-
-
-        /// <summary>
-        /// Dispose the stream
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This method writes the Zip Central directory, then closes the stream.  The
-        ///   application must call Dispose() (or Close) in order to produce a valid zip file.
-        /// </para>
-        ///
-        /// <para>
-        ///   Typically the application will call <c>Dispose()</c> implicitly, via a <c>using</c>
-        ///   statement in C#, or a <c>Using</c> statement in VB.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="disposing">set this to true, always.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (_disposed) return;
-
-            if (disposing) // not called from finalizer
-            {
-                // handle pending exceptions
-                if (!_exceptionPending)
-                {
-                    _FinishCurrentEntry();
-                    _directoryNeededZip64 = ZipOutput.WriteCentralDirectoryStructure(_outputStream,
-                                                                                     _entriesWritten.Values,
-                                                                                     1, // _numberOfSegmentsForMostRecentSave,
-                                                                                     _zip64,
-                                                                                     Comment,
-                                                                                     new ZipContainer(this));
-                    Stream wrappedStream = null;
-                    CountingStream cs = _outputStream as CountingStream;
-                    if (cs != null)
-                    {
-                        wrappedStream = cs.WrappedStream;
-#if NETCF
-                    cs.Close();
-#else
-                        cs.Dispose();
-#endif
-                    }
-                    else
-                    {
-                        wrappedStream = _outputStream;
-                    }
-
-                    if (!_leaveUnderlyingStreamOpen)
-                    {
-#if NETCF
-                    wrappedStream.Close();
-#else
-                        wrappedStream.Dispose();
-#endif
-                    }
-                    _outputStream = null;
-                }
-            }
-            _disposed = true;
-        }
-
-
-
-        /// <summary>
-        /// Always returns false.
-        /// </summary>
-        public override bool CanRead { get { return false; } }
-
-        /// <summary>
-        /// Always returns false.
-        /// </summary>
-        public override bool CanSeek { get { return false; } }
-
-        /// <summary>
-        /// Always returns true.
-        /// </summary>
-        public override bool CanWrite { get { return true; } }
-
-        /// <summary>
-        /// Always returns a NotSupportedException.
-        /// </summary>
-        public override long Length { get { throw new NotSupportedException(); } }
-
-        /// <summary>
-        /// Setting this property always returns a NotSupportedException. Getting it
-        /// returns the value of the Position on the underlying stream.
-        /// </summary>
-        public override long Position
-        {
-            get { return _outputStream.Position; }
-            set { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        /// This is a no-op.
-        /// </summary>
-        public override void Flush() { }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="buffer">ignored</param>
-        /// <param name="offset">ignored</param>
-        /// <param name="count">ignored</param>
-        /// <returns>nothing</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException("Read");
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="offset">ignored</param>
-        /// <param name="origin">ignored</param>
-        /// <returns>nothing</returns>
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotSupportedException("Seek");
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="value">ignored</param>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-
-        private EncryptionAlgorithm _encryption;
-        private ZipEntryTimestamp _timestamp;
-        internal String _password;
-        private String _comment;
-        private Stream _outputStream;
-        private ZipEntry _currentEntry;
-        internal Zip64Option _zip64;
-        private Dictionary<String, ZipEntry> _entriesWritten;
-        private int _entryCount;
-        private ZipOption _alternateEncodingUsage = ZipOption.Never;
-        private System.Text.Encoding _alternateEncoding
-            = System.Text.Encoding.ASCII; // default = IBM437
-
-        private bool _leaveUnderlyingStreamOpen;
-        private bool _disposed;
-        private bool _exceptionPending; // **see note below
-        private bool _anyEntriesUsedZip64, _directoryNeededZip64;
-        private CountingStream _outputCounter;
-        private Stream _encryptor;
-        private Stream _deflater;
-        private Ionic.Crc.CrcCalculatorStream _entryOutputStream;
-        private bool _needToWriteEntryHeader;
-        private string _name;
-        private bool _DontIgnoreCase;
-#if !NETCF
-        internal ParallelDeflateOutputStream ParallelDeflater;
-        private long _ParallelDeflateThreshold;
-        private int _maxBufferPairs = 16;
-#endif
-
-        // **Note regarding exceptions:
-
-        // When ZipOutputStream is employed within a using clause, which
-        // is the typical scenario, and an exception is thrown within
-        // the scope of the using, Close()/Dispose() is invoked
-        // implicitly before processing the initial exception.  In that
-        // case, _exceptionPending is true, and we don't want to try to
-        // write anything in the Close/Dispose logic.  Doing so can
-        // cause additional exceptions that mask the original one. So,
-        // the _exceptionPending flag is used to track that, and to
-        // allow the original exception to be propagated to the
-        // application without extra "noise."
-
-    }
-
-
-
-    internal class ZipContainer
-    {
-        private ZipFile _zf;
-        private ZipOutputStream _zos;
-        private ZipInputStream _zis;
-
-        public ZipContainer(Object o)
-        {
-            _zf = (o as ZipFile);
-            _zos = (o as ZipOutputStream);
-            _zis = (o as ZipInputStream);
-        }
-
-        public ZipFile ZipFile
-        {
-            get { return _zf; }
-        }
-
-        public ZipOutputStream ZipOutputStream
-        {
-            get { return _zos; }
-        }
-
-        public string Name
-        {
-            get
-            {
-                if (_zf != null) return _zf.Name;
-                if (_zis != null) throw new NotSupportedException();
-                return _zos.Name;
-            }
-        }
-
-        public string Password
-        {
-            get
-            {
-                if (_zf != null) return _zf._Password;
-                if (_zis != null) return _zis._Password;
-                return _zos._password;
-            }
-        }
-
-        public Zip64Option Zip64
-        {
-            get
-            {
-                if (_zf != null) return _zf._zip64;
-                if (_zis != null) throw new NotSupportedException();
-                return _zos._zip64;
-            }
-        }
-
-        public int BufferSize
-        {
-            get
-            {
-                if (_zf != null) return _zf.BufferSize;
-                if (_zis != null) throw new NotSupportedException();
-                return 0;
-            }
-        }
-
-#if !NETCF
-        public Ionic.Zlib.ParallelDeflateOutputStream ParallelDeflater
-        {
-            get
-            {
-                if (_zf != null) return _zf.ParallelDeflater;
-                if (_zis != null) return null;
-                return _zos.ParallelDeflater;
-            }
-            set
-            {
-                if (_zf != null) _zf.ParallelDeflater = value;
-                else if (_zos != null) _zos.ParallelDeflater = value;
-            }
-        }
-
-        public long ParallelDeflateThreshold
-        {
-            get
-            {
-                if (_zf != null) return _zf.ParallelDeflateThreshold;
-                return _zos.ParallelDeflateThreshold;
-            }
-        }
-        public int ParallelDeflateMaxBufferPairs
-        {
-            get
-            {
-                if (_zf != null) return _zf.ParallelDeflateMaxBufferPairs;
-                return _zos.ParallelDeflateMaxBufferPairs;
-            }
-        }
-#endif
-
-        public int CodecBufferSize
-        {
-            get
-            {
-                if (_zf != null) return _zf.CodecBufferSize;
-                if (_zis != null) return _zis.CodecBufferSize;
-                return _zos.CodecBufferSize;
-            }
-        }
-
-        public Ionic.Zlib.CompressionStrategy Strategy
-        {
-            get
-            {
-                if (_zf != null) return _zf.Strategy;
-                return _zos.Strategy;
-            }
-        }
-
-        public Zip64Option UseZip64WhenSaving
-        {
-            get
-            {
-                if (_zf != null) return _zf.UseZip64WhenSaving;
-                return _zos.EnableZip64;
-            }
-        }
-
-        public System.Text.Encoding AlternateEncoding
-        {
-            get
-            {
-                if (_zf != null) return _zf.AlternateEncoding;
-                if (_zos!=null) return _zos.AlternateEncoding;
-                return null;
-            }
-        }
-        public System.Text.Encoding DefaultEncoding
-        {
-            get
-            {
-                if (_zf != null) return ZipFile.DefaultEncoding;
-                if (_zos!=null) return ZipOutputStream.DefaultEncoding;
-                return null;
-            }
-        }
-        public ZipOption AlternateEncodingUsage
-        {
-            get
-            {
-                if (_zf != null) return _zf.AlternateEncodingUsage;
-                if (_zos!=null) return _zos.AlternateEncodingUsage;
-                return ZipOption.Never; // n/a
-            }
-        }
-
-        public Stream ReadStream
-        {
-            get
-            {
-                if (_zf != null) return _zf.ReadStream;
-                return _zis.ReadStream;
-            }
-        }
-    }
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/ZipSegmentedStream.cs b/EPPlus/Packaging/DotNetZip/ZipSegmentedStream.cs
deleted file mode 100644
index 4afc634..0000000
--- a/EPPlus/Packaging/DotNetZip/ZipSegmentedStream.cs
+++ /dev/null
@@ -1,571 +0,0 @@
-// ZipSegmentedStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-13 22:25:45>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for zip streams that span disk files.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zip
-{
-    internal class ZipSegmentedStream : System.IO.Stream
-    {
-        enum RwMode
-        {
-            None = 0,
-            ReadOnly = 1,
-            Write = 2,
-            //Update = 3
-        }
-
-        private RwMode rwMode;
-        private bool _exceptionPending; // **see note below
-        private string _baseName;
-        private string _baseDir;
-        //private bool _isDisposed;
-        private string _currentName;
-        private string _currentTempName;
-        private uint _currentDiskNumber;
-        private uint _maxDiskNumber;
-        private int _maxSegmentSize;
-        private System.IO.Stream _innerStream;
-
-        // **Note regarding exceptions:
-        //
-        // When ZipSegmentedStream is employed within a using clause,
-        // which is the typical scenario, and an exception is thrown
-        // within the scope of the using, Dispose() is invoked
-        // implicitly before processing the initial exception.  If that
-        // happens, this class sets _exceptionPending to true, and then
-        // within the Dispose(bool), takes special action as
-        // appropriate. Need to be careful: any additional exceptions
-        // will mask the original one.
-
-        private ZipSegmentedStream() : base()
-        {
-            _exceptionPending = false;
-        }
-
-        public static ZipSegmentedStream ForReading(string name,
-                                                    uint initialDiskNumber,
-                                                    uint maxDiskNumber)
-        {
-            ZipSegmentedStream zss = new ZipSegmentedStream()
-                {
-                    rwMode = RwMode.ReadOnly,
-                    CurrentSegment = initialDiskNumber,
-                    _maxDiskNumber = maxDiskNumber,
-                    _baseName = name,
-                };
-
-            // Console.WriteLine("ZSS: ForReading ({0})",
-            //                    Path.GetFileName(zss.CurrentName));
-
-            zss._SetReadStream();
-
-            return zss;
-        }
-
-
-        public static ZipSegmentedStream ForWriting(string name, int maxSegmentSize)
-        {
-            ZipSegmentedStream zss = new ZipSegmentedStream()
-                {
-                    rwMode = RwMode.Write,
-                    CurrentSegment = 0,
-                    _baseName = name,
-                    _maxSegmentSize = maxSegmentSize,
-                    _baseDir = Path.GetDirectoryName(name)
-                };
-
-            // workitem 9522
-            if (zss._baseDir=="") zss._baseDir=".";
-
-            zss._SetWriteStream(0);
-
-            // Console.WriteLine("ZSS: ForWriting ({0})",
-            //                    Path.GetFileName(zss.CurrentName));
-
-            return zss;
-        }
-
-
-        /// <summary>
-        ///   Sort-of like a factory method, ForUpdate is used only when
-        ///   the application needs to update the zip entry metadata for
-        ///   a segmented zip file, when the starting segment is earlier
-        ///   than the ending segment, for a particular entry.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The update is always contiguous, never rolls over.  As a
-        ///     result, this method doesn't need to return a ZSS; it can
-        ///     simply return a FileStream.  That's why it's "sort of"
-        ///     like a Factory method.
-        ///   </para>
-        ///   <para>
-        ///     Caller must Close/Dispose the stream object returned by
-        ///     this method.
-        ///   </para>
-        /// </remarks>
-        public static Stream ForUpdate(string name, uint diskNumber)
-        {
-            if (diskNumber >= 99)
-                throw new ArgumentOutOfRangeException("diskNumber");
-
-            string fname =
-                String.Format("{0}.z{1:D2}",
-                                 Path.Combine(Path.GetDirectoryName(name),
-                                              Path.GetFileNameWithoutExtension(name)),
-                                 diskNumber + 1);
-
-            // Console.WriteLine("ZSS: ForUpdate ({0})",
-            //                   Path.GetFileName(fname));
-
-            // This class assumes that the update will not expand the
-            // size of the segment. Update is used only for an in-place
-            // update of zip metadata. It never will try to write beyond
-            // the end of a segment.
-
-            return File.Open(fname,
-                             FileMode.Open,
-                             FileAccess.ReadWrite,
-                             FileShare.None);
-        }
-
-        public bool ContiguousWrite
-        {
-            get;
-            set;
-        }
-
-
-        public UInt32 CurrentSegment
-        {
-            get
-            {
-                return _currentDiskNumber;
-            }
-            private set
-            {
-                _currentDiskNumber = value;
-                _currentName = null; // it will get updated next time referenced
-            }
-        }
-
-        /// <summary>
-        ///   Name of the filesystem file corresponding to the current segment.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     The name is not always the name currently being used in the
-        ///     filesystem.  When rwMode is RwMode.Write, the filesystem file has a
-        ///     temporary name until the stream is closed or until the next segment is
-        ///     started.
-        ///   </para>
-        /// </remarks>
-        public String CurrentName
-        {
-            get
-            {
-                if (_currentName==null)
-                    _currentName = _NameForSegment(CurrentSegment);
-
-                return _currentName;
-            }
-        }
-
-
-        public String CurrentTempName
-        {
-            get
-            {
-                return _currentTempName;
-            }
-        }
-
-        private string _NameForSegment(uint diskNumber)
-        {
-            if (diskNumber >= 99)
-            {
-                _exceptionPending = true;
-                throw new OverflowException("The number of zip segments would exceed 99.");
-            }
-
-            return String.Format("{0}.z{1:D2}",
-                                 Path.Combine(Path.GetDirectoryName(_baseName),
-                                              Path.GetFileNameWithoutExtension(_baseName)),
-                                 diskNumber + 1);
-        }
-
-
-        // Returns the segment that WILL be current if writing
-        // a block of the given length.
-        // This isn't exactly true. It could roll over beyond
-        // this number.
-        public UInt32 ComputeSegment(int length)
-        {
-            if (_innerStream.Position + length > _maxSegmentSize)
-                // the block will go AT LEAST into the next segment
-                return CurrentSegment + 1;
-
-            // it will fit in the current segment
-            return CurrentSegment;
-        }
-
-
-        public override String ToString()
-        {
-            return String.Format("{0}[{1}][{2}], pos=0x{3:X})",
-                                 "ZipSegmentedStream", CurrentName,
-                                 rwMode.ToString(),
-                                 this.Position);
-        }
-
-
-        private void _SetReadStream()
-        {
-            if (_innerStream != null)
-            {
-#if NETCF
-                _innerStream.Close();
-#else
-                _innerStream.Dispose();
-#endif
-            }
-
-            if (CurrentSegment + 1 == _maxDiskNumber)
-                _currentName = _baseName;
-
-            // Console.WriteLine("ZSS: SRS ({0})",
-            //                   Path.GetFileName(CurrentName));
-
-            _innerStream = File.OpenRead(CurrentName);
-        }
-
-
-        /// <summary>
-        /// Read from the stream
-        /// </summary>
-        /// <param name="buffer">the buffer to read</param>
-        /// <param name="offset">the offset at which to start</param>
-        /// <param name="count">the number of bytes to read</param>
-        /// <returns>the number of bytes actually read</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (rwMode != RwMode.ReadOnly)
-            {
-                _exceptionPending = true;
-                throw new InvalidOperationException("Stream Error: Cannot Read.");
-            }
-
-            int r = _innerStream.Read(buffer, offset, count);
-            int r1 = r;
-
-            while (r1 != count)
-            {
-                if (_innerStream.Position != _innerStream.Length)
-                {
-                    _exceptionPending = true;
-                    throw new ZipException(String.Format("Read error in file {0}", CurrentName));
-
-                }
-
-                if (CurrentSegment + 1 == _maxDiskNumber)
-                    return r; // no more to read
-
-                CurrentSegment++;
-                _SetReadStream();
-                offset += r1;
-                count -= r1;
-                r1 = _innerStream.Read(buffer, offset, count);
-                r += r1;
-            }
-            return r;
-        }
-
-
-
-        private void _SetWriteStream(uint increment)
-        {
-            if (_innerStream != null)
-            {
-#if NETCF
-                _innerStream.Close();
-#else
-                _innerStream.Dispose();
-#endif
-                if (File.Exists(CurrentName))
-                    File.Delete(CurrentName);
-                File.Move(_currentTempName, CurrentName);
-                // Console.WriteLine("ZSS: SWS close ({0})",
-                //                   Path.GetFileName(CurrentName));
-            }
-
-            if (increment > 0)
-                CurrentSegment += increment;
-
-            SharedUtilities.CreateAndOpenUniqueTempFile(_baseDir,
-                                                        out _innerStream,
-                                                        out _currentTempName);
-
-            // Console.WriteLine("ZSS: SWS open ({0})",
-            //                   Path.GetFileName(_currentTempName));
-
-            if (CurrentSegment == 0)
-                _innerStream.Write(BitConverter.GetBytes(ZipConstants.SplitArchiveSignature), 0, 4);
-        }
-
-
-        /// <summary>
-        /// Write to the stream.
-        /// </summary>
-        /// <param name="buffer">the buffer from which to write</param>
-        /// <param name="offset">the offset at which to start writing</param>
-        /// <param name="count">the number of bytes to write</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (rwMode != RwMode.Write)
-            {
-                _exceptionPending = true;
-                throw new InvalidOperationException("Stream Error: Cannot Write.");
-            }
-
-
-            if (ContiguousWrite)
-            {
-                // enough space for a contiguous write?
-                if (_innerStream.Position + count > _maxSegmentSize)
-                    _SetWriteStream(1);
-            }
-            else
-            {
-                while (_innerStream.Position + count > _maxSegmentSize)
-                {
-                    int c = unchecked(_maxSegmentSize - (int)_innerStream.Position);
-                    _innerStream.Write(buffer, offset, c);
-                    _SetWriteStream(1);
-                    count -= c;
-                    offset += c;
-                }
-            }
-
-            _innerStream.Write(buffer, offset, count);
-        }
-
-
-        public long TruncateBackward(uint diskNumber, long offset)
-        {
-            // Console.WriteLine("***ZSS.Trunc to disk {0}", diskNumber);
-            // Console.WriteLine("***ZSS.Trunc:  current disk {0}", CurrentSegment);
-            if (diskNumber >= 99)
-                throw new ArgumentOutOfRangeException("diskNumber");
-
-            if (rwMode != RwMode.Write)
-            {
-                _exceptionPending = true;
-                throw new ZipException("bad state.");
-            }
-
-            // Seek back in the segmented stream to a (maybe) prior segment.
-
-            // Check if it is the same segment.  If it is, very simple.
-            if (diskNumber == CurrentSegment)
-            {
-                var x =_innerStream.Seek(offset, SeekOrigin.Begin);
-                // workitem 10178
-                Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_innerStream);
-                return x;
-            }
-
-            // Seeking back to a prior segment.
-            // The current segment and any intervening segments must be removed.
-            // First, close the current segment, and then remove it.
-            if (_innerStream != null)
-            {
-#if NETCF
-                _innerStream.Close();
-#else
-                _innerStream.Dispose();
-#endif
-                if (File.Exists(_currentTempName))
-                    File.Delete(_currentTempName);
-            }
-
-            // Now, remove intervening segments.
-            for (uint j= CurrentSegment-1; j > diskNumber; j--)
-            {
-                string s = _NameForSegment(j);
-                // Console.WriteLine("***ZSS.Trunc:  removing file {0}", s);
-                if (File.Exists(s))
-                    File.Delete(s);
-            }
-
-            // now, open the desired segment.  It must exist.
-            CurrentSegment = diskNumber;
-
-            // get a new temp file, try 3 times:
-            for (int i = 0; i < 3; i++)
-            {
-                try
-                {
-                    _currentTempName = SharedUtilities.InternalGetTempFileName();
-                    // move the .z0x file back to a temp name
-                    File.Move(CurrentName, _currentTempName);
-                    break; // workitem 12403
-                }
-                catch(IOException)
-                {
-                    if (i == 2) throw;
-                }
-            }
-
-            // open it
-            _innerStream = new FileStream(_currentTempName, FileMode.Open);
-
-            var r =  _innerStream.Seek(offset, SeekOrigin.Begin);
-
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_innerStream);
-
-            return r;
-        }
-
-
-
-        public override bool CanRead
-        {
-            get
-            {
-                return (rwMode == RwMode.ReadOnly &&
-                        (_innerStream != null) &&
-                        _innerStream.CanRead);
-            }
-        }
-
-
-        public override bool CanSeek
-        {
-            get
-            {
-                return (_innerStream != null) &&
-                        _innerStream.CanSeek;
-            }
-        }
-
-
-        public override bool CanWrite
-        {
-            get
-            {
-                return (rwMode == RwMode.Write) &&
-                        (_innerStream != null) &&
-                        _innerStream.CanWrite;
-            }
-        }
-
-        public override void Flush()
-        {
-            _innerStream.Flush();
-        }
-
-        public override long Length
-        {
-            get
-            {
-                return _innerStream.Length;
-            }
-        }
-
-        public override long Position
-        {
-            get { return _innerStream.Position; }
-            set { _innerStream.Position = value; }
-        }
-
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            var x = _innerStream.Seek(offset, origin);
-            // workitem 10178
-            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_innerStream);
-            return x;
-        }
-
-        public override void SetLength(long value)
-        {
-            if (rwMode != RwMode.Write)
-            {
-                _exceptionPending = true;
-                throw new InvalidOperationException();
-            }
-            _innerStream.SetLength(value);
-        }
-
-
-        protected override void Dispose(bool disposing)
-        {
-            // this gets called by Stream.Close()
-
-            // if (_isDisposed) return;
-            // _isDisposed = true;
-            //Console.WriteLine("Dispose (mode={0})\n", rwMode.ToString());
-
-            try
-            {
-                if (_innerStream != null)
-                {
-#if NETCF
-                    _innerStream.Close();
-#else
-                    _innerStream.Dispose();
-#endif
-                    //_innerStream = null;
-                    if (rwMode == RwMode.Write)
-                    {
-                        if (_exceptionPending)
-                        {
-                            // possibly could try to clean up all the
-                            // temp files created so far...
-                        }
-                        else
-                        {
-                            // // move the final temp file to the .zNN name
-                            // if (File.Exists(CurrentName))
-                            //     File.Delete(CurrentName);
-                            // if (File.Exists(_currentTempName))
-                            //     File.Move(_currentTempName, CurrentName);
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                base.Dispose(disposing);
-            }
-        }
-
-    }
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/Deflate.cs b/EPPlus/Packaging/DotNetZip/Zlib/Deflate.cs
deleted file mode 100644
index d5d32ad..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/Deflate.cs
+++ /dev/null
@@ -1,1879 +0,0 @@
-// Deflate.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-03 19:52:15>
-//
-// ------------------------------------------------------------------
-//
-// This module defines logic for handling the Deflate or compression.
-//
-// This code is based on multiple sources:
-// - the original zlib v1.2.3 source, which is Copyright (C) 1995-2005 Jean-loup Gailly.
-// - the original jzlib, which is Copyright (c) 2000-2003 ymnk, JCraft,Inc.
-//
-// However, this code is significantly different from both.
-// The object model is not the same, and many of the behaviors are different.
-//
-// In keeping with the license for these other works, the copyrights for
-// jzlib and zlib are here.
-//
-// -----------------------------------------------------------------------
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in
-// the documentation and/or other materials provided with the distribution.
-//
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-
-    internal enum BlockState
-    {
-        NeedMore = 0,       // block not completed, need more input or more output
-        BlockDone,          // block flush performed
-        FinishStarted,              // finish started, need only more output at next deflate
-        FinishDone          // finish done, accept no more input or output
-    }
-
-    internal enum DeflateFlavor
-    {
-        Store,
-        Fast,
-        Slow
-    }
-
-    internal sealed class DeflateManager
-    {
-        private static readonly int MEM_LEVEL_MAX = 9;
-        private static readonly int MEM_LEVEL_DEFAULT = 8;
-
-        internal delegate BlockState CompressFunc(FlushType flush);
-
-        internal class Config
-        {
-            // Use a faster search when the previous match is longer than this
-            internal int GoodLength; // reduce lazy search above this match length
-
-            // Attempt to find a better match only when the current match is
-            // strictly smaller than this value. This mechanism is used only for
-            // compression levels >= 4.  For levels 1,2,3: MaxLazy is actually
-            // MaxInsertLength. (See DeflateFast)
-
-            internal int MaxLazy;    // do not perform lazy search above this match length
-
-            internal int NiceLength; // quit search above this match length
-
-            // To speed up deflation, hash chains are never searched beyond this
-            // length.  A higher limit improves compression ratio but degrades the speed.
-
-            internal int MaxChainLength;
-
-            internal DeflateFlavor Flavor;
-
-            private Config(int goodLength, int maxLazy, int niceLength, int maxChainLength, DeflateFlavor flavor)
-            {
-                this.GoodLength = goodLength;
-                this.MaxLazy = maxLazy;
-                this.NiceLength = niceLength;
-                this.MaxChainLength = maxChainLength;
-                this.Flavor = flavor;
-            }
-
-            public static Config Lookup(CompressionLevel level)
-            {
-                return Table[(int)level];
-            }
-
-
-            static Config()
-            {
-                Table = new Config[] {
-                    new Config(0, 0, 0, 0, DeflateFlavor.Store),
-                    new Config(4, 4, 8, 4, DeflateFlavor.Fast),
-                    new Config(4, 5, 16, 8, DeflateFlavor.Fast),
-                    new Config(4, 6, 32, 32, DeflateFlavor.Fast),
-
-                    new Config(4, 4, 16, 16, DeflateFlavor.Slow),
-                    new Config(8, 16, 32, 32, DeflateFlavor.Slow),
-                    new Config(8, 16, 128, 128, DeflateFlavor.Slow),
-                    new Config(8, 32, 128, 256, DeflateFlavor.Slow),
-                    new Config(32, 128, 258, 1024, DeflateFlavor.Slow),
-                    new Config(32, 258, 258, 4096, DeflateFlavor.Slow),
-                };
-            }
-
-            private static readonly Config[] Table;
-        }
-
-
-        private CompressFunc DeflateFunction;
-
-        private static readonly System.String[] _ErrorMessage = new System.String[]
-        {
-            "need dictionary",
-            "stream end",
-            "",
-            "file error",
-            "stream error",
-            "data error",
-            "insufficient memory",
-            "buffer error",
-            "incompatible version",
-            ""
-        };
-
-        // preset dictionary flag in zlib header
-        private static readonly int PRESET_DICT = 0x20;
-
-        private static readonly int INIT_STATE = 42;
-        private static readonly int BUSY_STATE = 113;
-        private static readonly int FINISH_STATE = 666;
-
-        // The deflate compression method
-        private static readonly int Z_DEFLATED = 8;
-
-        private static readonly int STORED_BLOCK = 0;
-        private static readonly int STATIC_TREES = 1;
-        private static readonly int DYN_TREES = 2;
-
-        // The three kinds of block type
-        private static readonly int Z_BINARY = 0;
-        private static readonly int Z_ASCII = 1;
-        private static readonly int Z_UNKNOWN = 2;
-
-        private static readonly int Buf_size = 8 * 2;
-
-        private static readonly int MIN_MATCH = 3;
-        private static readonly int MAX_MATCH = 258;
-
-        private static readonly int MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
-
-        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
-
-        private static readonly int END_BLOCK = 256;
-
-        internal ZlibCodec _codec; // the zlib encoder/decoder
-        internal int status;       // as the name implies
-        internal byte[] pending;   // output still pending - waiting to be compressed
-        internal int nextPending;  // index of next pending byte to output to the stream
-        internal int pendingCount; // number of bytes in the pending buffer
-
-        internal sbyte data_type;  // UNKNOWN, BINARY or ASCII
-        internal int last_flush;   // value of flush param for previous deflate call
-
-        internal int w_size;       // LZ77 window size (32K by default)
-        internal int w_bits;       // log2(w_size)  (8..16)
-        internal int w_mask;       // w_size - 1
-
-        //internal byte[] dictionary;
-        internal byte[] window;
-
-        // Sliding window. Input bytes are read into the second half of the window,
-        // and move to the first half later to keep a dictionary of at least wSize
-        // bytes. With this organization, matches are limited to a distance of
-        // wSize-MAX_MATCH bytes, but this ensures that IO is always
-        // performed with a length multiple of the block size.
-        //
-        // To do: use the user input buffer as sliding window.
-
-        internal int window_size;
-        // Actual size of window: 2*wSize, except when the user input buffer
-        // is directly used as sliding window.
-
-        internal short[] prev;
-        // Link to older string with same hash index. To limit the size of this
-        // array to 64K, this link is maintained only for the last 32K strings.
-        // An index in this array is thus a window index modulo 32K.
-
-        internal short[] head;  // Heads of the hash chains or NIL.
-
-        internal int ins_h;     // hash index of string to be inserted
-        internal int hash_size; // number of elements in hash table
-        internal int hash_bits; // log2(hash_size)
-        internal int hash_mask; // hash_size-1
-
-        // Number of bits by which ins_h must be shifted at each input
-        // step. It must be such that after MIN_MATCH steps, the oldest
-        // byte no longer takes part in the hash key, that is:
-        // hash_shift * MIN_MATCH >= hash_bits
-        internal int hash_shift;
-
-        // Window position at the beginning of the current output block. Gets
-        // negative when the window is moved backwards.
-
-        internal int block_start;
-
-        Config config;
-        internal int match_length;    // length of best match
-        internal int prev_match;      // previous match
-        internal int match_available; // set if previous match exists
-        internal int strstart;        // start of string to insert into.....????
-        internal int match_start;     // start of matching string
-        internal int lookahead;       // number of valid bytes ahead in window
-
-        // Length of the best match at previous step. Matches not greater than this
-        // are discarded. This is used in the lazy match evaluation.
-        internal int prev_length;
-
-        // Insert new strings in the hash table only if the match length is not
-        // greater than this length. This saves time but degrades compression.
-        // max_insert_length is used only for compression levels <= 3.
-
-        internal CompressionLevel compressionLevel; // compression level (1..9)
-        internal CompressionStrategy compressionStrategy; // favor or force Huffman coding
-
-
-        internal short[] dyn_ltree;         // literal and length tree
-        internal short[] dyn_dtree;         // distance tree
-        internal short[] bl_tree;           // Huffman tree for bit lengths
-
-        internal Tree treeLiterals = new Tree();  // desc for literal tree
-        internal Tree treeDistances = new Tree();  // desc for distance tree
-        internal Tree treeBitLengths = new Tree(); // desc for bit length tree
-
-        // number of codes at each bit length for an optimal tree
-        internal short[] bl_count = new short[InternalConstants.MAX_BITS + 1];
-
-        // heap used to build the Huffman trees
-        internal int[] heap = new int[2 * InternalConstants.L_CODES + 1];
-
-        internal int heap_len;              // number of elements in the heap
-        internal int heap_max;              // element of largest frequency
-
-        // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
-        // The same heap array is used to build all trees.
-
-        // Depth of each subtree used as tie breaker for trees of equal frequency
-        internal sbyte[] depth = new sbyte[2 * InternalConstants.L_CODES + 1];
-
-        internal int _lengthOffset;                 // index for literals or lengths
-
-
-        // Size of match buffer for literals/lengths.  There are 4 reasons for
-        // limiting lit_bufsize to 64K:
-        //   - frequencies can be kept in 16 bit counters
-        //   - if compression is not successful for the first block, all input
-        //     data is still in the window so we can still emit a stored block even
-        //     when input comes from standard input.  (This can also be done for
-        //     all blocks if lit_bufsize is not greater than 32K.)
-        //   - if compression is not successful for a file smaller than 64K, we can
-        //     even emit a stored file instead of a stored block (saving 5 bytes).
-        //     This is applicable only for zip (not gzip or zlib).
-        //   - creating new Huffman trees less frequently may not provide fast
-        //     adaptation to changes in the input data statistics. (Take for
-        //     example a binary file with poorly compressible code followed by
-        //     a highly compressible string table.) Smaller buffer sizes give
-        //     fast adaptation but have of course the overhead of transmitting
-        //     trees more frequently.
-
-        internal int lit_bufsize;
-
-        internal int last_lit;     // running index in l_buf
-
-        // Buffer for distances. To simplify the code, d_buf and l_buf have
-        // the same number of elements. To use different lengths, an extra flag
-        // array would be necessary.
-
-        internal int _distanceOffset;        // index into pending; points to distance data??
-
-        internal int opt_len;      // bit length of current block with optimal trees
-        internal int static_len;   // bit length of current block with static trees
-        internal int matches;      // number of string matches in current block
-        internal int last_eob_len; // bit length of EOB code for last block
-
-        // Output buffer. bits are inserted starting at the bottom (least
-        // significant bits).
-        internal short bi_buf;
-
-        // Number of valid bits in bi_buf.  All bits above the last valid bit
-        // are always zero.
-        internal int bi_valid;
-
-
-        internal DeflateManager()
-        {
-            dyn_ltree = new short[HEAP_SIZE * 2];
-            dyn_dtree = new short[(2 * InternalConstants.D_CODES + 1) * 2]; // distance tree
-            bl_tree = new short[(2 * InternalConstants.BL_CODES + 1) * 2]; // Huffman tree for bit lengths
-        }
-
-
-        // lm_init
-        private void _InitializeLazyMatch()
-        {
-            window_size = 2 * w_size;
-
-            // clear the hash - workitem 9063
-            Array.Clear(head, 0, hash_size);
-            //for (int i = 0; i < hash_size; i++) head[i] = 0;
-
-            config = Config.Lookup(compressionLevel);
-            SetDeflater();
-
-            strstart = 0;
-            block_start = 0;
-            lookahead = 0;
-            match_length = prev_length = MIN_MATCH - 1;
-            match_available = 0;
-            ins_h = 0;
-        }
-
-        // Initialize the tree data structures for a new zlib stream.
-        private void _InitializeTreeData()
-        {
-            treeLiterals.dyn_tree = dyn_ltree;
-            treeLiterals.staticTree = StaticTree.Literals;
-
-            treeDistances.dyn_tree = dyn_dtree;
-            treeDistances.staticTree = StaticTree.Distances;
-
-            treeBitLengths.dyn_tree = bl_tree;
-            treeBitLengths.staticTree = StaticTree.BitLengths;
-
-            bi_buf = 0;
-            bi_valid = 0;
-            last_eob_len = 8; // enough lookahead for inflate
-
-            // Initialize the first block of the first file:
-            _InitializeBlocks();
-        }
-
-        internal void _InitializeBlocks()
-        {
-            // Initialize the trees.
-            for (int i = 0; i < InternalConstants.L_CODES; i++)
-                dyn_ltree[i * 2] = 0;
-            for (int i = 0; i < InternalConstants.D_CODES; i++)
-                dyn_dtree[i * 2] = 0;
-            for (int i = 0; i < InternalConstants.BL_CODES; i++)
-                bl_tree[i * 2] = 0;
-
-            dyn_ltree[END_BLOCK * 2] = 1;
-            opt_len = static_len = 0;
-            last_lit = matches = 0;
-        }
-
-        // Restore the heap property by moving down the tree starting at node k,
-        // exchanging a node with the smallest of its two sons if necessary, stopping
-        // when the heap property is re-established (each father smaller than its
-        // two sons).
-        internal void pqdownheap(short[] tree, int k)
-        {
-            int v = heap[k];
-            int j = k << 1; // left son of k
-            while (j <= heap_len)
-            {
-                // Set j to the smallest of the two sons:
-                if (j < heap_len && _IsSmaller(tree, heap[j + 1], heap[j], depth))
-                {
-                    j++;
-                }
-                // Exit if v is smaller than both sons
-                if (_IsSmaller(tree, v, heap[j], depth))
-                    break;
-
-                // Exchange v with the smallest son
-                heap[k] = heap[j]; k = j;
-                // And continue down the tree, setting j to the left son of k
-                j <<= 1;
-            }
-            heap[k] = v;
-        }
-
-        internal static bool _IsSmaller(short[] tree, int n, int m, sbyte[] depth)
-        {
-            short tn2 = tree[n * 2];
-            short tm2 = tree[m * 2];
-            return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
-        }
-
-
-        // Scan a literal or distance tree to determine the frequencies of the codes
-        // in the bit length tree.
-        internal void scan_tree(short[] tree, int max_code)
-        {
-            int n; // iterates over all tree elements
-            int prevlen = -1; // last emitted length
-            int curlen; // length of current code
-            int nextlen = (int)tree[0 * 2 + 1]; // length of next code
-            int count = 0; // repeat count of the current code
-            int max_count = 7; // max repeat count
-            int min_count = 4; // min repeat count
-
-            if (nextlen == 0)
-            {
-                max_count = 138; min_count = 3;
-            }
-            tree[(max_code + 1) * 2 + 1] = (short)0x7fff; // guard //??
-
-            for (n = 0; n <= max_code; n++)
-            {
-                curlen = nextlen; nextlen = (int)tree[(n + 1) * 2 + 1];
-                if (++count < max_count && curlen == nextlen)
-                {
-                    continue;
-                }
-                else if (count < min_count)
-                {
-                    bl_tree[curlen * 2] = (short)(bl_tree[curlen * 2] + count);
-                }
-                else if (curlen != 0)
-                {
-                    if (curlen != prevlen)
-                        bl_tree[curlen * 2]++;
-                    bl_tree[InternalConstants.REP_3_6 * 2]++;
-                }
-                else if (count <= 10)
-                {
-                    bl_tree[InternalConstants.REPZ_3_10 * 2]++;
-                }
-                else
-                {
-                    bl_tree[InternalConstants.REPZ_11_138 * 2]++;
-                }
-                count = 0; prevlen = curlen;
-                if (nextlen == 0)
-                {
-                    max_count = 138; min_count = 3;
-                }
-                else if (curlen == nextlen)
-                {
-                    max_count = 6; min_count = 3;
-                }
-                else
-                {
-                    max_count = 7; min_count = 4;
-                }
-            }
-        }
-
-        // Construct the Huffman tree for the bit lengths and return the index in
-        // bl_order of the last bit length code to send.
-        internal int build_bl_tree()
-        {
-            int max_blindex; // index of last bit length code of non zero freq
-
-            // Determine the bit length frequencies for literal and distance trees
-            scan_tree(dyn_ltree, treeLiterals.max_code);
-            scan_tree(dyn_dtree, treeDistances.max_code);
-
-            // Build the bit length tree:
-            treeBitLengths.build_tree(this);
-            // opt_len now includes the length of the tree representations, except
-            // the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
-
-            // Determine the number of bit length codes to send. The pkzip format
-            // requires that at least 4 bit length codes be sent. (appnote.txt says
-            // 3 but the actual value used is 4.)
-            for (max_blindex = InternalConstants.BL_CODES - 1; max_blindex >= 3; max_blindex--)
-            {
-                if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] != 0)
-                    break;
-            }
-            // Update opt_len to include the bit length tree and counts
-            opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
-
-            return max_blindex;
-        }
-
-
-        // Send the header for a block using dynamic Huffman trees: the counts, the
-        // lengths of the bit length codes, the literal tree and the distance tree.
-        // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
-        internal void send_all_trees(int lcodes, int dcodes, int blcodes)
-        {
-            int rank; // index in bl_order
-
-            send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt
-            send_bits(dcodes - 1, 5);
-            send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt
-            for (rank = 0; rank < blcodes; rank++)
-            {
-                send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
-            }
-            send_tree(dyn_ltree, lcodes - 1); // literal tree
-            send_tree(dyn_dtree, dcodes - 1); // distance tree
-        }
-
-        // Send a literal or distance tree in compressed form, using the codes in
-        // bl_tree.
-        internal void send_tree(short[] tree, int max_code)
-        {
-            int n;                           // iterates over all tree elements
-            int prevlen   = -1;              // last emitted length
-            int curlen;                      // length of current code
-            int nextlen   = tree[0 * 2 + 1]; // length of next code
-            int count     = 0;               // repeat count of the current code
-            int max_count = 7;               // max repeat count
-            int min_count = 4;               // min repeat count
-
-            if (nextlen == 0)
-            {
-                max_count = 138; min_count = 3;
-            }
-
-            for (n = 0; n <= max_code; n++)
-            {
-                curlen = nextlen; nextlen = tree[(n + 1) * 2 + 1];
-                if (++count < max_count && curlen == nextlen)
-                {
-                    continue;
-                }
-                else if (count < min_count)
-                {
-                    do
-                    {
-                        send_code(curlen, bl_tree);
-                    }
-                    while (--count != 0);
-                }
-                else if (curlen != 0)
-                {
-                    if (curlen != prevlen)
-                    {
-                        send_code(curlen, bl_tree); count--;
-                    }
-                    send_code(InternalConstants.REP_3_6, bl_tree);
-                    send_bits(count - 3, 2);
-                }
-                else if (count <= 10)
-                {
-                    send_code(InternalConstants.REPZ_3_10, bl_tree);
-                    send_bits(count - 3, 3);
-                }
-                else
-                {
-                    send_code(InternalConstants.REPZ_11_138, bl_tree);
-                    send_bits(count - 11, 7);
-                }
-                count = 0; prevlen = curlen;
-                if (nextlen == 0)
-                {
-                    max_count = 138; min_count = 3;
-                }
-                else if (curlen == nextlen)
-                {
-                    max_count = 6; min_count = 3;
-                }
-                else
-                {
-                    max_count = 7; min_count = 4;
-                }
-            }
-        }
-
-        // Output a block of bytes on the stream.
-        // IN assertion: there is enough room in pending_buf.
-        private void put_bytes(byte[] p, int start, int len)
-        {
-            Array.Copy(p, start, pending, pendingCount, len);
-            pendingCount += len;
-        }
-
-#if NOTNEEDED
-        private void put_byte(byte c)
-        {
-            pending[pendingCount++] = c;
-        }
-        internal void put_short(int b)
-        {
-            unchecked
-            {
-                pending[pendingCount++] = (byte)b;
-                pending[pendingCount++] = (byte)(b >> 8);
-            }
-        }
-        internal void putShortMSB(int b)
-        {
-            unchecked
-            {
-                pending[pendingCount++] = (byte)(b >> 8);
-                pending[pendingCount++] = (byte)b;
-            }
-        }
-#endif
-
-        internal void send_code(int c, short[] tree)
-        {
-            int c2 = c * 2;
-            send_bits((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
-        }
-
-        internal void send_bits(int value, int length)
-        {
-            int len = length;
-            unchecked
-            {
-                if (bi_valid > (int)Buf_size - len)
-                {
-                    //int val = value;
-                    //      bi_buf |= (val << bi_valid);
-
-                    bi_buf |= (short)((value << bi_valid) & 0xffff);
-                    //put_short(bi_buf);
-                        pending[pendingCount++] = (byte)bi_buf;
-                        pending[pendingCount++] = (byte)(bi_buf >> 8);
-
-
-                    bi_buf = (short)((uint)value >> (Buf_size - bi_valid));
-                    bi_valid += len - Buf_size;
-                }
-                else
-                {
-                    //      bi_buf |= (value) << bi_valid;
-                    bi_buf |= (short)((value << bi_valid) & 0xffff);
-                    bi_valid += len;
-                }
-            }
-        }
-
-        // Send one empty static block to give enough lookahead for inflate.
-        // This takes 10 bits, of which 7 may remain in the bit buffer.
-        // The current inflate code requires 9 bits of lookahead. If the
-        // last two codes for the previous block (real code plus EOB) were coded
-        // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
-        // the last real code. In this case we send two empty static blocks instead
-        // of one. (There are no problems if the previous block is stored or fixed.)
-        // To simplify the code, we assume the worst case of last real code encoded
-        // on one bit only.
-        internal void _tr_align()
-        {
-            send_bits(STATIC_TREES << 1, 3);
-            send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
-
-            bi_flush();
-
-            // Of the 10 bits for the empty block, we have already sent
-            // (10 - bi_valid) bits. The lookahead for the last real code (before
-            // the EOB of the previous block) was thus at least one plus the length
-            // of the EOB plus what we have just sent of the empty static block.
-            if (1 + last_eob_len + 10 - bi_valid < 9)
-            {
-                send_bits(STATIC_TREES << 1, 3);
-                send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
-                bi_flush();
-            }
-            last_eob_len = 7;
-        }
-
-
-        // Save the match info and tally the frequency counts. Return true if
-        // the current block must be flushed.
-        internal bool _tr_tally(int dist, int lc)
-        {
-            pending[_distanceOffset + last_lit * 2] = unchecked((byte) ( (uint)dist >> 8 ) );
-            pending[_distanceOffset + last_lit * 2 + 1] = unchecked((byte)dist);
-            pending[_lengthOffset + last_lit] = unchecked((byte)lc);
-            last_lit++;
-
-            if (dist == 0)
-            {
-                // lc is the unmatched char
-                dyn_ltree[lc * 2]++;
-            }
-            else
-            {
-                matches++;
-                // Here, lc is the match length - MIN_MATCH
-                dist--; // dist = match distance - 1
-                dyn_ltree[(Tree.LengthCode[lc] + InternalConstants.LITERALS + 1) * 2]++;
-                dyn_dtree[Tree.DistanceCode(dist) * 2]++;
-            }
-
-            if ((last_lit & 0x1fff) == 0 && (int)compressionLevel > 2)
-            {
-                // Compute an upper bound for the compressed length
-                int out_length = last_lit << 3;
-                int in_length = strstart - block_start;
-                int dcode;
-                for (dcode = 0; dcode < InternalConstants.D_CODES; dcode++)
-                {
-                    out_length = (int)(out_length + (int)dyn_dtree[dcode * 2] * (5L + Tree.ExtraDistanceBits[dcode]));
-                }
-                out_length >>= 3;
-                if ((matches < (last_lit / 2)) && out_length < in_length / 2)
-                    return true;
-            }
-
-            return (last_lit == lit_bufsize - 1) || (last_lit == lit_bufsize);
-            // dinoch - wraparound?
-            // We avoid equality with lit_bufsize because of wraparound at 64K
-            // on 16 bit machines and because stored blocks are restricted to
-            // 64K-1 bytes.
-        }
-
-
-
-        // Send the block data compressed using the given Huffman trees
-        internal void send_compressed_block(short[] ltree, short[] dtree)
-        {
-            int distance; // distance of matched string
-            int lc;       // match length or unmatched char (if dist == 0)
-            int lx = 0;   // running index in l_buf
-            int code;     // the code to send
-            int extra;    // number of extra bits to send
-
-            if (last_lit != 0)
-            {
-                do
-                {
-                    int ix = _distanceOffset + lx * 2;
-                    distance = ((pending[ix] << 8) & 0xff00) |
-                        (pending[ix + 1] & 0xff);
-                    lc = (pending[_lengthOffset + lx]) & 0xff;
-                    lx++;
-
-                    if (distance == 0)
-                    {
-                        send_code(lc, ltree); // send a literal byte
-                    }
-                    else
-                    {
-                        // literal or match pair
-                        // Here, lc is the match length - MIN_MATCH
-                        code = Tree.LengthCode[lc];
-
-                        // send the length code
-                        send_code(code + InternalConstants.LITERALS + 1, ltree);
-                        extra = Tree.ExtraLengthBits[code];
-                        if (extra != 0)
-                        {
-                            // send the extra length bits
-                            lc -= Tree.LengthBase[code];
-                            send_bits(lc, extra);
-                        }
-                        distance--; // dist is now the match distance - 1
-                        code = Tree.DistanceCode(distance);
-
-                        // send the distance code
-                        send_code(code, dtree);
-
-                        extra = Tree.ExtraDistanceBits[code];
-                        if (extra != 0)
-                        {
-                            // send the extra distance bits
-                            distance -= Tree.DistanceBase[code];
-                            send_bits(distance, extra);
-                        }
-                    }
-
-                    // Check that the overlay between pending and d_buf+l_buf is ok:
-                }
-                while (lx < last_lit);
-            }
-
-            send_code(END_BLOCK, ltree);
-            last_eob_len = ltree[END_BLOCK * 2 + 1];
-        }
-
-
-
-        // Set the data type to ASCII or BINARY, using a crude approximation:
-        // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
-        // IN assertion: the fields freq of dyn_ltree are set and the total of all
-        // frequencies does not exceed 64K (to fit in an int on 16 bit machines).
-        internal void set_data_type()
-        {
-            int n = 0;
-            int ascii_freq = 0;
-            int bin_freq = 0;
-            while (n < 7)
-            {
-                bin_freq += dyn_ltree[n * 2]; n++;
-            }
-            while (n < 128)
-            {
-                ascii_freq += dyn_ltree[n * 2]; n++;
-            }
-            while (n < InternalConstants.LITERALS)
-            {
-                bin_freq += dyn_ltree[n * 2]; n++;
-            }
-            data_type = (sbyte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
-        }
-
-
-
-        // Flush the bit buffer, keeping at most 7 bits in it.
-        internal void bi_flush()
-        {
-            if (bi_valid == 16)
-            {
-                pending[pendingCount++] = (byte)bi_buf;
-                pending[pendingCount++] = (byte)(bi_buf >> 8);
-                bi_buf = 0;
-                bi_valid = 0;
-            }
-            else if (bi_valid >= 8)
-            {
-                //put_byte((byte)bi_buf);
-                pending[pendingCount++] = (byte)bi_buf;
-                bi_buf >>= 8;
-                bi_valid -= 8;
-            }
-        }
-
-        // Flush the bit buffer and align the output on a byte boundary
-        internal void bi_windup()
-        {
-            if (bi_valid > 8)
-            {
-                pending[pendingCount++] = (byte)bi_buf;
-                pending[pendingCount++] = (byte)(bi_buf >> 8);
-            }
-            else if (bi_valid > 0)
-            {
-                //put_byte((byte)bi_buf);
-                pending[pendingCount++] = (byte)bi_buf;
-            }
-            bi_buf = 0;
-            bi_valid = 0;
-        }
-
-        // Copy a stored block, storing first the length and its
-        // one's complement if requested.
-        internal void copy_block(int buf, int len, bool header)
-        {
-            bi_windup(); // align on byte boundary
-            last_eob_len = 8; // enough lookahead for inflate
-
-            if (header)
-                unchecked
-                {
-                    //put_short((short)len);
-                    pending[pendingCount++] = (byte)len;
-                    pending[pendingCount++] = (byte)(len >> 8);
-                    //put_short((short)~len);
-                    pending[pendingCount++] = (byte)~len;
-                    pending[pendingCount++] = (byte)(~len >> 8);
-                }
-
-            put_bytes(window, buf, len);
-        }
-
-        internal void flush_block_only(bool eof)
-        {
-            _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
-            block_start = strstart;
-            _codec.flush_pending();
-        }
-
-        // Copy without compression as much as possible from the input stream, return
-        // the current block state.
-        // This function does not insert new strings in the dictionary since
-        // uncompressible data is probably not useful. This function is used
-        // only for the level=0 compression option.
-        // NOTE: this function should be optimized to avoid extra copying from
-        // window to pending_buf.
-        internal BlockState DeflateNone(FlushType flush)
-        {
-            // Stored blocks are limited to 0xffff bytes, pending is limited
-            // to pending_buf_size, and each stored block has a 5 byte header:
-
-            int max_block_size = 0xffff;
-            int max_start;
-
-            if (max_block_size > pending.Length - 5)
-            {
-                max_block_size = pending.Length - 5;
-            }
-
-            // Copy as much as possible from input to output:
-            while (true)
-            {
-                // Fill the window as much as possible:
-                if (lookahead <= 1)
-                {
-                    _fillWindow();
-                    if (lookahead == 0 && flush == FlushType.None)
-                        return BlockState.NeedMore;
-                    if (lookahead == 0)
-                        break; // flush the current block
-                }
-
-                strstart += lookahead;
-                lookahead = 0;
-
-                // Emit a stored block if pending will be full:
-                max_start = block_start + max_block_size;
-                if (strstart == 0 || strstart >= max_start)
-                {
-                    // strstart == 0 is possible when wraparound on 16-bit machine
-                    lookahead = (int)(strstart - max_start);
-                    strstart = (int)max_start;
-
-                    flush_block_only(false);
-                    if (_codec.AvailableBytesOut == 0)
-                        return BlockState.NeedMore;
-                }
-
-                // Flush if we may have to slide, otherwise block_start may become
-                // negative and the data will be gone:
-                if (strstart - block_start >= w_size - MIN_LOOKAHEAD)
-                {
-                    flush_block_only(false);
-                    if (_codec.AvailableBytesOut == 0)
-                        return BlockState.NeedMore;
-                }
-            }
-
-            flush_block_only(flush == FlushType.Finish);
-            if (_codec.AvailableBytesOut == 0)
-                return (flush == FlushType.Finish) ? BlockState.FinishStarted : BlockState.NeedMore;
-
-            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
-        }
-
-
-        // Send a stored block
-        internal void _tr_stored_block(int buf, int stored_len, bool eof)
-        {
-            send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3); // send block type
-            copy_block(buf, stored_len, true); // with header
-        }
-
-        // Determine the best encoding for the current block: dynamic trees, static
-        // trees or store, and output the encoded block to the zip file.
-        internal void _tr_flush_block(int buf, int stored_len, bool eof)
-        {
-            int opt_lenb, static_lenb; // opt_len and static_len in bytes
-            int max_blindex = 0; // index of last bit length code of non zero freq
-
-            // Build the Huffman trees unless a stored block is forced
-            if (compressionLevel > 0)
-            {
-                // Check if the file is ascii or binary
-                if (data_type == Z_UNKNOWN)
-                    set_data_type();
-
-                // Construct the literal and distance trees
-                treeLiterals.build_tree(this);
-
-                treeDistances.build_tree(this);
-
-                // At this point, opt_len and static_len are the total bit lengths of
-                // the compressed block data, excluding the tree representations.
-
-                // Build the bit length tree for the above two trees, and get the index
-                // in bl_order of the last bit length code to send.
-                max_blindex = build_bl_tree();
-
-                // Determine the best encoding. Compute first the block length in bytes
-                opt_lenb = (opt_len + 3 + 7) >> 3;
-                static_lenb = (static_len + 3 + 7) >> 3;
-
-                if (static_lenb <= opt_lenb)
-                    opt_lenb = static_lenb;
-            }
-            else
-            {
-                opt_lenb = static_lenb = stored_len + 5; // force a stored block
-            }
-
-            if (stored_len + 4 <= opt_lenb && buf != -1)
-            {
-                // 4: two words for the lengths
-                // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
-                // Otherwise we can't have processed more than WSIZE input bytes since
-                // the last block flush, because compression would have been
-                // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
-                // transform a block into a stored block.
-                _tr_stored_block(buf, stored_len, eof);
-            }
-            else if (static_lenb == opt_lenb)
-            {
-                send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
-                send_compressed_block(StaticTree.lengthAndLiteralsTreeCodes, StaticTree.distTreeCodes);
-            }
-            else
-            {
-                send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
-                send_all_trees(treeLiterals.max_code + 1, treeDistances.max_code + 1, max_blindex + 1);
-                send_compressed_block(dyn_ltree, dyn_dtree);
-            }
-
-            // The above check is made mod 2^32, for files larger than 512 MB
-            // and uLong implemented on 32 bits.
-
-            _InitializeBlocks();
-
-            if (eof)
-            {
-                bi_windup();
-            }
-        }
-
-        // Fill the window when the lookahead becomes insufficient.
-        // Updates strstart and lookahead.
-        //
-        // IN assertion: lookahead < MIN_LOOKAHEAD
-        // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
-        //    At least one byte has been read, or avail_in == 0; reads are
-        //    performed for at least two bytes (required for the zip translate_eol
-        //    option -- not supported here).
-        private void _fillWindow()
-        {
-            int n, m;
-            int p;
-            int more; // Amount of free space at the end of the window.
-
-            do
-            {
-                more = (window_size - lookahead - strstart);
-
-                // Deal with !@#$% 64K limit:
-                if (more == 0 && strstart == 0 && lookahead == 0)
-                {
-                    more = w_size;
-                }
-                else if (more == -1)
-                {
-                    // Very unlikely, but possible on 16 bit machine if strstart == 0
-                    // and lookahead == 1 (input done one byte at time)
-                    more--;
-
-                    // 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 (strstart >= w_size + w_size - MIN_LOOKAHEAD)
-                {
-                    Array.Copy(window, w_size, window, 0, w_size);
-                    match_start -= w_size;
-                    strstart -= w_size; // we now have strstart >= MAX_DIST
-                    block_start -= w_size;
-
-                    // Slide the hash table (could be avoided with 32 bit values
-                    // at the expense of memory usage). We slide even when level == 0
-                    // to keep the hash table consistent if we switch back to level > 0
-                    // later. (Using level 0 permanently is not an optimal usage of
-                    // zlib, so we don't care about this pathological case.)
-
-                    n = hash_size;
-                    p = n;
-                    do
-                    {
-                        m = (head[--p] & 0xffff);
-                        head[p] = (short)((m >= w_size) ? (m - w_size) : 0);
-                    }
-                    while (--n != 0);
-
-                    n = w_size;
-                    p = n;
-                    do
-                    {
-                        m = (prev[--p] & 0xffff);
-                        prev[p] = (short)((m >= w_size) ? (m - w_size) : 0);
-                        // If n is not on any hash chain, prev[n] is garbage but
-                        // its value will never be used.
-                    }
-                    while (--n != 0);
-                    more += w_size;
-                }
-
-                if (_codec.AvailableBytesIn == 0)
-                    return;
-
-                // If there was no sliding:
-                //    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
-                //    more == window_size - lookahead - strstart
-                // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
-                // => more >= window_size - 2*WSIZE + 2
-                // In the BIG_MEM or MMAP case (not yet supported),
-                //   window_size == input_size + MIN_LOOKAHEAD  &&
-                //   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
-                // Otherwise, window_size == 2*WSIZE so more >= 2.
-                // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
-
-                n = _codec.read_buf(window, strstart + lookahead, more);
-                lookahead += n;
-
-                // Initialize the hash value now that we have some input:
-                if (lookahead >= MIN_MATCH)
-                {
-                    ins_h = window[strstart] & 0xff;
-                    ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
-                }
-                // If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
-                // but this is not important since only literal bytes will be emitted.
-            }
-            while (lookahead < MIN_LOOKAHEAD && _codec.AvailableBytesIn != 0);
-        }
-
-        // Compress as much as possible from the input stream, return the current
-        // block state.
-        // This function does not perform lazy evaluation of matches and inserts
-        // new strings in the dictionary only for unmatched strings or for short
-        // matches. It is used only for the fast compression options.
-        internal BlockState DeflateFast(FlushType flush)
-        {
-            //    short hash_head = 0; // head of the hash chain
-            int hash_head = 0; // head of the hash chain
-            bool bflush; // set if current block must be flushed
-
-            while (true)
-            {
-                // Make sure that we always have enough lookahead, except
-                // at the end of the input file. We need MAX_MATCH bytes
-                // for the next match, plus MIN_MATCH bytes to insert the
-                // string following the next match.
-                if (lookahead < MIN_LOOKAHEAD)
-                {
-                    _fillWindow();
-                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
-                    {
-                        return BlockState.NeedMore;
-                    }
-                    if (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:
-                if (lookahead >= MIN_MATCH)
-                {
-                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
-
-                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
-                    hash_head = (head[ins_h] & 0xffff);
-                    prev[strstart & w_mask] = head[ins_h];
-                    head[ins_h] = unchecked((short)strstart);
-                }
-
-                // Find the longest match, discarding those <= prev_length.
-                // At this point we have always match_length < MIN_MATCH
-
-                if (hash_head != 0L && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
-                {
-                    // To simplify the code, we prevent matches with the string
-                    // 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 (compressionStrategy != CompressionStrategy.HuffmanOnly)
-                    {
-                        match_length = longest_match(hash_head);
-                    }
-                    // longest_match() sets match_start
-                }
-                if (match_length >= MIN_MATCH)
-                {
-                    //        check_match(strstart, match_start, match_length);
-
-                    bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
-
-                    lookahead -= match_length;
-
-                    // Insert new strings in the hash table only if the match length
-                    // is not too large. This saves time but degrades compression.
-                    if (match_length <= config.MaxLazy && lookahead >= MIN_MATCH)
-                    {
-                        match_length--; // string at strstart already in hash table
-                        do
-                        {
-                            strstart++;
-
-                            ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
-                            //      prev[strstart&w_mask]=hash_head=head[ins_h];
-                            hash_head = (head[ins_h] & 0xffff);
-                            prev[strstart & w_mask] = head[ins_h];
-                            head[ins_h] = unchecked((short)strstart);
-
-                            // strstart never exceeds WSIZE-MAX_MATCH, so there are
-                            // always MIN_MATCH bytes ahead.
-                        }
-                        while (--match_length != 0);
-                        strstart++;
-                    }
-                    else
-                    {
-                        strstart += match_length;
-                        match_length = 0;
-                        ins_h = window[strstart] & 0xff;
-
-                        ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
-                        // If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-                        // matter since it will be recomputed at next deflate call.
-                    }
-                }
-                else
-                {
-                    // No match, output a literal byte
-
-                    bflush = _tr_tally(0, window[strstart] & 0xff);
-                    lookahead--;
-                    strstart++;
-                }
-                if (bflush)
-                {
-                    flush_block_only(false);
-                    if (_codec.AvailableBytesOut == 0)
-                        return BlockState.NeedMore;
-                }
-            }
-
-            flush_block_only(flush == FlushType.Finish);
-            if (_codec.AvailableBytesOut == 0)
-            {
-                if (flush == FlushType.Finish)
-                    return BlockState.FinishStarted;
-                else
-                    return BlockState.NeedMore;
-            }
-            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
-        }
-
-        // Same as above, but achieves better compression. We use a lazy
-        // evaluation for matches: a match is finally adopted only if there is
-        // no better match at the next window position.
-        internal BlockState DeflateSlow(FlushType flush)
-        {
-            //    short hash_head = 0;    // head of hash chain
-            int hash_head = 0; // head of hash chain
-            bool bflush; // set if current block must be flushed
-
-            // Process the input block.
-            while (true)
-            {
-                // Make sure that we always have enough lookahead, except
-                // at the end of the input file. We need MAX_MATCH bytes
-                // for the next match, plus MIN_MATCH bytes to insert the
-                // string following the next match.
-
-                if (lookahead < MIN_LOOKAHEAD)
-                {
-                    _fillWindow();
-                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
-                        return BlockState.NeedMore;
-
-                    if (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:
-
-                if (lookahead >= MIN_MATCH)
-                {
-                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
-                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
-                    hash_head = (head[ins_h] & 0xffff);
-                    prev[strstart & w_mask] = head[ins_h];
-                    head[ins_h] = unchecked((short)strstart);
-                }
-
-                // Find the longest match, discarding those <= prev_length.
-                prev_length = match_length;
-                prev_match = match_start;
-                match_length = MIN_MATCH - 1;
-
-                if (hash_head != 0 && prev_length < config.MaxLazy &&
-                    ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
-                {
-                    // To simplify the code, we prevent matches with the string
-                    // 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 (compressionStrategy != CompressionStrategy.HuffmanOnly)
-                    {
-                        match_length = longest_match(hash_head);
-                    }
-                    // longest_match() sets match_start
-
-                    if (match_length <= 5 && (compressionStrategy == CompressionStrategy.Filtered ||
-                                              (match_length == MIN_MATCH && strstart - match_start > 4096)))
-                    {
-
-                        // If prev_match is also MIN_MATCH, match_start is garbage
-                        // but we will ignore the current match anyway.
-                        match_length = MIN_MATCH - 1;
-                    }
-                }
-
-                // If there was a match at the previous step and the current
-                // match is not better, output the previous match:
-                if (prev_length >= MIN_MATCH && match_length <= prev_length)
-                {
-                    int max_insert = strstart + lookahead - MIN_MATCH;
-                    // Do not insert strings in hash table beyond this.
-
-                    //          check_match(strstart-1, prev_match, prev_length);
-
-                    bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
-
-                    // Insert in hash table all strings up to the end of the match.
-                    // strstart-1 and strstart are already inserted. If there is not
-                    // enough lookahead, the last two strings are not inserted in
-                    // the hash table.
-                    lookahead -= (prev_length - 1);
-                    prev_length -= 2;
-                    do
-                    {
-                        if (++strstart <= max_insert)
-                        {
-                            ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
-                            //prev[strstart&w_mask]=hash_head=head[ins_h];
-                            hash_head = (head[ins_h] & 0xffff);
-                            prev[strstart & w_mask] = head[ins_h];
-                            head[ins_h] = unchecked((short)strstart);
-                        }
-                    }
-                    while (--prev_length != 0);
-                    match_available = 0;
-                    match_length = MIN_MATCH - 1;
-                    strstart++;
-
-                    if (bflush)
-                    {
-                        flush_block_only(false);
-                        if (_codec.AvailableBytesOut == 0)
-                            return BlockState.NeedMore;
-                    }
-                }
-                else if (match_available != 0)
-                {
-
-                    // If there was no match at the previous position, output a
-                    // single literal. If there was a match but the current match
-                    // is longer, truncate the previous match to a single literal.
-
-                    bflush = _tr_tally(0, window[strstart - 1] & 0xff);
-
-                    if (bflush)
-                    {
-                        flush_block_only(false);
-                    }
-                    strstart++;
-                    lookahead--;
-                    if (_codec.AvailableBytesOut == 0)
-                        return BlockState.NeedMore;
-                }
-                else
-                {
-                    // There is no previous match to compare with, wait for
-                    // the next step to decide.
-
-                    match_available = 1;
-                    strstart++;
-                    lookahead--;
-                }
-            }
-
-            if (match_available != 0)
-            {
-                bflush = _tr_tally(0, window[strstart - 1] & 0xff);
-                match_available = 0;
-            }
-            flush_block_only(flush == FlushType.Finish);
-
-            if (_codec.AvailableBytesOut == 0)
-            {
-                if (flush == FlushType.Finish)
-                    return BlockState.FinishStarted;
-                else
-                    return BlockState.NeedMore;
-            }
-
-            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
-        }
-
-
-        internal int longest_match(int cur_match)
-        {
-            int chain_length = config.MaxChainLength; // max hash chain length
-            int scan         = strstart;              // current string
-            int match;                                // matched string
-            int len;                                  // length of current match
-            int best_len     = prev_length;           // best match length so far
-            int limit        = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
-
-            int niceLength = config.NiceLength;
-
-            // Stop when cur_match becomes <= limit. To simplify the code,
-            // we prevent matches with the string of window index 0.
-
-            int wmask = w_mask;
-
-            int strend = strstart + MAX_MATCH;
-            byte scan_end1 = window[scan + best_len - 1];
-            byte scan_end = window[scan + best_len];
-
-            // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
-            // It is easy to get rid of this optimization if necessary.
-
-            // Do not waste too much time if we already have a good match:
-            if (prev_length >= config.GoodLength)
-            {
-                chain_length >>= 2;
-            }
-
-            // Do not look for matches beyond the end of the input. This is necessary
-            // to make deflate deterministic.
-            if (niceLength > lookahead)
-                niceLength = lookahead;
-
-            do
-            {
-                match = cur_match;
-
-                // Skip to next match if the match length cannot increase
-                // or if the match length is less than 2:
-                if (window[match + best_len] != scan_end ||
-                    window[match + best_len - 1] != scan_end1 ||
-                    window[match] != window[scan] ||
-                    window[++match] != window[scan + 1])
-                    continue;
-
-                // The check at best_len-1 can be removed because it will be made
-                // again later. (This heuristic is not always a win.)
-                // It is not necessary to compare scan[2] and match[2] since they
-                // are always equal when the other bytes match, given that
-                // the hash keys are equal and that HASH_BITS >= 8.
-                scan += 2; match++;
-
-                // We check for insufficient lookahead only every 8th comparison;
-                // the 256th check will be made at strstart+258.
-                do
-                {
-                }
-                while (window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] &&
-                       window[++scan] == window[++match] && scan < strend);
-
-                len = MAX_MATCH - (int)(strend - scan);
-                scan = strend - MAX_MATCH;
-
-                if (len > best_len)
-                {
-                    match_start = cur_match;
-                    best_len = len;
-                    if (len >= niceLength)
-                        break;
-                    scan_end1 = window[scan + best_len - 1];
-                    scan_end = window[scan + best_len];
-                }
-            }
-            while ((cur_match = (prev[cur_match & wmask] & 0xffff)) > limit && --chain_length != 0);
-
-            if (best_len <= lookahead)
-                return best_len;
-            return lookahead;
-        }
-
-
-        private bool Rfc1950BytesEmitted = false;
-        private bool _WantRfc1950HeaderBytes = true;
-        internal bool WantRfc1950HeaderBytes
-        {
-            get { return _WantRfc1950HeaderBytes; }
-            set { _WantRfc1950HeaderBytes = value; }
-        }
-
-
-        internal int Initialize(ZlibCodec codec, CompressionLevel level)
-        {
-            return Initialize(codec, level, ZlibConstants.WindowBitsMax);
-        }
-
-        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits)
-        {
-            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, CompressionStrategy.Default);
-        }
-
-        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits, CompressionStrategy compressionStrategy)
-        {
-            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, compressionStrategy);
-        }
-
-        internal int Initialize(ZlibCodec codec, CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
-        {
-            _codec = codec;
-            _codec.Message = null;
-
-            // validation
-            if (windowBits < 9 || windowBits > 15)
-                throw new ZlibException("windowBits must be in the range 9..15.");
-
-            if (memLevel < 1 || memLevel > MEM_LEVEL_MAX)
-                throw new ZlibException(String.Format("memLevel must be in the range 1.. {0}", MEM_LEVEL_MAX));
-
-            _codec.dstate = this;
-
-            w_bits = windowBits;
-            w_size = 1 << w_bits;
-            w_mask = w_size - 1;
-
-            hash_bits = memLevel + 7;
-            hash_size = 1 << hash_bits;
-            hash_mask = hash_size - 1;
-            hash_shift = ((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
-
-            window = new byte[w_size * 2];
-            prev = new short[w_size];
-            head = new short[hash_size];
-
-            // for memLevel==8, this will be 16384, 16k
-            lit_bufsize = 1 << (memLevel + 6);
-
-            // Use a single array as the buffer for data pending compression,
-            // the output distance codes, and the output length codes (aka tree).
-            // orig comment: This works just fine since the average
-            // output size for (length,distance) codes is <= 24 bits.
-            pending = new byte[lit_bufsize * 4];
-            _distanceOffset = lit_bufsize;
-            _lengthOffset = (1 + 2) * lit_bufsize;
-
-            // So, for memLevel 8, the length of the pending buffer is 65536. 64k.
-            // The first 16k are pending bytes.
-            // The middle slice, of 32k, is used for distance codes.
-            // The final 16k are length codes.
-
-            this.compressionLevel = level;
-            this.compressionStrategy = strategy;
-
-            Reset();
-            return ZlibConstants.Z_OK;
-        }
-
-
-        internal void Reset()
-        {
-            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
-            _codec.Message = null;
-            //strm.data_type = Z_UNKNOWN;
-
-            pendingCount = 0;
-            nextPending = 0;
-
-            Rfc1950BytesEmitted = false;
-
-            status = (WantRfc1950HeaderBytes) ? INIT_STATE : BUSY_STATE;
-            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
-
-            last_flush = (int)FlushType.None;
-
-            _InitializeTreeData();
-            _InitializeLazyMatch();
-        }
-
-
-        internal int End()
-        {
-            if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE)
-            {
-                return ZlibConstants.Z_STREAM_ERROR;
-            }
-            // Deallocate in reverse order of allocations:
-            pending = null;
-            head = null;
-            prev = null;
-            window = null;
-            // free
-            // dstate=null;
-            return status == BUSY_STATE ? ZlibConstants.Z_DATA_ERROR : ZlibConstants.Z_OK;
-        }
-
-
-        private void SetDeflater()
-        {
-            switch (config.Flavor)
-            {
-                case DeflateFlavor.Store:
-                    DeflateFunction = DeflateNone;
-                    break;
-                case DeflateFlavor.Fast:
-                    DeflateFunction = DeflateFast;
-                    break;
-                case DeflateFlavor.Slow:
-                    DeflateFunction = DeflateSlow;
-                    break;
-            }
-        }
-
-
-        internal int SetParams(CompressionLevel level, CompressionStrategy strategy)
-        {
-            int result = ZlibConstants.Z_OK;
-
-            if (compressionLevel != level)
-            {
-                Config newConfig = Config.Lookup(level);
-
-                // change in the deflate flavor (Fast vs slow vs none)?
-                if (newConfig.Flavor != config.Flavor && _codec.TotalBytesIn != 0)
-                {
-                    // Flush the last buffer:
-                    result = _codec.Deflate(FlushType.Partial);
-                }
-
-                compressionLevel = level;
-                config = newConfig;
-                SetDeflater();
-            }
-
-            // no need to flush with change in strategy?  Really?
-            compressionStrategy = strategy;
-
-            return result;
-        }
-
-
-        internal int SetDictionary(byte[] dictionary)
-        {
-            int length = dictionary.Length;
-            int index = 0;
-
-            if (dictionary == null || status != INIT_STATE)
-                throw new ZlibException("Stream error.");
-
-            _codec._Adler32 = Adler.Adler32(_codec._Adler32, dictionary, 0, dictionary.Length);
-
-            if (length < MIN_MATCH)
-                return ZlibConstants.Z_OK;
-            if (length > w_size - MIN_LOOKAHEAD)
-            {
-                length = w_size - MIN_LOOKAHEAD;
-                index = dictionary.Length - length; // use the tail of the dictionary
-            }
-            Array.Copy(dictionary, index, window, 0, length);
-            strstart = length;
-            block_start = length;
-
-            // Insert all strings in the hash table (except for the last two bytes).
-            // s->lookahead stays null, so s->ins_h will be recomputed at the next
-            // call of fill_window.
-
-            ins_h = window[0] & 0xff;
-            ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
-
-            for (int n = 0; n <= length - MIN_MATCH; n++)
-            {
-                ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
-                prev[n & w_mask] = head[ins_h];
-                head[ins_h] = (short)n;
-            }
-            return ZlibConstants.Z_OK;
-        }
-
-
-
-        internal int Deflate(FlushType flush)
-        {
-            int old_flush;
-
-            if (_codec.OutputBuffer == null ||
-                (_codec.InputBuffer == null && _codec.AvailableBytesIn != 0) ||
-                (status == FINISH_STATE && flush != FlushType.Finish))
-            {
-                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_STREAM_ERROR)];
-                throw new ZlibException(String.Format("Something is fishy. [{0}]", _codec.Message));
-            }
-            if (_codec.AvailableBytesOut == 0)
-            {
-                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
-                throw new ZlibException("OutputBuffer is full (AvailableBytesOut == 0)");
-            }
-
-            old_flush = last_flush;
-            last_flush = (int)flush;
-
-            // Write the zlib (rfc1950) header bytes
-            if (status == INIT_STATE)
-            {
-                int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
-                int level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
-
-                if (level_flags > 3)
-                    level_flags = 3;
-                header |= (level_flags << 6);
-                if (strstart != 0)
-                    header |= PRESET_DICT;
-                header += 31 - (header % 31);
-
-                status = BUSY_STATE;
-                //putShortMSB(header);
-                unchecked
-                {
-                    pending[pendingCount++] = (byte)(header >> 8);
-                    pending[pendingCount++] = (byte)header;
-                }
-                // Save the adler32 of the preset dictionary:
-                if (strstart != 0)
-                {
-                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
-                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
-                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
-                    pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
-                }
-                _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
-            }
-
-            // Flush as much pending output as possible
-            if (pendingCount != 0)
-            {
-                _codec.flush_pending();
-                if (_codec.AvailableBytesOut == 0)
-                {
-                    //System.out.println("  avail_out==0");
-                    // Since avail_out is 0, deflate will be called again with
-                    // more output space, but possibly with both pending and
-                    // avail_in equal to zero. There won't be anything to do,
-                    // but this is not an error situation so make sure we
-                    // return OK instead of BUF_ERROR at next call of deflate:
-                    last_flush = -1;
-                    return ZlibConstants.Z_OK;
-                }
-
-                // Make sure there is something to do and avoid duplicate consecutive
-                // flushes. For repeated and useless calls with Z_FINISH, we keep
-                // returning Z_STREAM_END instead of Z_BUFF_ERROR.
-            }
-            else if (_codec.AvailableBytesIn == 0 &&
-                     (int)flush <= old_flush &&
-                     flush != FlushType.Finish)
-            {
-                // workitem 8557
-                //
-                // Not sure why this needs to be an error.  pendingCount == 0, which
-                // means there's nothing to deflate.  And the caller has not asked
-                // for a FlushType.Finish, but...  that seems very non-fatal.  We
-                // can just say "OK" and do nothing.
-
-                // _codec.Message = z_errmsg[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
-                // throw new ZlibException("AvailableBytesIn == 0 && flush<=old_flush && flush != FlushType.Finish");
-
-                return ZlibConstants.Z_OK;
-            }
-
-            // User must not provide more input after the first FINISH:
-            if (status == FINISH_STATE && _codec.AvailableBytesIn != 0)
-            {
-                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
-                throw new ZlibException("status == FINISH_STATE && _codec.AvailableBytesIn != 0");
-            }
-
-            // Start a new block or continue the current one.
-            if (_codec.AvailableBytesIn != 0 || lookahead != 0 || (flush != FlushType.None && status != FINISH_STATE))
-            {
-                BlockState bstate = DeflateFunction(flush);
-
-                if (bstate == BlockState.FinishStarted || bstate == BlockState.FinishDone)
-                {
-                    status = FINISH_STATE;
-                }
-                if (bstate == BlockState.NeedMore || bstate == BlockState.FinishStarted)
-                {
-                    if (_codec.AvailableBytesOut == 0)
-                    {
-                        last_flush = -1; // avoid BUF_ERROR next call, see above
-                    }
-                    return ZlibConstants.Z_OK;
-                    // If flush != Z_NO_FLUSH && avail_out == 0, the next call
-                    // of deflate should use the same flush parameter to make sure
-                    // that the flush is complete. So we don't have to output an
-                    // empty block here, this will be done at next call. This also
-                    // ensures that for a very small output buffer, we emit at most
-                    // one empty block.
-                }
-
-                if (bstate == BlockState.BlockDone)
-                {
-                    if (flush == FlushType.Partial)
-                    {
-                        _tr_align();
-                    }
-                    else
-                    {
-                        // FlushType.Full or FlushType.Sync
-                        _tr_stored_block(0, 0, false);
-                        // For a full flush, this empty block will be recognized
-                        // as a special marker by inflate_sync().
-                        if (flush == FlushType.Full)
-                        {
-                            // clear hash (forget the history)
-                            for (int i = 0; i < hash_size; i++)
-                                head[i] = 0;
-                        }
-                    }
-                    _codec.flush_pending();
-                    if (_codec.AvailableBytesOut == 0)
-                    {
-                        last_flush = -1; // avoid BUF_ERROR at next call, see above
-                        return ZlibConstants.Z_OK;
-                    }
-                }
-            }
-
-            if (flush != FlushType.Finish)
-                return ZlibConstants.Z_OK;
-
-            if (!WantRfc1950HeaderBytes || Rfc1950BytesEmitted)
-                return ZlibConstants.Z_STREAM_END;
-
-            // Write the zlib trailer (adler32)
-            pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
-            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
-            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
-            pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
-            //putShortMSB((int)(SharedUtils.URShift(_codec._Adler32, 16)));
-            //putShortMSB((int)(_codec._Adler32 & 0xffff));
-
-            _codec.flush_pending();
-
-            // If avail_out is zero, the application will call deflate again
-            // to flush the rest.
-
-            Rfc1950BytesEmitted = true; // write the trailer only once!
-
-            return pendingCount != 0 ? ZlibConstants.Z_OK : ZlibConstants.Z_STREAM_END;
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/DeflateStream.cs b/EPPlus/Packaging/DotNetZip/Zlib/DeflateStream.cs
deleted file mode 100644
index c846469..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/DeflateStream.cs
+++ /dev/null
@@ -1,740 +0,0 @@
-// DeflateStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2010 Dino Chiesa.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-31 14:48:11>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the DeflateStream class, which can be used as a replacement for
-// the System.IO.Compression.DeflateStream class in the .NET BCL.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    /// <summary>
-    /// A class for compressing and decompressing streams using the Deflate algorithm.
-    /// </summary>
-    ///
-    /// <remarks>
-    ///
-    /// <para>
-    ///   The DeflateStream is a <see
-    ///   href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
-    ///   cref="System.IO.Stream"/>.  It adds DEFLATE compression or decompression to any
-    ///   stream.
-    /// </para>
-    ///
-    /// <para>
-    ///   Using this stream, applications can compress or decompress data via stream
-    ///   <c>Read</c> and <c>Write</c> operations.  Either compresssion or decompression
-    ///   can occur through either reading or writing. The compression format used is
-    ///   DEFLATE, which is documented in <see
-    ///   href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
-    ///   Compressed Data Format Specification version 1.3.".
-    /// </para>
-    ///
-    /// <para>
-    ///   This class is similar to <see cref="ZlibStream"/>, except that
-    ///   <c>ZlibStream</c> adds the <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
-    ///   1950 - ZLIB</see> framing bytes to a compressed stream when compressing, or
-    ///   expects the RFC1950 framing bytes when decompressing. The <c>DeflateStream</c>
-    ///   does not.
-    /// </para>
-    ///
-    /// </remarks>
-    ///
-    /// <seealso cref="ZlibStream" />
-    /// <seealso cref="GZipStream" />
-    public class DeflateStream : System.IO.Stream
-    {
-        internal ZlibBaseStream _baseStream;
-        internal System.IO.Stream _innerStream;
-        bool _disposed;
-
-        /// <summary>
-        ///   Create a DeflateStream using the specified CompressionMode.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   When mode is <c>CompressionMode.Compress</c>, the DeflateStream will use
-        ///   the default compression level. The "captive" stream will be closed when
-        ///   the DeflateStream is closed.
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example uses a DeflateStream to compress data from a file, and writes
-        /// the compressed data to another file.
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
-        ///     {
-        ///         using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
-        ///         Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream which will be read or written.</param>
-        /// <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
-        public DeflateStream(System.IO.Stream stream, CompressionMode mode)
-            : this(stream, mode, CompressionLevel.Default, false)
-        {
-        }
-
-        /// <summary>
-        /// Create a DeflateStream using the specified CompressionMode and the specified CompressionLevel.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
-        ///   ignored.  The "captive" stream will be closed when the DeflateStream is
-        ///   closed.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example uses a DeflateStream to compress data from a file, and writes
-        ///   the compressed data to another file.
-        ///
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
-        ///     {
-        ///         using (Stream compressor = new DeflateStream(raw,
-        ///                                                      CompressionMode.Compress,
-        ///                                                      CompressionLevel.BestCompression))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n= -1;
-        ///             while (n != 0)
-        ///             {
-        ///                 if (n &gt; 0)
-        ///                     compressor.Write(buffer, 0, n);
-        ///                 n= input.Read(buffer, 0, buffer.Length);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
-        ///         Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
-        /// <param name="mode">Indicates whether the <c>DeflateStream</c> will compress or decompress.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
-            : this(stream, mode, level, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>DeflateStream</c> using the specified
-        ///   <c>CompressionMode</c>, and explicitly specify whether the
-        ///   stream should be left open after Deflation or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This constructor allows the application to request that the captive stream
-        ///   remain open after the deflation or inflation occurs.  By default, after
-        ///   <c>Close()</c> is called on the stream, the captive stream is also
-        ///   closed. In some cases this is not desired, for example if the stream is a
-        ///   memory stream that will be re-read after compression.  Specify true for
-        ///   the <paramref name="leaveOpen"/> parameter to leave the stream open.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <c>DeflateStream</c> will use the default compression level.
-        /// </para>
-        ///
-        /// <para>
-        ///   See the other overloads of this constructor for example code.
-        /// </para>
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The stream which will be read or written. This is called the
-        ///   "captive" stream in other places in this documentation.
-        /// </param>
-        ///
-        /// <param name="mode">
-        ///   Indicates whether the <c>DeflateStream</c> will compress or decompress.
-        /// </param>
-        ///
-        /// <param name="leaveOpen">true if the application would like the stream to
-        /// remain open after inflation/deflation.</param>
-        public DeflateStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
-            : this(stream, mode, CompressionLevel.Default, leaveOpen)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>DeflateStream</c> using the specified <c>CompressionMode</c>
-        ///   and the specified <c>CompressionLevel</c>, and explicitly specify whether
-        ///   the stream should be left open after Deflation or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
-        /// </para>
-        ///
-        /// <para>
-        ///   This constructor allows the application to request that the captive stream
-        ///   remain open after the deflation or inflation occurs.  By default, after
-        ///   <c>Close()</c> is called on the stream, the captive stream is also
-        ///   closed. In some cases this is not desired, for example if the stream is a
-        ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
-        ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter
-        ///   to leave the stream open.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        ///   This example shows how to use a <c>DeflateStream</c> to compress data from
-        ///   a file, and store the compressed data into another file.
-        ///
-        /// <code>
-        /// using (var output = System.IO.File.Create(fileToCompress + ".deflated"))
-        /// {
-        ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        ///     {
-        ///         using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n= -1;
-        ///             while (n != 0)
-        ///             {
-        ///                 if (n &gt; 0)
-        ///                     compressor.Write(buffer, 0, n);
-        ///                 n= input.Read(buffer, 0, buffer.Length);
-        ///             }
-        ///         }
-        ///     }
-        ///     // can write additional data to the output stream here
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using output As FileStream = File.Create(fileToCompress &amp; ".deflated")
-        ///     Using input As Stream = File.OpenRead(fileToCompress)
-        ///         Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        ///     ' can write additional data to the output stream here.
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream which will be read or written.</param>
-        /// <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
-        /// <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
-        {
-            _innerStream = stream;
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen);
-        }
-
-        #region Zlib properties
-
-        /// <summary>
-        /// This property sets the flush behavior on the stream.
-        /// </summary>
-        /// <remarks> See the ZLIB documentation for the meaning of the flush behavior.
-        /// </remarks>
-        virtual public FlushType FlushMode
-        {
-            get { return (this._baseStream._flushMode); }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("DeflateStream");
-                this._baseStream._flushMode = value;
-            }
-        }
-
-        /// <summary>
-        ///   The size of the working buffer for the compression codec.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The working buffer is used for all stream operations.  The default size is
-        ///   1024 bytes.  The minimum size is 128 bytes. You may get better performance
-        ///   with a larger buffer.  Then again, you might not.  You would have to test
-        ///   it.
-        /// </para>
-        ///
-        /// <para>
-        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
-        ///   stream. If you try to set it afterwards, it will throw.
-        /// </para>
-        /// </remarks>
-        public int BufferSize
-        {
-            get
-            {
-                return this._baseStream._bufferSize;
-            }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("DeflateStream");
-                if (this._baseStream._workingBuffer != null)
-                    throw new ZlibException("The working buffer is already set.");
-                if (value < ZlibConstants.WorkingBufferSizeMin)
-                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
-                this._baseStream._bufferSize = value;
-            }
-        }
-
-        /// <summary>
-        ///   The ZLIB strategy to be used during compression.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   By tweaking this parameter, you may be able to optimize the compression for
-        ///   data with particular characteristics.
-        /// </remarks>
-        public CompressionStrategy Strategy
-        {
-            get
-            {
-                return this._baseStream.Strategy;
-            }
-            set
-            {
-            if (_disposed) throw new ObjectDisposedException("DeflateStream");
-                this._baseStream.Strategy = value;
-            }
-        }
-
-        /// <summary> Returns the total number of bytes input so far.</summary>
-        virtual public long TotalIn
-        {
-            get
-            {
-                return this._baseStream._z.TotalBytesIn;
-            }
-        }
-
-        /// <summary> Returns the total number of bytes output so far.</summary>
-        virtual public long TotalOut
-        {
-            get
-            {
-                return this._baseStream._z.TotalBytesOut;
-            }
-        }
-
-        #endregion
-
-        #region System.IO.Stream methods
-        /// <summary>
-        ///   Dispose the stream.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This may or may not result in a <c>Close()</c> call on the captive
-        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
-        ///     for more information.
-        ///   </para>
-        ///   <para>
-        ///     Application code won't call this code directly.  This method may be
-        ///     invoked in two distinct scenarios.  If disposing == true, the method
-        ///     has been called directly or indirectly by a user's code, for example
-        ///     via the public Dispose() method. In this case, both managed and
-        ///     unmanaged resources can be referenced and disposed.  If disposing ==
-        ///     false, the method has been called by the runtime from inside the
-        ///     object finalizer and this method should not reference other objects;
-        ///     in that case only unmanaged resources must be referenced or
-        ///     disposed.
-        ///   </para>
-        /// </remarks>
-        /// <param name="disposing">
-        ///   true if the Dispose method was invoked by user code.
-        /// </param>
-        protected override void Dispose(bool disposing)
-        {
-            try
-            {
-                if (!_disposed)
-                {
-                    if (disposing && (this._baseStream != null))
-                        this._baseStream.Close();
-                    _disposed = true;
-                }
-            }
-            finally
-            {
-                base.Dispose(disposing);
-            }
-        }
-
-
-
-        /// <summary>
-        /// Indicates whether the stream can be read.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports reading.
-        /// </remarks>
-        public override bool CanRead
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("DeflateStream");
-                return _baseStream._stream.CanRead;
-            }
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports Seek operations.
-        /// </summary>
-        /// <remarks>
-        /// Always returns false.
-        /// </remarks>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the stream can be written.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports writing.
-        /// </remarks>
-        public override bool CanWrite
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("DeflateStream");
-                return _baseStream._stream.CanWrite;
-            }
-        }
-
-        /// <summary>
-        /// Flush the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            if (_disposed) throw new ObjectDisposedException("DeflateStream");
-            _baseStream.Flush();
-        }
-
-        /// <summary>
-        /// Reading this property always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        public override long Length
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        /// The position of the stream pointer.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Setting this property always throws a <see
-        ///   cref="NotImplementedException"/>. Reading will return the total bytes
-        ///   written out, if used in writing, or the total bytes read in, if used in
-        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
-        ///   depending on how you've used the stream.
-        /// </remarks>
-        public override long Position
-        {
-            get
-            {
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Writer)
-                    return this._baseStream._z.TotalBytesOut;
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Reader)
-                    return this._baseStream._z.TotalBytesIn;
-                return 0;
-            }
-            set { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        /// Read data from the stream.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If you wish to use the <c>DeflateStream</c> to compress data while
-        ///   reading, you can create a <c>DeflateStream</c> with
-        ///   <c>CompressionMode.Compress</c>, providing an uncompressed data stream.
-        ///   Then call Read() on that <c>DeflateStream</c>, and the data read will be
-        ///   compressed as you read.  If you wish to use the <c>DeflateStream</c> to
-        ///   decompress data while reading, you can create a <c>DeflateStream</c> with
-        ///   <c>CompressionMode.Decompress</c>, providing a readable compressed data
-        ///   stream.  Then call Read() on that <c>DeflateStream</c>, and the data read
-        ///   will be decompressed as you read.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <param name="buffer">The buffer into which the read data should be placed.</param>
-        /// <param name="offset">the offset within that data array to put the first byte read.</param>
-        /// <param name="count">the number of bytes to read.</param>
-        /// <returns>the number of bytes actually read</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_disposed) throw new ObjectDisposedException("DeflateStream");
-            return _baseStream.Read(buffer, offset, count);
-        }
-
-
-        /// <summary>
-        /// Calling this method always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        /// <param name="offset">this is irrelevant, since it will always throw!</param>
-        /// <param name="origin">this is irrelevant, since it will always throw!</param>
-        /// <returns>irrelevant!</returns>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        /// Calling this method always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        /// <param name="value">this is irrelevant, since it will always throw!</param>
-        public override void SetLength(long value)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        ///   Write data to the stream.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If you wish to use the <c>DeflateStream</c> to compress data while
-        ///   writing, you can create a <c>DeflateStream</c> with
-        ///   <c>CompressionMode.Compress</c>, and a writable output stream.  Then call
-        ///   <c>Write()</c> on that <c>DeflateStream</c>, providing uncompressed data
-        ///   as input.  The data sent to the output stream will be the compressed form
-        ///   of the data written.  If you wish to use the <c>DeflateStream</c> to
-        ///   decompress data while writing, you can create a <c>DeflateStream</c> with
-        ///   <c>CompressionMode.Decompress</c>, and a writable output stream.  Then
-        ///   call <c>Write()</c> on that stream, providing previously compressed
-        ///   data. The data sent to the output stream will be the decompressed form of
-        ///   the data written.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>,
-        ///   but not both.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (_disposed) throw new ObjectDisposedException("DeflateStream");
-            _baseStream.Write(buffer, offset, count);
-        }
-        #endregion
-
-
-
-
-        /// <summary>
-        ///   Compress a string into a byte array using DEFLATE (RFC 1951).
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="DeflateStream.UncompressString(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
-        /// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
-        /// <seealso cref="GZipStream.CompressString(string)">GZipStream.CompressString(string)</seealso>
-        /// <seealso cref="ZlibStream.CompressString(string)">ZlibStream.CompressString(string)</seealso>
-        ///
-        /// <param name="s">
-        ///   A string to compress. The string will first be encoded
-        ///   using UTF8, then compressed.
-        /// </param>
-        ///
-        /// <returns>The string in compressed form</returns>
-        public static byte[] CompressString(String s)
-        {
-            using (var ms = new System.IO.MemoryStream())
-            {
-                System.IO.Stream compressor =
-                    new DeflateStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
-                ZlibBaseStream.CompressString(s, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Compress a byte array into a new byte array using DEFLATE.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="DeflateStream.UncompressBuffer(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="DeflateStream.CompressString(string)">DeflateStream.CompressString(string)</seealso>
-        /// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>
-        /// <seealso cref="GZipStream.CompressBuffer(byte[])">GZipStream.CompressBuffer(byte[])</seealso>
-        /// <seealso cref="ZlibStream.CompressBuffer(byte[])">ZlibStream.CompressBuffer(byte[])</seealso>
-        ///
-        /// <param name="b">
-        ///   A buffer to compress.
-        /// </param>
-        ///
-        /// <returns>The data in compressed form</returns>
-        public static byte[] CompressBuffer(byte[] b)
-        {
-            using (var ms = new System.IO.MemoryStream())
-            {
-                System.IO.Stream compressor =
-                    new DeflateStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
-
-                ZlibBaseStream.CompressBuffer(b, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a DEFLATE'd byte array into a single string.
-        /// </summary>
-        ///
-        /// <seealso cref="DeflateStream.CompressString(String)">DeflateStream.CompressString(String)</seealso>
-        /// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>
-        /// <seealso cref="GZipStream.UncompressString(byte[])">GZipStream.UncompressString(byte[])</seealso>
-        /// <seealso cref="ZlibStream.UncompressString(byte[])">ZlibStream.UncompressString(byte[])</seealso>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing DEFLATE-compressed data.
-        /// </param>
-        ///
-        /// <returns>The uncompressed string</returns>
-        public static String UncompressString(byte[] compressed)
-        {
-            using (var input = new System.IO.MemoryStream(compressed))
-            {
-                System.IO.Stream decompressor =
-                    new DeflateStream(input, CompressionMode.Decompress);
-
-                return ZlibBaseStream.UncompressString(compressed, decompressor);
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a DEFLATE'd byte array into a byte array.
-        /// </summary>
-        ///
-        /// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
-        /// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
-        /// <seealso cref="GZipStream.UncompressBuffer(byte[])">GZipStream.UncompressBuffer(byte[])</seealso>
-        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])">ZlibStream.UncompressBuffer(byte[])</seealso>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing data that has been compressed with DEFLATE.
-        /// </param>
-        ///
-        /// <returns>The data in uncompressed form</returns>
-        public static byte[] UncompressBuffer(byte[] compressed)
-        {
-            using (var input = new System.IO.MemoryStream(compressed))
-            {
-                System.IO.Stream decompressor =
-                    new DeflateStream( input, CompressionMode.Decompress );
-
-                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
-            }
-        }
-
-    }
-
-}
-
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/GZipStream.cs b/EPPlus/Packaging/DotNetZip/Zlib/GZipStream.cs
deleted file mode 100644
index a83a496..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/GZipStream.cs
+++ /dev/null
@@ -1,1033 +0,0 @@
-// GZipStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-08 18:14:39>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the GZipStream class, which can be used as a replacement for
-// the System.IO.Compression.GZipStream class in the .NET BCL.  NB: The design is not
-// completely OO clean: there is some intelligence in the ZlibBaseStream that reads the
-// GZip header.
-//
-// ------------------------------------------------------------------
-
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    /// <summary>
-    ///   A class for compressing and decompressing GZIP streams.
-    /// </summary>
-    /// <remarks>
-    ///
-    /// <para>
-    ///   The <c>GZipStream</c> is a <see
-    ///   href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a
-    ///   <see cref="Stream"/>. It adds GZIP compression or decompression to any
-    ///   stream.
-    /// </para>
-    ///
-    /// <para>
-    ///   Like the <c>System.IO.Compression.GZipStream</c> in the .NET Base Class Library, the
-    ///   <c>Ionic.Zlib.GZipStream</c> can compress while writing, or decompress while
-    ///   reading, but not vice versa.  The compression method used is GZIP, which is
-    ///   documented in <see href="http://www.ietf.org/rfc/rfc1952.txt">IETF RFC
-    ///   1952</see>, "GZIP file format specification version 4.3".</para>
-    ///
-    /// <para>
-    ///   A <c>GZipStream</c> can be used to decompress data (through <c>Read()</c>) or
-    ///   to compress data (through <c>Write()</c>), but not both.
-    /// </para>
-    ///
-    /// <para>
-    ///   If you wish to use the <c>GZipStream</c> to compress data, you must wrap it
-    ///   around a write-able stream. As you call <c>Write()</c> on the <c>GZipStream</c>, the
-    ///   data will be compressed into the GZIP format.  If you want to decompress data,
-    ///   you must wrap the <c>GZipStream</c> around a readable stream that contains an
-    ///   IETF RFC 1952-compliant stream.  The data will be decompressed as you call
-    ///   <c>Read()</c> on the <c>GZipStream</c>.
-    /// </para>
-    ///
-    /// <para>
-    ///   Though the GZIP format allows data from multiple files to be concatenated
-    ///   together, this stream handles only a single segment of GZIP format, typically
-    ///   representing a single file.
-    /// </para>
-    ///
-    /// <para>
-    ///   This class is similar to <see cref="ZlibStream"/> and <see cref="DeflateStream"/>.
-    ///   <c>ZlibStream</c> handles RFC1950-compliant streams.  <see cref="DeflateStream"/>
-    ///   handles RFC1951-compliant streams. This class handles RFC1952-compliant streams.
-    /// </para>
-    ///
-    /// </remarks>
-    ///
-    /// <seealso cref="DeflateStream" />
-    /// <seealso cref="ZlibStream" />
-    public class GZipStream : System.IO.Stream
-    {
-        // GZip format
-        // source: http://tools.ietf.org/html/rfc1952
-        //
-        //  header id:           2 bytes    1F 8B
-        //  compress method      1 byte     8= DEFLATE (none other supported)
-        //  flag                 1 byte     bitfield (See below)
-        //  mtime                4 bytes    time_t (seconds since jan 1, 1970 UTC of the file.
-        //  xflg                 1 byte     2 = max compress used , 4 = max speed (can be ignored)
-        //  OS                   1 byte     OS for originating archive. set to 0xFF in compression.
-        //  extra field length   2 bytes    optional - only if FEXTRA is set.
-        //  extra field          varies
-        //  filename             varies     optional - if FNAME is set.  zero terminated. ISO-8859-1.
-        //  file comment         varies     optional - if FCOMMENT is set. zero terminated. ISO-8859-1.
-        //  crc16                1 byte     optional - present only if FHCRC bit is set
-        //  compressed data      varies
-        //  CRC32                4 bytes
-        //  isize                4 bytes    data size modulo 2^32
-        //
-        //     FLG (FLaGs)
-        //                bit 0   FTEXT - indicates file is ASCII text (can be safely ignored)
-        //                bit 1   FHCRC - there is a CRC16 for the header immediately following the header
-        //                bit 2   FEXTRA - extra fields are present
-        //                bit 3   FNAME - the zero-terminated filename is present. encoding; ISO-8859-1.
-        //                bit 4   FCOMMENT  - a zero-terminated file comment is present. encoding: ISO-8859-1
-        //                bit 5   reserved
-        //                bit 6   reserved
-        //                bit 7   reserved
-        //
-        // On consumption:
-        // Extra field is a bunch of nonsense and can be safely ignored.
-        // Header CRC and OS, likewise.
-        //
-        // on generation:
-        // all optional fields get 0, except for the OS, which gets 255.
-        //
-
-
-
-        /// <summary>
-        ///   The comment on the GZIP stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The GZIP format allows for each file to optionally have an associated
-        ///   comment stored with the file.  The comment is encoded with the ISO-8859-1
-        ///   code page.  To include a comment in a GZIP stream you create, set this
-        ///   property before calling <c>Write()</c> for the first time on the
-        ///   <c>GZipStream</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   When using <c>GZipStream</c> to decompress, you can retrieve this property
-        ///   after the first call to <c>Read()</c>.  If no comment has been set in the
-        ///   GZIP bytestream, the Comment property will return <c>null</c>
-        ///   (<c>Nothing</c> in VB).
-        /// </para>
-        /// </remarks>
-        public String Comment
-        {
-            get
-            {
-                return _Comment;
-            }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                _Comment = value;
-            }
-        }
-
-        /// <summary>
-        ///   The FileName for the GZIP stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The GZIP format optionally allows each file to have an associated
-        ///   filename.  When compressing data (through <c>Write()</c>), set this
-        ///   FileName before calling <c>Write()</c> the first time on the <c>GZipStream</c>.
-        ///   The actual filename is encoded into the GZIP bytestream with the
-        ///   ISO-8859-1 code page, according to RFC 1952. It is the application's
-        ///   responsibility to insure that the FileName can be encoded and decoded
-        ///   correctly with this code page.
-        /// </para>
-        ///
-        /// <para>
-        ///   When decompressing (through <c>Read()</c>), you can retrieve this value
-        ///   any time after the first <c>Read()</c>.  In the case where there was no filename
-        ///   encoded into the GZIP bytestream, the property will return <c>null</c> (<c>Nothing</c>
-        ///   in VB).
-        /// </para>
-        /// </remarks>
-        public String FileName
-        {
-            get { return _FileName; }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                _FileName = value;
-                if (_FileName == null) return;
-                if (_FileName.IndexOf("/") != -1)
-                {
-                    _FileName = _FileName.Replace("/", "\\");
-                }
-                if (_FileName.EndsWith("\\"))
-                    throw new Exception("Illegal filename");
-                if (_FileName.IndexOf("\\") != -1)
-                {
-                    // trim any leading path
-                    _FileName = Path.GetFileName(_FileName);
-                }
-            }
-        }
-
-        /// <summary>
-        ///   The last modified time for the GZIP stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   GZIP allows the storage of a last modified time with each GZIP entry.
-        ///   When compressing data, you can set this before the first call to
-        ///   <c>Write()</c>.  When decompressing, you can retrieve this value any time
-        ///   after the first call to <c>Read()</c>.
-        /// </remarks>
-        public DateTime? LastModified;
-
-        /// <summary>
-        /// The CRC on the GZIP stream.
-        /// </summary>
-        /// <remarks>
-        /// This is used for internal error checking. You probably don't need to look at this property.
-        /// </remarks>
-        public int Crc32 { get { return _Crc32; } }
-
-        private int _headerByteCount;
-        internal ZlibBaseStream _baseStream;
-        bool _disposed;
-        bool _firstReadDone;
-        string _FileName;
-        string _Comment;
-        int _Crc32;
-
-
-        /// <summary>
-        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Compress</c>, the <c>GZipStream</c> will use the
-        ///   default compression level.
-        /// </para>
-        ///
-        /// <para>
-        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
-        ///   or Decompress) also establishes the "direction" of the stream.  A
-        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
-        ///   <c>Write()</c>.  A <c>GZipStream</c> with
-        ///   <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example shows how to use a GZipStream to compress data.
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(outputFile))
-        ///     {
-        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(outputFile)
-        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)
-        ///         Dim buffer As Byte() = New Byte(4096) {}
-        ///         Dim n As Integer = -1
-        ///         Do While (n &lt;&gt; 0)
-        ///             If (n &gt; 0) Then
-        ///                 compressor.Write(buffer, 0, n)
-        ///             End If
-        ///             n = input.Read(buffer, 0, buffer.Length)
-        ///         Loop
-        ///     End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <example>
-        /// This example shows how to use a GZipStream to uncompress a file.
-        /// <code>
-        /// private void GunZipFile(string filename)
-        /// {
-        ///     if (!filename.EndsWith(".gz))
-        ///         throw new ArgumentException("filename");
-        ///     var DecompressedFile = filename.Substring(0,filename.Length-3);
-        ///     byte[] working = new byte[WORKING_BUFFER_SIZE];
-        ///     int n= 1;
-        ///     using (System.IO.Stream input = System.IO.File.OpenRead(filename))
-        ///     {
-        ///         using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
-        ///         {
-        ///             using (var output = System.IO.File.Create(DecompressedFile))
-        ///             {
-        ///                 while (n !=0)
-        ///                 {
-        ///                     n= decompressor.Read(working, 0, working.Length);
-        ///                     if (n > 0)
-        ///                     {
-        ///                         output.Write(working, 0, n);
-        ///                     }
-        ///                 }
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Private Sub GunZipFile(ByVal filename as String)
-        ///     If Not (filename.EndsWith(".gz)) Then
-        ///         Throw New ArgumentException("filename")
-        ///     End If
-        ///     Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)
-        ///     Dim working(WORKING_BUFFER_SIZE) as Byte
-        ///     Dim n As Integer = 1
-        ///     Using input As Stream = File.OpenRead(filename)
-        ///         Using decompressor As Stream = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, True)
-        ///             Using output As Stream = File.Create(UncompressedFile)
-        ///                 Do
-        ///                     n= decompressor.Read(working, 0, working.Length)
-        ///                     If n > 0 Then
-        ///                         output.Write(working, 0, n)
-        ///                     End IF
-        ///                 Loop While (n  > 0)
-        ///             End Using
-        ///         End Using
-        ///     End Using
-        /// End Sub
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="stream">The stream which will be read or written.</param>
-        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
-        public GZipStream(Stream stream, CompressionMode mode)
-            : this(stream, mode, CompressionLevel.Default, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and
-        ///   the specified <c>CompressionLevel</c>.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The <c>CompressionMode</c> (Compress or Decompress) also establishes the
-        ///   "direction" of the stream.  A <c>GZipStream</c> with
-        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A
-        ///   <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
-        ///   through <c>Read()</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        /// This example shows how to use a <c>GZipStream</c> to compress a file into a .gz file.
-        ///
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(fileToCompress + ".gz"))
-        ///     {
-        ///         using (Stream compressor = new GZipStream(raw,
-        ///                                                   CompressionMode.Compress,
-        ///                                                   CompressionLevel.BestCompression))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".gz")
-        ///         Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
-        /// <param name="mode">Indicates whether the <c>GZipStream</c> will compress or decompress.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level)
-            : this(stream, mode, level, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>, and
-        ///   explicitly specify whether the stream should be left open after Deflation
-        ///   or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This constructor allows the application to request that the captive stream
-        ///   remain open after the deflation or inflation occurs.  By default, after
-        ///   <c>Close()</c> is called on the stream, the captive stream is also
-        ///   closed. In some cases this is not desired, for example if the stream is a
-        ///   memory stream that will be re-read after compressed data has been written
-        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to leave
-        ///   the stream open.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <see cref="CompressionMode"/> (Compress or Decompress) also
-        ///   establishes the "direction" of the stream.  A <c>GZipStream</c> with
-        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A <c>GZipStream</c>
-        ///   with <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
-        /// </para>
-        ///
-        /// <para>
-        ///   The <c>GZipStream</c> will use the default compression level. If you want
-        ///   to specify the compression level, see <see cref="GZipStream(Stream,
-        ///   CompressionMode, CompressionLevel, bool)"/>.
-        /// </para>
-        ///
-        /// <para>
-        ///   See the other overloads of this constructor for example code.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The stream which will be read or written. This is called the "captive"
-        ///   stream in other places in this documentation.
-        /// </param>
-        ///
-        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.
-        /// </param>
-        ///
-        /// <param name="leaveOpen">
-        ///   true if the application would like the base stream to remain open after
-        ///   inflation/deflation.
-        /// </param>
-        public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
-            : this(stream, mode, CompressionLevel.Default, leaveOpen)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and the
-        ///   specified <c>CompressionLevel</c>, and explicitly specify whether the
-        ///   stream should be left open after Deflation or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This constructor allows the application to request that the captive stream
-        ///   remain open after the deflation or inflation occurs.  By default, after
-        ///   <c>Close()</c> is called on the stream, the captive stream is also
-        ///   closed. In some cases this is not desired, for example if the stream is a
-        ///   memory stream that will be re-read after compressed data has been written
-        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to
-        ///   leave the stream open.
-        /// </para>
-        ///
-        /// <para>
-        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
-        ///   or Decompress) also establishes the "direction" of the stream.  A
-        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
-        ///   <c>Write()</c>.  A <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
-        ///   through <c>Read()</c>.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example shows how to use a <c>GZipStream</c> to compress data.
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(outputFile))
-        ///     {
-        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(outputFile)
-        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)
-        ///         Dim buffer As Byte() = New Byte(4096) {}
-        ///         Dim n As Integer = -1
-        ///         Do While (n &lt;&gt; 0)
-        ///             If (n &gt; 0) Then
-        ///                 compressor.Write(buffer, 0, n)
-        ///             End If
-        ///             n = input.Read(buffer, 0, buffer.Length)
-        ///         Loop
-        ///     End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream which will be read or written.</param>
-        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
-        /// <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
-        {
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
-        }
-
-        #region Zlib properties
-
-        /// <summary>
-        /// This property sets the flush behavior on the stream.
-        /// </summary>
-        virtual public FlushType FlushMode
-        {
-            get { return (this._baseStream._flushMode); }
-            set {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                this._baseStream._flushMode = value;
-            }
-        }
-
-        /// <summary>
-        ///   The size of the working buffer for the compression codec.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The working buffer is used for all stream operations.  The default size is
-        ///   1024 bytes.  The minimum size is 128 bytes. You may get better performance
-        ///   with a larger buffer.  Then again, you might not.  You would have to test
-        ///   it.
-        /// </para>
-        ///
-        /// <para>
-        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
-        ///   stream. If you try to set it afterwards, it will throw.
-        /// </para>
-        /// </remarks>
-        public int BufferSize
-        {
-            get
-            {
-                return this._baseStream._bufferSize;
-            }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                if (this._baseStream._workingBuffer != null)
-                    throw new ZlibException("The working buffer is already set.");
-                if (value < ZlibConstants.WorkingBufferSizeMin)
-                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
-                this._baseStream._bufferSize = value;
-            }
-        }
-
-
-        /// <summary> Returns the total number of bytes input so far.</summary>
-        virtual public long TotalIn
-        {
-            get
-            {
-                return this._baseStream._z.TotalBytesIn;
-            }
-        }
-
-        /// <summary> Returns the total number of bytes output so far.</summary>
-        virtual public long TotalOut
-        {
-            get
-            {
-                return this._baseStream._z.TotalBytesOut;
-            }
-        }
-
-        #endregion
-
-        #region Stream methods
-
-        /// <summary>
-        ///   Dispose the stream.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This may or may not result in a <c>Close()</c> call on the captive
-        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
-        ///     for more information.
-        ///   </para>
-        ///   <para>
-        ///     This method may be invoked in two distinct scenarios.  If disposing
-        ///     == true, the method has been called directly or indirectly by a
-        ///     user's code, for example via the public Dispose() method. In this
-        ///     case, both managed and unmanaged resources can be referenced and
-        ///     disposed.  If disposing == false, the method has been called by the
-        ///     runtime from inside the object finalizer and this method should not
-        ///     reference other objects; in that case only unmanaged resources must
-        ///     be referenced or disposed.
-        ///   </para>
-        /// </remarks>
-        /// <param name="disposing">
-        ///   indicates whether the Dispose method was invoked by user code.
-        /// </param>
-        protected override void Dispose(bool disposing)
-        {
-            try
-            {
-                if (!_disposed)
-                {
-                    if (disposing && (this._baseStream != null))
-                    {
-                        this._baseStream.Close();
-                        this._Crc32 = _baseStream.Crc32;
-                    }
-                    _disposed = true;
-                }
-            }
-            finally
-            {
-                base.Dispose(disposing);
-            }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the stream can be read.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports reading.
-        /// </remarks>
-        public override bool CanRead
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                return _baseStream._stream.CanRead;
-            }
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports Seek operations.
-        /// </summary>
-        /// <remarks>
-        /// Always returns false.
-        /// </remarks>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the stream can be written.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports writing.
-        /// </remarks>
-        public override bool CanWrite
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("GZipStream");
-                return _baseStream._stream.CanWrite;
-            }
-        }
-
-        /// <summary>
-        /// Flush the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            if (_disposed) throw new ObjectDisposedException("GZipStream");
-            _baseStream.Flush();
-        }
-
-        /// <summary>
-        /// Reading this property always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        public override long Length
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        ///   The position of the stream pointer.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Setting this property always throws a <see
-        ///   cref="NotImplementedException"/>. Reading will return the total bytes
-        ///   written out, if used in writing, or the total bytes read in, if used in
-        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
-        ///   depending on how you've used the stream.
-        /// </remarks>
-        public override long Position
-        {
-            get
-            {
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Writer)
-                    return this._baseStream._z.TotalBytesOut + _headerByteCount;
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Reader)
-                    return this._baseStream._z.TotalBytesIn + this._baseStream._gzipHeaderByteCount;
-                return 0;
-            }
-
-            set { throw new NotImplementedException(); }
-        }
-
-        /// <summary>
-        ///   Read and decompress data from the source stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   With a <c>GZipStream</c>, decompression is done through reading.
-        /// </remarks>
-        ///
-        /// <example>
-        /// <code>
-        /// byte[] working = new byte[WORKING_BUFFER_SIZE];
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))
-        /// {
-        ///     using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
-        ///     {
-        ///         using (var output = System.IO.File.Create(_DecompressedFile))
-        ///         {
-        ///             int n;
-        ///             while ((n= decompressor.Read(working, 0, working.Length)) !=0)
-        ///             {
-        ///                 output.Write(working, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        /// <param name="buffer">The buffer into which the decompressed data should be placed.</param>
-        /// <param name="offset">the offset within that data array to put the first byte read.</param>
-        /// <param name="count">the number of bytes to read.</param>
-        /// <returns>the number of bytes actually read</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_disposed) throw new ObjectDisposedException("GZipStream");
-            int n = _baseStream.Read(buffer, offset, count);
-
-            // Console.WriteLine("GZipStream::Read(buffer, off({0}), c({1}) = {2}", offset, count, n);
-            // Console.WriteLine( Util.FormatByteArray(buffer, offset, n) );
-
-            if (!_firstReadDone)
-            {
-                _firstReadDone = true;
-                FileName = _baseStream._GzipFileName;
-                Comment = _baseStream._GzipComment;
-            }
-            return n;
-        }
-
-
-
-        /// <summary>
-        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        /// <param name="offset">irrelevant; it will always throw!</param>
-        /// <param name="origin">irrelevant; it will always throw!</param>
-        /// <returns>irrelevant!</returns>
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
-        /// </summary>
-        /// <param name="value">irrelevant; this method will always throw!</param>
-        public override void SetLength(long value)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        ///   Write data to the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   If you wish to use the <c>GZipStream</c> to compress data while writing,
-        ///   you can create a <c>GZipStream</c> with <c>CompressionMode.Compress</c>, and a
-        ///   writable output stream.  Then call <c>Write()</c> on that <c>GZipStream</c>,
-        ///   providing uncompressed data as input.  The data sent to the output stream
-        ///   will be the compressed form of the data written.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>GZipStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not
-        ///   both. Writing implies compression.  Reading implies decompression.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            if (_disposed) throw new ObjectDisposedException("GZipStream");
-            if (_baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Undefined)
-            {
-                //Console.WriteLine("GZipStream: First write");
-                if (_baseStream._wantCompress)
-                {
-                    // first write in compression, therefore, emit the GZIP header
-                    _headerByteCount = EmitHeader();
-                }
-                else
-                {
-                    throw new InvalidOperationException();
-                }
-            }
-
-            _baseStream.Write(buffer, offset, count);
-        }
-        #endregion
-
-
-        internal static readonly System.DateTime _unixEpoch = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-#if SILVERLIGHT || NETCF
-        internal static readonly System.Text.Encoding iso8859dash1 = new Ionic.Encoding.Iso8859Dash1Encoding();
-#else
-        internal static readonly System.Text.Encoding iso8859dash1 = System.Text.Encoding.GetEncoding("iso-8859-1");
-#endif
-
-
-        private int EmitHeader()
-        {
-            byte[] commentBytes = (Comment == null) ? null : iso8859dash1.GetBytes(Comment);
-            byte[] filenameBytes = (FileName == null) ? null : iso8859dash1.GetBytes(FileName);
-
-            int cbLength = (Comment == null) ? 0 : commentBytes.Length + 1;
-            int fnLength = (FileName == null) ? 0 : filenameBytes.Length + 1;
-
-            int bufferLength = 10 + cbLength + fnLength;
-            byte[] header = new byte[bufferLength];
-            int i = 0;
-            // ID
-            header[i++] = 0x1F;
-            header[i++] = 0x8B;
-
-            // compression method
-            header[i++] = 8;
-            byte flag = 0;
-            if (Comment != null)
-                flag ^= 0x10;
-            if (FileName != null)
-                flag ^= 0x8;
-
-            // flag
-            header[i++] = flag;
-
-            // mtime
-            if (!LastModified.HasValue) LastModified = DateTime.Now;
-            System.TimeSpan delta = LastModified.Value - _unixEpoch;
-            Int32 timet = (Int32)delta.TotalSeconds;
-            Array.Copy(BitConverter.GetBytes(timet), 0, header, i, 4);
-            i += 4;
-
-            // xflg
-            header[i++] = 0;    // this field is totally useless
-            // OS
-            header[i++] = 0xFF; // 0xFF == unspecified
-
-            // extra field length - only if FEXTRA is set, which it is not.
-            //header[i++]= 0;
-            //header[i++]= 0;
-
-            // filename
-            if (fnLength != 0)
-            {
-                Array.Copy(filenameBytes, 0, header, i, fnLength - 1);
-                i += fnLength - 1;
-                header[i++] = 0; // terminate
-            }
-
-            // comment
-            if (cbLength != 0)
-            {
-                Array.Copy(commentBytes, 0, header, i, cbLength - 1);
-                i += cbLength - 1;
-                header[i++] = 0; // terminate
-            }
-
-            _baseStream._stream.Write(header, 0, header.Length);
-
-            return header.Length; // bytes written
-        }
-
-
-
-        /// <summary>
-        ///   Compress a string into a byte array using GZip.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="GZipStream.UncompressString(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
-        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
-        ///
-        /// <param name="s">
-        ///   A string to compress. The string will first be encoded
-        ///   using UTF8, then compressed.
-        /// </param>
-        ///
-        /// <returns>The string in compressed form</returns>
-        public static byte[] CompressString(String s)
-        {
-            using (var ms = new MemoryStream())
-            {
-                System.IO.Stream compressor =
-                    new GZipStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
-                ZlibBaseStream.CompressString(s, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Compress a byte array into a new byte array using GZip.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="GZipStream.UncompressBuffer(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="GZipStream.CompressString(string)"/>
-        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
-        ///
-        /// <param name="b">
-        ///   A buffer to compress.
-        /// </param>
-        ///
-        /// <returns>The data in compressed form</returns>
-        public static byte[] CompressBuffer(byte[] b)
-        {
-            using (var ms = new MemoryStream())
-            {
-                System.IO.Stream compressor =
-                    new GZipStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
-
-                ZlibBaseStream.CompressBuffer(b, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a GZip'ed byte array into a single string.
-        /// </summary>
-        ///
-        /// <seealso cref="GZipStream.CompressString(String)"/>
-        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing GZIP-compressed data.
-        /// </param>
-        ///
-        /// <returns>The uncompressed string</returns>
-        public static String UncompressString(byte[] compressed)
-        {
-            using (var input = new MemoryStream(compressed))
-            {
-                Stream decompressor = new GZipStream(input, CompressionMode.Decompress);
-                return ZlibBaseStream.UncompressString(compressed, decompressor);
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a GZip'ed byte array into a byte array.
-        /// </summary>
-        ///
-        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
-        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing data that has been compressed with GZip.
-        /// </param>
-        ///
-        /// <returns>The data in uncompressed form</returns>
-        public static byte[] UncompressBuffer(byte[] compressed)
-        {
-            using (var input = new System.IO.MemoryStream(compressed))
-            {
-                System.IO.Stream decompressor =
-                    new GZipStream( input, CompressionMode.Decompress );
-
-                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
-            }
-        }
-
-
-    }
-}
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/InfTree.cs b/EPPlus/Packaging/DotNetZip/Zlib/InfTree.cs
deleted file mode 100644
index 431299c..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/InfTree.cs
+++ /dev/null
@@ -1,436 +0,0 @@
-// Inftree.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-October-28 12:43:54>
-//
-// ------------------------------------------------------------------
-//
-// This module defines classes used in  decompression. This code is derived
-// from the jzlib implementation of zlib. In keeping with the license for jzlib, 
-// the copyright to that code is below.
-//
-// ------------------------------------------------------------------
-// 
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright 
-// notice, this list of conditions and the following disclaimer in 
-// the documentation and/or other materials provided with the distribution.
-// 
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-
-using System;
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-        
-        sealed class InfTree
-        {
-                
-                private const int MANY = 1440;
-                
-                private const int Z_OK = 0;
-                private const int Z_STREAM_END = 1;
-                private const int Z_NEED_DICT = 2;
-                private const int Z_ERRNO = - 1;
-                private const int Z_STREAM_ERROR = - 2;
-                private const int Z_DATA_ERROR = - 3;
-                private const int Z_MEM_ERROR = - 4;
-                private const int Z_BUF_ERROR = - 5;
-                private const int Z_VERSION_ERROR = - 6;
-                
-                internal const int fixed_bl = 9;
-                internal const int fixed_bd = 5;
-                
-                //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_tl'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] fixed_tl = new int[]{96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 
-                        0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 
-                        14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255};
-                //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_td'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] fixed_td = new int[]{80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5, 24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577};
-                
-                // Tables for deflate from PKZIP's appnote.txt.
-                //UPGRADE_NOTE: Final was removed from the declaration of 'cplens'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] cplens = new int[]{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};
-                
-                // see note #13 above about 258
-                //UPGRADE_NOTE: Final was removed from the declaration of 'cplext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] cplext = new int[]{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, 112, 112};
-                
-                //UPGRADE_NOTE: Final was removed from the declaration of 'cpdist'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] cpdist = new int[]{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};
-                
-                //UPGRADE_NOTE: Final was removed from the declaration of 'cpdext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
-                internal static readonly int[] cpdext = new int[]{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};
-                
-                // If BMAX needs to be larger than 16, then h and x[] should be uLong.
-                internal const int BMAX = 15; // maximum bit length of any code
-                
-                internal int[] hn = null; // hufts used in space
-                internal int[] v = null; // work area for huft_build 
-                internal int[] c = null; // bit length count table
-                internal int[] r = null; // table entry for structure assignment
-                internal int[] u = null; // table stack
-                internal int[] x = null; // bit offsets, then code stack
-                
-                private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
-                {
-                        // 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 (an over-subscribed set of
-                        // lengths), or Z_MEM_ERROR if not enough memory.
-                        
-                        int a; // counter for codes of length k
-                        int f; // i repeats in table every f entries
-                        int g; // maximum code length
-                        int h; // table level
-                        int i; // counter, current code
-                        int j; // counter
-                        int k; // number of bits in current code
-                        int l; // bits per table (returned in m)
-                        int mask; // (1 << w) - 1, to avoid cc -O bug on HP
-                        int p; // pointer into c[], b[], or v[]
-                        int q; // points to current table
-                        int w; // bits before this table == (l * h)
-                        int xp; // pointer into x
-                        int y; // number of dummy codes added
-                        int z; // number of entries in current table
-                        
-                        // Generate counts for each bit length
-                        
-                        p = 0; i = n;
-                        do 
-                        {
-                                c[b[bindex + p]]++; p++; i--; // assume all entries <= BMAX
-                        }
-                        while (i != 0);
-                        
-                        if (c[0] == n)
-                        {
-                                // null input--all zero length codes
-                                t[0] = - 1;
-                                m[0] = 0;
-                                return Z_OK;
-                        }
-                        
-                        // Find minimum and maximum length, bound *m by those
-                        l = m[0];
-                        for (j = 1; j <= BMAX; j++)
-                                if (c[j] != 0)
-                                        break;
-                        k = j; // minimum code length
-                        if (l < j)
-                        {
-                                l = j;
-                        }
-                        for (i = BMAX; i != 0; i--)
-                        {
-                                if (c[i] != 0)
-                                        break;
-                        }
-                        g = i; // maximum code length
-                        if (l > i)
-                        {
-                                l = i;
-                        }
-                        m[0] = l;
-                        
-                        // Adjust last length count to fill out codes, if needed
-                        for (y = 1 << j; j < i; j++, y <<= 1)
-                        {
-                                if ((y -= c[j]) < 0)
-                                {
-                                        return Z_DATA_ERROR;
-                                }
-                        }
-                        if ((y -= c[i]) < 0)
-                        {
-                                return Z_DATA_ERROR;
-                        }
-                        c[i] += y;
-                        
-                        // Generate starting offsets into the value table for each length
-                        x[1] = j = 0;
-                        p = 1; xp = 2;
-                        while (--i != 0)
-                        {
-                                // note that i == g from above
-                                x[xp] = (j += c[p]);
-                                xp++;
-                                p++;
-                        }
-                        
-                        // Make a table of values in order of bit lengths
-                        i = 0; p = 0;
-                        do 
-                        {
-                                if ((j = b[bindex + p]) != 0)
-                                {
-                                        v[x[j]++] = i;
-                                }
-                                p++;
-                        }
-                        while (++i < n);
-                        n = x[g]; // set n to length of v
-                        
-                        // Generate the Huffman codes and for each, make the table entries
-                        x[0] = i = 0; // first Huffman code is zero
-                        p = 0; // grab values in bit order
-                        h = - 1; // no tables yet--level -1
-                        w = - l; // bits decoded == (l * h)
-                        u[0] = 0; // just to keep compilers happy
-                        q = 0; // ditto
-                        z = 0; // ditto
-                        
-                        // go through the bit lengths (k already is bits in shortest code)
-                        for (; k <= g; k++)
-                        {
-                                a = c[k];
-                                while (a-- != 0)
-                                {
-                                        // here i is the Huffman code of length k bits for value *p
-                                        // make tables up to required level
-                                        while (k > w + l)
-                                        {
-                                                h++;
-                                                w += l; // previous table always l bits
-                                                // compute minimum size table less than or equal to l bits
-                                                z = g - w;
-                                                z = (z > l)?l:z; // table size upper limit
-                                                if ((f = 1 << (j = k - w)) > a + 1)
-                                                {
-                                                        // try a k-w bit table
-                                                        // too few codes for k-w bit table
-                                                        f -= (a + 1); // deduct codes from patterns left
-                                                        xp = k;
-                                                        if (j < z)
-                                                        {
-                                                                while (++j < z)
-                                                                {
-                                                                        // try smaller tables up to z bits
-                                                                        if ((f <<= 1) <= c[++xp])
-                                                                                break; // enough codes to use up j bits
-                                                                        f -= c[xp]; // else deduct codes from patterns
-                                                                }
-                                                        }
-                                                }
-                                                z = 1 << j; // table entries for j-bit table
-                                                
-                                                // allocate new table
-                                                if (hn[0] + z > MANY)
-                                                {
-                                                        // (note: doesn't matter for fixed)
-                                                        return Z_DATA_ERROR; // overflow of MANY
-                                                }
-                                                u[h] = q = hn[0]; // DEBUG
-                                                hn[0] += z;
-                                                
-                                                // connect to last table, if there is one
-                                                if (h != 0)
-                                                {
-                                                        x[h] = i; // save pattern for backing up
-                                                        r[0] = (sbyte) j; // bits in this table
-                                                        r[1] = (sbyte) l; // bits to dump before this table
-                                                        j = SharedUtils.URShift(i, (w - l));
-                                                        r[2] = (int) (q - u[h - 1] - j); // offset to this table
-                                                        Array.Copy(r, 0, hp, (u[h - 1] + j) * 3, 3); // connect to last table
-                                                }
-                                                else
-                                                {
-                                                        t[0] = q; // first table is returned result
-                                                }
-                                        }
-                                        
-                                        // set up table entry in r
-                                        r[1] = (sbyte) (k - w);
-                                        if (p >= n)
-                                        {
-                                                r[0] = 128 + 64; // out of values--invalid code
-                                        }
-                                        else if (v[p] < s)
-                                        {
-                                                r[0] = (sbyte) (v[p] < 256?0:32 + 64); // 256 is end-of-block
-                                                r[2] = v[p++]; // simple code is just the value
-                                        }
-                                        else
-                                        {
-                                                r[0] = (sbyte) (e[v[p] - s] + 16 + 64); // non-simple--look up in lists
-                                                r[2] = d[v[p++] - s];
-                                        }
-                                        
-                                        // fill code-like entries with r
-                                        f = 1 << (k - w);
-                                        for (j = SharedUtils.URShift(i, w); j < z; j += f)
-                                        {
-                                                Array.Copy(r, 0, hp, (q + j) * 3, 3);
-                                        }
-                                        
-                                        // backwards increment the k-bit code i
-                                        for (j = 1 << (k - 1); (i & j) != 0; j = SharedUtils.URShift(j, 1))
-                                        {
-                                                i ^= j;
-                                        }
-                                        i ^= j;
-                                        
-                                        // backup over finished tables
-                                        mask = (1 << w) - 1; // needed on HP, cc -O bug
-                                        while ((i & mask) != x[h])
-                                        {
-                                                h--; // don't need to update q
-                                                w -= l;
-                                                mask = (1 << w) - 1;
-                                        }
-                                }
-                        }
-                        // Return Z_BUF_ERROR if we were given an incomplete table
-                        return y != 0 && g != 1?Z_BUF_ERROR:Z_OK;
-                }
-                
-                internal int inflate_trees_bits(int[] c, int[] bb, int[] tb, int[] hp, ZlibCodec z)
-                {
-                        int result;
-                        initWorkArea(19);
-                        hn[0] = 0;
-                        result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
-                        
-                        if (result == Z_DATA_ERROR)
-                        {
-                                z.Message = "oversubscribed dynamic bit lengths tree";
-                        }
-                        else if (result == Z_BUF_ERROR || bb[0] == 0)
-                        {
-                                z.Message = "incomplete dynamic bit lengths tree";
-                                result = Z_DATA_ERROR;
-                        }
-                        return result;
-                }
-                
-                internal int inflate_trees_dynamic(int nl, int nd, int[] c, int[] bl, int[] bd, int[] tl, int[] td, int[] hp, ZlibCodec z)
-                {
-                        int result;
-                        
-                        // build literal/length tree
-                        initWorkArea(288);
-                        hn[0] = 0;
-                        result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
-                        if (result != Z_OK || bl[0] == 0)
-                        {
-                                if (result == Z_DATA_ERROR)
-                                {
-                                        z.Message = "oversubscribed literal/length tree";
-                                }
-                                else if (result != Z_MEM_ERROR)
-                                {
-                                        z.Message = "incomplete literal/length tree";
-                                        result = Z_DATA_ERROR;
-                                }
-                                return result;
-                        }
-                        
-                        // build distance tree
-                        initWorkArea(288);
-                        result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
-                        
-                        if (result != Z_OK || (bd[0] == 0 && nl > 257))
-                        {
-                                if (result == Z_DATA_ERROR)
-                                {
-                                        z.Message = "oversubscribed distance tree";
-                                }
-                                else if (result == Z_BUF_ERROR)
-                                {
-                                        z.Message = "incomplete distance tree";
-                                        result = Z_DATA_ERROR;
-                                }
-                                else if (result != Z_MEM_ERROR)
-                                {
-                                        z.Message = "empty distance tree with lengths";
-                                        result = Z_DATA_ERROR;
-                                }
-                                return result;
-                        }
-                        
-                        return Z_OK;
-                }
-                
-                internal static int inflate_trees_fixed(int[] bl, int[] bd, int[][] tl, int[][] td, ZlibCodec z)
-                {
-                        bl[0] = fixed_bl;
-                        bd[0] = fixed_bd;
-                        tl[0] = fixed_tl;
-                        td[0] = fixed_td;
-                        return Z_OK;
-                }
-                
-                private void  initWorkArea(int vsize)
-                {
-                        if (hn == null)
-                        {
-                                hn = new int[1];
-                                v = new int[vsize];
-                                c = new int[BMAX + 1];
-                                r = new int[3];
-                                u = new int[BMAX];
-                                x = new int[BMAX + 1];
-                        }
-                        else
-                        {
-                            if (v.Length < vsize)
-                            {
-                                v = new int[vsize];
-                            }
-                            Array.Clear(v,0,vsize);
-                            Array.Clear(c,0,BMAX+1);
-                            r[0]=0; r[1]=0; r[2]=0;
-                            //  for(int i=0; i<BMAX; i++){u[i]=0;}
-                            //Array.Copy(c, 0, u, 0, BMAX);
-                            Array.Clear(u,0,BMAX);
-                            //  for(int i=0; i<BMAX+1; i++){x[i]=0;}
-                            //Array.Copy(c, 0, x, 0, BMAX + 1);
-                            Array.Clear(x,0,BMAX+1);
-                        }
-                }
-        }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/Inflate.cs b/EPPlus/Packaging/DotNetZip/Zlib/Inflate.cs
deleted file mode 100644
index 47c8d6e..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/Inflate.cs
+++ /dev/null
@@ -1,1796 +0,0 @@
-// Inflate.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2010-January-08 18:32:12>
-//
-// ------------------------------------------------------------------
-//
-// This module defines classes for decompression. This code is derived
-// from the jzlib implementation of zlib, but significantly modified.
-// The object model is not the same, and many of the behaviors are
-// different.  Nonetheless, in keeping with the license for jzlib, I am
-// reproducing the copyright to that code here.
-//
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in
-// the documentation and/or other materials provided with the distribution.
-//
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-using System;
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    sealed class InflateBlocks
-    {
-        private const int MANY = 1440;
-
-        // Table for deflate from PKZIP's appnote.txt.
-        internal static readonly int[] border = new int[]
-        { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
-
-        private enum InflateBlockMode
-        {
-            TYPE   = 0,                     // get type bits (3, including end bit)
-            LENS   = 1,                     // get lengths for stored
-            STORED = 2,                     // processing stored block
-            TABLE  = 3,                     // get table lengths
-            BTREE  = 4,                     // get bit lengths tree for a dynamic block
-            DTREE  = 5,                     // get length, distance trees for a dynamic block
-            CODES  = 6,                     // processing fixed or dynamic block
-            DRY    = 7,                     // output remaining window bytes
-            DONE   = 8,                     // finished last block, done
-            BAD    = 9,                     // ot a data error--stuck here
-        }
-
-        private InflateBlockMode mode;                    // current inflate_block mode
-
-        internal int left;                                // if STORED, bytes left to copy
-
-        internal int table;                               // table lengths (14 bits)
-        internal int index;                               // index into blens (or border)
-        internal int[] blens;                             // bit lengths of codes
-        internal int[] bb = new int[1];                   // bit length tree depth
-        internal int[] tb = new int[1];                   // bit length decoding tree
-
-        internal InflateCodes codes = new InflateCodes(); // if CODES, current state
-
-        internal int last;                                // true if this block is the last block
-
-        internal ZlibCodec _codec;                        // pointer back to this zlib stream
-
-                                                          // mode independent information
-        internal int bitk;                                // bits in bit buffer
-        internal int bitb;                                // bit buffer
-        internal int[] hufts;                             // single malloc for tree space
-        internal byte[] window;                           // sliding window
-        internal int end;                                 // one byte after sliding window
-        internal int readAt;                              // window read pointer
-        internal int writeAt;                             // window write pointer
-        internal System.Object checkfn;                   // check function
-        internal uint check;                              // check on output
-
-        internal InfTree inftree = new InfTree();
-
-        internal InflateBlocks(ZlibCodec codec, System.Object checkfn, int w)
-        {
-            _codec = codec;
-            hufts = new int[MANY * 3];
-            window = new byte[w];
-            end = w;
-            this.checkfn = checkfn;
-            mode = InflateBlockMode.TYPE;
-            Reset();
-        }
-
-        internal uint Reset()
-        {
-            uint oldCheck = check;
-            mode = InflateBlockMode.TYPE;
-            bitk = 0;
-            bitb = 0;
-            readAt = writeAt = 0;
-
-            if (checkfn != null)
-                _codec._Adler32 = check = Adler.Adler32(0, null, 0, 0);
-            return oldCheck;
-        }
-
-
-        internal int Process(int r)
-        {
-            int t; // temporary storage
-            int b; // bit buffer
-            int k; // bits in bit buffer
-            int p; // input data pointer
-            int n; // bytes available there
-            int q; // output window write pointer
-            int m; // bytes to end of window or read pointer
-
-            // copy input/output information to locals (UPDATE macro restores)
-
-            p = _codec.NextIn;
-            n = _codec.AvailableBytesIn;
-            b = bitb;
-            k = bitk;
-
-            q = writeAt;
-            m = (int)(q < readAt ? readAt - q - 1 : end - q);
-
-
-            // process input based on current state
-            while (true)
-            {
-                switch (mode)
-                {
-                    case InflateBlockMode.TYPE:
-
-                        while (k < (3))
-                        {
-                            if (n != 0)
-                            {
-                                r = ZlibConstants.Z_OK;
-                            }
-                            else
-                            {
-                                bitb = b; bitk = k;
-                                _codec.AvailableBytesIn = n;
-                                _codec.TotalBytesIn += p - _codec.NextIn;
-                                _codec.NextIn = p;
-                                writeAt = q;
-                                return Flush(r);
-                            }
-
-                            n--;
-                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-                        t = (int)(b & 7);
-                        last = t & 1;
-
-                        switch ((uint)t >> 1)
-                        {
-                            case 0:  // stored
-                                b >>= 3; k -= (3);
-                                t = k & 7; // go to byte boundary
-                                b >>= t; k -= t;
-                                mode = InflateBlockMode.LENS; // get length of stored block
-                                break;
-
-                            case 1:  // fixed
-                                int[] bl = new int[1];
-                                int[] bd = new int[1];
-                                int[][] tl = new int[1][];
-                                int[][] td = new int[1][];
-                                InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
-                                codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
-                                b >>= 3; k -= 3;
-                                mode = InflateBlockMode.CODES;
-                                break;
-
-                            case 2:  // dynamic
-                                b >>= 3; k -= 3;
-                                mode = InflateBlockMode.TABLE;
-                                break;
-
-                            case 3:  // illegal
-                                b >>= 3; k -= 3;
-                                mode = InflateBlockMode.BAD;
-                                _codec.Message = "invalid block type";
-                                r = ZlibConstants.Z_DATA_ERROR;
-                                bitb = b; bitk = k;
-                                _codec.AvailableBytesIn = n;
-                                _codec.TotalBytesIn += p - _codec.NextIn;
-                                _codec.NextIn = p;
-                                writeAt = q;
-                                return Flush(r);
-                        }
-                        break;
-
-                    case InflateBlockMode.LENS:
-
-                        while (k < (32))
-                        {
-                            if (n != 0)
-                            {
-                                r = ZlibConstants.Z_OK;
-                            }
-                            else
-                            {
-                                bitb = b; bitk = k;
-                                _codec.AvailableBytesIn = n;
-                                _codec.TotalBytesIn += p - _codec.NextIn;
-                                _codec.NextIn = p;
-                                writeAt = q;
-                                return Flush(r);
-                            }
-                            ;
-                            n--;
-                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        if ( ( ((~b)>>16) & 0xffff) != (b & 0xffff))
-                        {
-                            mode = InflateBlockMode.BAD;
-                            _codec.Message = "invalid stored block lengths";
-                            r = ZlibConstants.Z_DATA_ERROR;
-
-                            bitb = b; bitk = k;
-                            _codec.AvailableBytesIn = n;
-                            _codec.TotalBytesIn += p - _codec.NextIn;
-                            _codec.NextIn = p;
-                            writeAt = q;
-                            return Flush(r);
-                        }
-                        left = (b & 0xffff);
-                        b = k = 0; // dump bits
-                        mode = left != 0 ? InflateBlockMode.STORED : (last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
-                        break;
-
-                    case InflateBlockMode.STORED:
-                        if (n == 0)
-                        {
-                            bitb = b; bitk = k;
-                            _codec.AvailableBytesIn = n;
-                            _codec.TotalBytesIn += p - _codec.NextIn;
-                            _codec.NextIn = p;
-                            writeAt = q;
-                            return Flush(r);
-                        }
-
-                        if (m == 0)
-                        {
-                            if (q == end && readAt != 0)
-                            {
-                                q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
-                            }
-                            if (m == 0)
-                            {
-                                writeAt = q;
-                                r = Flush(r);
-                                q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
-                                if (q == end && readAt != 0)
-                                {
-                                    q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
-                                }
-                                if (m == 0)
-                                {
-                                    bitb = b; bitk = k;
-                                    _codec.AvailableBytesIn = n;
-                                    _codec.TotalBytesIn += p - _codec.NextIn;
-                                    _codec.NextIn = p;
-                                    writeAt = q;
-                                    return Flush(r);
-                                }
-                            }
-                        }
-                        r = ZlibConstants.Z_OK;
-
-                        t = left;
-                        if (t > n)
-                            t = n;
-                        if (t > m)
-                            t = m;
-                        Array.Copy(_codec.InputBuffer, p, window, q, t);
-                        p += t; n -= t;
-                        q += t; m -= t;
-                        if ((left -= t) != 0)
-                            break;
-                        mode = last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE;
-                        break;
-
-                    case InflateBlockMode.TABLE:
-
-                        while (k < (14))
-                        {
-                            if (n != 0)
-                            {
-                                r = ZlibConstants.Z_OK;
-                            }
-                            else
-                            {
-                                bitb = b; bitk = k;
-                                _codec.AvailableBytesIn = n;
-                                _codec.TotalBytesIn += p - _codec.NextIn;
-                                _codec.NextIn = p;
-                                writeAt = q;
-                                return Flush(r);
-                            }
-
-                            n--;
-                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        table = t = (b & 0x3fff);
-                        if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
-                        {
-                            mode = InflateBlockMode.BAD;
-                            _codec.Message = "too many length or distance symbols";
-                            r = ZlibConstants.Z_DATA_ERROR;
-
-                            bitb = b; bitk = k;
-                            _codec.AvailableBytesIn = n;
-                            _codec.TotalBytesIn += p - _codec.NextIn;
-                            _codec.NextIn = p;
-                            writeAt = q;
-                            return Flush(r);
-                        }
-                        t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
-                        if (blens == null || blens.Length < t)
-                        {
-                            blens = new int[t];
-                        }
-                        else
-                        {
-                            Array.Clear(blens, 0, t);
-                            // for (int i = 0; i < t; i++)
-                            // {
-                            //     blens[i] = 0;
-                            // }
-                        }
-
-                        b >>= 14;
-                        k -= 14;
-
-
-                        index = 0;
-                        mode = InflateBlockMode.BTREE;
-                        goto case InflateBlockMode.BTREE;
-
-                    case InflateBlockMode.BTREE:
-                        while (index < 4 + (table >> 10))
-                        {
-                            while (k < (3))
-                            {
-                                if (n != 0)
-                                {
-                                    r = ZlibConstants.Z_OK;
-                                }
-                                else
-                                {
-                                    bitb = b; bitk = k;
-                                    _codec.AvailableBytesIn = n;
-                                    _codec.TotalBytesIn += p - _codec.NextIn;
-                                    _codec.NextIn = p;
-                                    writeAt = q;
-                                    return Flush(r);
-                                }
-
-                                n--;
-                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                                k += 8;
-                            }
-
-                            blens[border[index++]] = b & 7;
-
-                            b >>= 3; k -= 3;
-                        }
-
-                        while (index < 19)
-                        {
-                            blens[border[index++]] = 0;
-                        }
-
-                        bb[0] = 7;
-                        t = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
-                        if (t != ZlibConstants.Z_OK)
-                        {
-                            r = t;
-                            if (r == ZlibConstants.Z_DATA_ERROR)
-                            {
-                                blens = null;
-                                mode = InflateBlockMode.BAD;
-                            }
-
-                            bitb = b; bitk = k;
-                            _codec.AvailableBytesIn = n;
-                            _codec.TotalBytesIn += p - _codec.NextIn;
-                            _codec.NextIn = p;
-                            writeAt = q;
-                            return Flush(r);
-                        }
-
-                        index = 0;
-                        mode = InflateBlockMode.DTREE;
-                        goto case InflateBlockMode.DTREE;
-
-                    case InflateBlockMode.DTREE:
-                        while (true)
-                        {
-                            t = table;
-                            if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
-                            {
-                                break;
-                            }
-
-                            int i, j, c;
-
-                            t = bb[0];
-
-                            while (k < t)
-                            {
-                                if (n != 0)
-                                {
-                                    r = ZlibConstants.Z_OK;
-                                }
-                                else
-                                {
-                                    bitb = b; bitk = k;
-                                    _codec.AvailableBytesIn = n;
-                                    _codec.TotalBytesIn += p - _codec.NextIn;
-                                    _codec.NextIn = p;
-                                    writeAt = q;
-                                    return Flush(r);
-                                }
-
-                                n--;
-                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                                k += 8;
-                            }
-
-                            t = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 1];
-                            c = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 2];
-
-                            if (c < 16)
-                            {
-                                b >>= t; k -= t;
-                                blens[index++] = c;
-                            }
-                            else
-                            {
-                                // c == 16..18
-                                i = c == 18 ? 7 : c - 14;
-                                j = c == 18 ? 11 : 3;
-
-                                while (k < (t + i))
-                                {
-                                    if (n != 0)
-                                    {
-                                        r = ZlibConstants.Z_OK;
-                                    }
-                                    else
-                                    {
-                                        bitb = b; bitk = k;
-                                        _codec.AvailableBytesIn = n;
-                                        _codec.TotalBytesIn += p - _codec.NextIn;
-                                        _codec.NextIn = p;
-                                        writeAt = q;
-                                        return Flush(r);
-                                    }
-
-                                    n--;
-                                    b |= (_codec.InputBuffer[p++] & 0xff) << k;
-                                    k += 8;
-                                }
-
-                                b >>= t; k -= t;
-
-                                j += (b & InternalInflateConstants.InflateMask[i]);
-
-                                b >>= i; k -= i;
-
-                                i = index;
-                                t = table;
-                                if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
-                                {
-                                    blens = null;
-                                    mode = InflateBlockMode.BAD;
-                                    _codec.Message = "invalid bit length repeat";
-                                    r = ZlibConstants.Z_DATA_ERROR;
-
-                                    bitb = b; bitk = k;
-                                    _codec.AvailableBytesIn = n;
-                                    _codec.TotalBytesIn += p - _codec.NextIn;
-                                    _codec.NextIn = p;
-                                    writeAt = q;
-                                    return Flush(r);
-                                }
-
-                                c = (c == 16) ? blens[i-1] : 0;
-                                do
-                                {
-                                    blens[i++] = c;
-                                }
-                                while (--j != 0);
-                                index = i;
-                            }
-                        }
-
-                        tb[0] = -1;
-                        {
-                            int[] bl = new int[] { 9 };  // must be <= 9 for lookahead assumptions
-                            int[] bd = new int[] { 6 }; // must be <= 9 for lookahead assumptions
-                            int[] tl = new int[1];
-                            int[] td = new int[1];
-
-                            t = table;
-                            t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, _codec);
-
-                            if (t != ZlibConstants.Z_OK)
-                            {
-                                if (t == ZlibConstants.Z_DATA_ERROR)
-                                {
-                                    blens = null;
-                                    mode = InflateBlockMode.BAD;
-                                }
-                                r = t;
-
-                                bitb = b; bitk = k;
-                                _codec.AvailableBytesIn = n;
-                                _codec.TotalBytesIn += p - _codec.NextIn;
-                                _codec.NextIn = p;
-                                writeAt = q;
-                                return Flush(r);
-                            }
-                            codes.Init(bl[0], bd[0], hufts, tl[0], hufts, td[0]);
-                        }
-                        mode = InflateBlockMode.CODES;
-                        goto case InflateBlockMode.CODES;
-
-                    case InflateBlockMode.CODES:
-                        bitb = b; bitk = k;
-                        _codec.AvailableBytesIn = n;
-                        _codec.TotalBytesIn += p - _codec.NextIn;
-                        _codec.NextIn = p;
-                        writeAt = q;
-
-                        r = codes.Process(this, r);
-                        if (r != ZlibConstants.Z_STREAM_END)
-                        {
-                            return Flush(r);
-                        }
-
-                        r = ZlibConstants.Z_OK;
-                        p = _codec.NextIn;
-                        n = _codec.AvailableBytesIn;
-                        b = bitb;
-                        k = bitk;
-                        q = writeAt;
-                        m = (int)(q < readAt ? readAt - q - 1 : end - q);
-
-                        if (last == 0)
-                        {
-                            mode = InflateBlockMode.TYPE;
-                            break;
-                        }
-                        mode = InflateBlockMode.DRY;
-                        goto case InflateBlockMode.DRY;
-
-                    case InflateBlockMode.DRY:
-                        writeAt = q;
-                        r = Flush(r);
-                        q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
-                        if (readAt != writeAt)
-                        {
-                            bitb = b; bitk = k;
-                            _codec.AvailableBytesIn = n;
-                            _codec.TotalBytesIn += p - _codec.NextIn;
-                            _codec.NextIn = p;
-                            writeAt = q;
-                            return Flush(r);
-                        }
-                        mode = InflateBlockMode.DONE;
-                        goto case InflateBlockMode.DONE;
-
-                    case InflateBlockMode.DONE:
-                        r = ZlibConstants.Z_STREAM_END;
-                        bitb = b;
-                        bitk = k;
-                        _codec.AvailableBytesIn = n;
-                        _codec.TotalBytesIn += p - _codec.NextIn;
-                        _codec.NextIn = p;
-                        writeAt = q;
-                        return Flush(r);
-
-                    case InflateBlockMode.BAD:
-                        r = ZlibConstants.Z_DATA_ERROR;
-
-                        bitb = b; bitk = k;
-                        _codec.AvailableBytesIn = n;
-                        _codec.TotalBytesIn += p - _codec.NextIn;
-                        _codec.NextIn = p;
-                        writeAt = q;
-                        return Flush(r);
-
-
-                    default:
-                        r = ZlibConstants.Z_STREAM_ERROR;
-
-                        bitb = b; bitk = k;
-                        _codec.AvailableBytesIn = n;
-                        _codec.TotalBytesIn += p - _codec.NextIn;
-                        _codec.NextIn = p;
-                        writeAt = q;
-                        return Flush(r);
-                }
-            }
-        }
-
-
-        internal void Free()
-        {
-            Reset();
-            window = null;
-            hufts = null;
-        }
-
-        internal void SetDictionary(byte[] d, int start, int n)
-        {
-            Array.Copy(d, start, window, 0, n);
-            readAt = writeAt = n;
-        }
-
-        // Returns true if inflate is currently at the end of a block generated
-        // by Z_SYNC_FLUSH or Z_FULL_FLUSH.
-        internal int SyncPoint()
-        {
-            return mode == InflateBlockMode.LENS ? 1 : 0;
-        }
-
-        // copy as much as possible from the sliding window to the output area
-        internal int Flush(int r)
-        {
-            int nBytes;
-
-            for (int pass=0; pass < 2; pass++)
-            {
-                if (pass==0)
-                {
-                    // compute number of bytes to copy as far as end of window
-                    nBytes = (int)((readAt <= writeAt ? writeAt : end) - readAt);
-                }
-                else
-                {
-                    // compute bytes to copy
-                    nBytes = writeAt - readAt;
-                }
-
-                // workitem 8870
-                if (nBytes == 0)
-                {
-                    if (r == ZlibConstants.Z_BUF_ERROR)
-                        r = ZlibConstants.Z_OK;
-                    return r;
-                }
-
-                if (nBytes > _codec.AvailableBytesOut)
-                    nBytes = _codec.AvailableBytesOut;
-
-                if (nBytes != 0 && r == ZlibConstants.Z_BUF_ERROR)
-                    r = ZlibConstants.Z_OK;
-
-                // update counters
-                _codec.AvailableBytesOut -= nBytes;
-                _codec.TotalBytesOut += nBytes;
-
-                // update check information
-                if (checkfn != null)
-                    _codec._Adler32 = check = Adler.Adler32(check, window, readAt, nBytes);
-
-                // copy as far as end of window
-                Array.Copy(window, readAt, _codec.OutputBuffer, _codec.NextOut, nBytes);
-                _codec.NextOut += nBytes;
-                readAt += nBytes;
-
-                // see if more to copy at beginning of window
-                if (readAt == end && pass == 0)
-                {
-                    // wrap pointers
-                    readAt = 0;
-                    if (writeAt == end)
-                        writeAt = 0;
-                }
-                else pass++;
-            }
-
-            // done
-            return r;
-        }
-    }
-
-
-    internal static class InternalInflateConstants
-    {
-        // And'ing with mask[n] masks the lower n bits
-        internal static readonly int[] InflateMask = new int[] {
-            0x00000000, 0x00000001, 0x00000003, 0x00000007,
-            0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
-            0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
-            0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff };
-    }
-
-
-    sealed class InflateCodes
-    {
-        // waiting for "i:"=input,
-        //             "o:"=output,
-        //             "x:"=nothing
-        private const int START   = 0; // x: set up for LEN
-        private const int LEN     = 1; // i: get length/literal/eob next
-        private const int LENEXT  = 2; // i: getting length extra (have base)
-        private const int DIST    = 3; // i: get distance next
-        private const int DISTEXT = 4; // i: getting distance extra
-        private const int COPY    = 5; // o: copying bytes in window, waiting for space
-        private const int LIT     = 6; // o: got literal, waiting for output space
-        private const int WASH    = 7; // o: got eob, possibly still output waiting
-        private const int END     = 8; // x: got eob and all data flushed
-        private const int BADCODE = 9; // x: got error
-
-        internal int mode;        // current inflate_codes mode
-
-        // mode dependent information
-        internal int len;
-
-        internal int[] tree;      // pointer into tree
-        internal int tree_index = 0;
-        internal int need;        // bits needed
-
-        internal int lit;
-
-        // if EXT or COPY, where and how much
-        internal int bitsToGet;   // bits to get for extra
-        internal int dist;        // distance back to copy from
-
-        internal byte lbits;      // ltree bits decoded per branch
-        internal byte dbits;      // dtree bits decoder per branch
-        internal int[] ltree;     // literal/length/eob tree
-        internal int ltree_index; // literal/length/eob tree
-        internal int[] dtree;     // distance tree
-        internal int dtree_index; // distance tree
-
-        internal InflateCodes()
-        {
-        }
-
-        internal void Init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index)
-        {
-            mode = START;
-            lbits = (byte)bl;
-            dbits = (byte)bd;
-            ltree = tl;
-            ltree_index = tl_index;
-            dtree = td;
-            dtree_index = td_index;
-            tree = null;
-        }
-
-        internal int Process(InflateBlocks blocks, int r)
-        {
-            int j;      // temporary storage
-            int tindex; // temporary pointer
-            int e;      // extra bits or operation
-            int b = 0;  // bit buffer
-            int k = 0;  // bits in bit buffer
-            int p = 0;  // input data pointer
-            int n;      // bytes available there
-            int q;      // output window write pointer
-            int m;      // bytes to end of window or read pointer
-            int f;      // pointer to copy strings from
-
-            ZlibCodec z = blocks._codec;
-
-            // copy input/output information to locals (UPDATE macro restores)
-            p = z.NextIn;
-            n = z.AvailableBytesIn;
-            b = blocks.bitb;
-            k = blocks.bitk;
-            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-
-            // process input and output based on current state
-            while (true)
-            {
-                switch (mode)
-                {
-                    // waiting for "i:"=input, "o:"=output, "x:"=nothing
-                    case START:  // x: set up for LEN
-                        if (m >= 258 && n >= 10)
-                        {
-                            blocks.bitb = b; blocks.bitk = k;
-                            z.AvailableBytesIn = n;
-                            z.TotalBytesIn += p - z.NextIn;
-                            z.NextIn = p;
-                            blocks.writeAt = q;
-                            r = InflateFast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, blocks, z);
-
-                            p = z.NextIn;
-                            n = z.AvailableBytesIn;
-                            b = blocks.bitb;
-                            k = blocks.bitk;
-                            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-
-                            if (r != ZlibConstants.Z_OK)
-                            {
-                                mode = (r == ZlibConstants.Z_STREAM_END) ? WASH : BADCODE;
-                                break;
-                            }
-                        }
-                        need = lbits;
-                        tree = ltree;
-                        tree_index = ltree_index;
-
-                        mode = LEN;
-                        goto case LEN;
-
-                    case LEN:  // i: get length/literal/eob next
-                        j = need;
-
-                        while (k < j)
-                        {
-                            if (n != 0)
-                                r = ZlibConstants.Z_OK;
-                            else
-                            {
-                                blocks.bitb = b; blocks.bitk = k;
-                                z.AvailableBytesIn = n;
-                                z.TotalBytesIn += p - z.NextIn;
-                                z.NextIn = p;
-                                blocks.writeAt = q;
-                                return blocks.Flush(r);
-                            }
-                            n--;
-                            b |= (z.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
-
-                        b >>= (tree[tindex + 1]);
-                        k -= (tree[tindex + 1]);
-
-                        e = tree[tindex];
-
-                        if (e == 0)
-                        {
-                            // literal
-                            lit = tree[tindex + 2];
-                            mode = LIT;
-                            break;
-                        }
-                        if ((e & 16) != 0)
-                        {
-                            // length
-                            bitsToGet = e & 15;
-                            len = tree[tindex + 2];
-                            mode = LENEXT;
-                            break;
-                        }
-                        if ((e & 64) == 0)
-                        {
-                            // next table
-                            need = e;
-                            tree_index = tindex / 3 + tree[tindex + 2];
-                            break;
-                        }
-                        if ((e & 32) != 0)
-                        {
-                            // end of block
-                            mode = WASH;
-                            break;
-                        }
-                        mode = BADCODE; // invalid code
-                        z.Message = "invalid literal/length code";
-                        r = ZlibConstants.Z_DATA_ERROR;
-
-                        blocks.bitb = b; blocks.bitk = k;
-                        z.AvailableBytesIn = n;
-                        z.TotalBytesIn += p - z.NextIn;
-                        z.NextIn = p;
-                        blocks.writeAt = q;
-                        return blocks.Flush(r);
-
-
-                    case LENEXT:  // i: getting length extra (have base)
-                        j = bitsToGet;
-
-                        while (k < j)
-                        {
-                            if (n != 0)
-                                r = ZlibConstants.Z_OK;
-                            else
-                            {
-                                blocks.bitb = b; blocks.bitk = k;
-                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                                blocks.writeAt = q;
-                                return blocks.Flush(r);
-                            }
-                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        len += (b & InternalInflateConstants.InflateMask[j]);
-
-                        b >>= j;
-                        k -= j;
-
-                        need = dbits;
-                        tree = dtree;
-                        tree_index = dtree_index;
-                        mode = DIST;
-                        goto case DIST;
-
-                    case DIST:  // i: get distance next
-                        j = need;
-
-                        while (k < j)
-                        {
-                            if (n != 0)
-                                r = ZlibConstants.Z_OK;
-                            else
-                            {
-                                blocks.bitb = b; blocks.bitk = k;
-                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                                blocks.writeAt = q;
-                                return blocks.Flush(r);
-                            }
-                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
-
-                        b >>= tree[tindex + 1];
-                        k -= tree[tindex + 1];
-
-                        e = (tree[tindex]);
-                        if ((e & 0x10) != 0)
-                        {
-                            // distance
-                            bitsToGet = e & 15;
-                            dist = tree[tindex + 2];
-                            mode = DISTEXT;
-                            break;
-                        }
-                        if ((e & 64) == 0)
-                        {
-                            // next table
-                            need = e;
-                            tree_index = tindex / 3 + tree[tindex + 2];
-                            break;
-                        }
-                        mode = BADCODE; // invalid code
-                        z.Message = "invalid distance code";
-                        r = ZlibConstants.Z_DATA_ERROR;
-
-                        blocks.bitb = b; blocks.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        blocks.writeAt = q;
-                        return blocks.Flush(r);
-
-
-                    case DISTEXT:  // i: getting distance extra
-                        j = bitsToGet;
-
-                        while (k < j)
-                        {
-                            if (n != 0)
-                                r = ZlibConstants.Z_OK;
-                            else
-                            {
-                                blocks.bitb = b; blocks.bitk = k;
-                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                                blocks.writeAt = q;
-                                return blocks.Flush(r);
-                            }
-                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
-                            k += 8;
-                        }
-
-                        dist += (b & InternalInflateConstants.InflateMask[j]);
-
-                        b >>= j;
-                        k -= j;
-
-                        mode = COPY;
-                        goto case COPY;
-
-                    case COPY:  // o: copying bytes in window, waiting for space
-                        f = q - dist;
-                        while (f < 0)
-                        {
-                            // modulo window size-"while" instead
-                            f += blocks.end; // of "if" handles invalid distances
-                        }
-                        while (len != 0)
-                        {
-                            if (m == 0)
-                            {
-                                if (q == blocks.end && blocks.readAt != 0)
-                                {
-                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-                                }
-                                if (m == 0)
-                                {
-                                    blocks.writeAt = q; r = blocks.Flush(r);
-                                    q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-
-                                    if (q == blocks.end && blocks.readAt != 0)
-                                    {
-                                        q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-                                    }
-
-                                    if (m == 0)
-                                    {
-                                        blocks.bitb = b; blocks.bitk = k;
-                                        z.AvailableBytesIn = n;
-                                        z.TotalBytesIn += p - z.NextIn;
-                                        z.NextIn = p;
-                                        blocks.writeAt = q;
-                                        return blocks.Flush(r);
-                                    }
-                                }
-                            }
-
-                            blocks.window[q++] = blocks.window[f++]; m--;
-
-                            if (f == blocks.end)
-                                f = 0;
-                            len--;
-                        }
-                        mode = START;
-                        break;
-
-                    case LIT:  // o: got literal, waiting for output space
-                        if (m == 0)
-                        {
-                            if (q == blocks.end && blocks.readAt != 0)
-                            {
-                                q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-                            }
-                            if (m == 0)
-                            {
-                                blocks.writeAt = q; r = blocks.Flush(r);
-                                q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-
-                                if (q == blocks.end && blocks.readAt != 0)
-                                {
-                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-                                }
-                                if (m == 0)
-                                {
-                                    blocks.bitb = b; blocks.bitk = k;
-                                    z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                                    blocks.writeAt = q;
-                                    return blocks.Flush(r);
-                                }
-                            }
-                        }
-                        r = ZlibConstants.Z_OK;
-
-                        blocks.window[q++] = (byte)lit; m--;
-
-                        mode = START;
-                        break;
-
-                    case WASH:  // o: got eob, possibly more output
-                        if (k > 7)
-                        {
-                            // return unused byte, if any
-                            k -= 8;
-                            n++;
-                            p--; // can always return one
-                        }
-
-                        blocks.writeAt = q; r = blocks.Flush(r);
-                        q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
-
-                        if (blocks.readAt != blocks.writeAt)
-                        {
-                            blocks.bitb = b; blocks.bitk = k;
-                            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                            blocks.writeAt = q;
-                            return blocks.Flush(r);
-                        }
-                        mode = END;
-                        goto case END;
-
-                    case END:
-                        r = ZlibConstants.Z_STREAM_END;
-                        blocks.bitb = b; blocks.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        blocks.writeAt = q;
-                        return blocks.Flush(r);
-
-                    case BADCODE:  // x: got error
-
-                        r = ZlibConstants.Z_DATA_ERROR;
-
-                        blocks.bitb = b; blocks.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        blocks.writeAt = q;
-                        return blocks.Flush(r);
-
-                    default:
-                        r = ZlibConstants.Z_STREAM_ERROR;
-
-                        blocks.bitb = b; blocks.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        blocks.writeAt = q;
-                        return blocks.Flush(r);
-                }
-            }
-        }
-
-
-        // 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.
-
-        internal int InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InflateBlocks s, ZlibCodec z)
-        {
-            int t;        // temporary pointer
-            int[] tp;     // temporary pointer
-            int tp_index; // temporary pointer
-            int e;        // extra bits or operation
-            int b;        // bit buffer
-            int k;        // bits in bit buffer
-            int p;        // input data pointer
-            int n;        // bytes available there
-            int q;        // output window write pointer
-            int m;        // bytes to end of window or read pointer
-            int ml;       // mask for literal/length tree
-            int md;       // mask for distance tree
-            int c;        // bytes to copy
-            int d;        // distance back to copy from
-            int r;        // copy source pointer
-
-            int tp_index_t_3; // (tp_index+t)*3
-
-            // load input, output, bit values
-            p = z.NextIn; n = z.AvailableBytesIn; b = s.bitb; k = s.bitk;
-            q = s.writeAt; m = q < s.readAt ? s.readAt - q - 1 : s.end - q;
-
-            // initialize masks
-            ml = InternalInflateConstants.InflateMask[bl];
-            md = InternalInflateConstants.InflateMask[bd];
-
-            // do until not enough input or output space for fast loop
-            do
-            {
-                // assume called with m >= 258 && n >= 10
-                // get literal/length code
-                while (k < (20))
-                {
-                    // max bits for literal/length code
-                    n--;
-                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
-                }
-
-                t = b & ml;
-                tp = tl;
-                tp_index = tl_index;
-                tp_index_t_3 = (tp_index + t) * 3;
-                if ((e = tp[tp_index_t_3]) == 0)
-                {
-                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
-
-                    s.window[q++] = (byte)tp[tp_index_t_3 + 2];
-                    m--;
-                    continue;
-                }
-                do
-                {
-
-                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
-
-                    if ((e & 16) != 0)
-                    {
-                        e &= 15;
-                        c = tp[tp_index_t_3 + 2] + ((int)b & InternalInflateConstants.InflateMask[e]);
-
-                        b >>= e; k -= e;
-
-                        // decode distance base of block to copy
-                        while (k < 15)
-                        {
-                            // max bits for distance code
-                            n--;
-                            b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
-                        }
-
-                        t = b & md;
-                        tp = td;
-                        tp_index = td_index;
-                        tp_index_t_3 = (tp_index + t) * 3;
-                        e = tp[tp_index_t_3];
-
-                        do
-                        {
-
-                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
-
-                            if ((e & 16) != 0)
-                            {
-                                // get extra bits to add to distance base
-                                e &= 15;
-                                while (k < e)
-                                {
-                                    // get extra bits (up to 13)
-                                    n--;
-                                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
-                                }
-
-                                d = tp[tp_index_t_3 + 2] + (b & InternalInflateConstants.InflateMask[e]);
-
-                                b >>= e; k -= e;
-
-                                // do the copy
-                                m -= c;
-                                if (q >= d)
-                                {
-                                    // offset before dest
-                                    //  just copy
-                                    r = q - d;
-                                    if (q - r > 0 && 2 > (q - r))
-                                    {
-                                        s.window[q++] = s.window[r++]; // minimum count is three,
-                                        s.window[q++] = s.window[r++]; // so unroll loop a little
-                                        c -= 2;
-                                    }
-                                    else
-                                    {
-                                        Array.Copy(s.window, r, s.window, q, 2);
-                                        q += 2; r += 2; c -= 2;
-                                    }
-                                }
-                                else
-                                {
-                                    // else offset after destination
-                                    r = q - d;
-                                    do
-                                    {
-                                        r += s.end; // force pointer in window
-                                    }
-                                    while (r < 0); // covers invalid distances
-                                    e = s.end - r;
-                                    if (c > e)
-                                    {
-                                        // if source crosses,
-                                        c -= e; // wrapped copy
-                                        if (q - r > 0 && e > (q - r))
-                                        {
-                                            do
-                                            {
-                                                s.window[q++] = s.window[r++];
-                                            }
-                                            while (--e != 0);
-                                        }
-                                        else
-                                        {
-                                            Array.Copy(s.window, r, s.window, q, e);
-                                            q += e; r += e; e = 0;
-                                        }
-                                        r = 0; // copy rest from start of window
-                                    }
-                                }
-
-                                // copy all or what's left
-                                if (q - r > 0 && c > (q - r))
-                                {
-                                    do
-                                    {
-                                        s.window[q++] = s.window[r++];
-                                    }
-                                    while (--c != 0);
-                                }
-                                else
-                                {
-                                    Array.Copy(s.window, r, s.window, q, c);
-                                    q += c; r += c; c = 0;
-                                }
-                                break;
-                            }
-                            else if ((e & 64) == 0)
-                            {
-                                t += tp[tp_index_t_3 + 2];
-                                t += (b & InternalInflateConstants.InflateMask[e]);
-                                tp_index_t_3 = (tp_index + t) * 3;
-                                e = tp[tp_index_t_3];
-                            }
-                            else
-                            {
-                                z.Message = "invalid distance code";
-
-                                c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
-
-                                s.bitb = b; s.bitk = k;
-                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                                s.writeAt = q;
-
-                                return ZlibConstants.Z_DATA_ERROR;
-                            }
-                        }
-                        while (true);
-                        break;
-                    }
-
-                    if ((e & 64) == 0)
-                    {
-                        t += tp[tp_index_t_3 + 2];
-                        t += (b & InternalInflateConstants.InflateMask[e]);
-                        tp_index_t_3 = (tp_index + t) * 3;
-                        if ((e = tp[tp_index_t_3]) == 0)
-                        {
-                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
-                            s.window[q++] = (byte)tp[tp_index_t_3 + 2];
-                            m--;
-                            break;
-                        }
-                    }
-                    else if ((e & 32) != 0)
-                    {
-                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
-
-                        s.bitb = b; s.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        s.writeAt = q;
-
-                        return ZlibConstants.Z_STREAM_END;
-                    }
-                    else
-                    {
-                        z.Message = "invalid literal/length code";
-
-                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
-
-                        s.bitb = b; s.bitk = k;
-                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-                        s.writeAt = q;
-
-                        return ZlibConstants.Z_DATA_ERROR;
-                    }
-                }
-                while (true);
-            }
-            while (m >= 258 && n >= 10);
-
-            // not enough input or output--restore pointers and return
-            c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
-
-            s.bitb = b; s.bitk = k;
-            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
-            s.writeAt = q;
-
-            return ZlibConstants.Z_OK;
-        }
-    }
-
-
-    internal sealed class InflateManager
-    {
-        // preset dictionary flag in zlib header
-        private const int PRESET_DICT = 0x20;
-
-        private const int Z_DEFLATED = 8;
-
-        private enum InflateManagerMode
-        {
-            METHOD = 0,  // waiting for method byte
-            FLAG   = 1,  // waiting for flag byte
-            DICT4  = 2,  // four dictionary check bytes to go
-            DICT3  = 3,  // three dictionary check bytes to go
-            DICT2  = 4,  // two dictionary check bytes to go
-            DICT1  = 5,  // one dictionary check byte to go
-            DICT0  = 6,  // waiting for inflateSetDictionary
-            BLOCKS = 7,  // decompressing blocks
-            CHECK4 = 8,  // four check bytes to go
-            CHECK3 = 9,  // three check bytes to go
-            CHECK2 = 10, // two check bytes to go
-            CHECK1 = 11, // one check byte to go
-            DONE   = 12, // finished check, done
-            BAD    = 13, // got an error--stay here
-        }
-
-        private InflateManagerMode mode; // current inflate mode
-        internal ZlibCodec _codec; // pointer back to this zlib stream
-
-        // mode dependent information
-        internal int method; // if FLAGS, method byte
-
-        // if CHECK, check values to compare
-        internal uint computedCheck; // computed check value
-        internal uint expectedCheck; // stream check value
-
-        // if BAD, inflateSync's marker bytes count
-        internal int marker;
-
-        // mode independent information
-        //internal int nowrap; // flag for no wrapper
-        private bool _handleRfc1950HeaderBytes = true;
-        internal bool HandleRfc1950HeaderBytes
-        {
-            get { return _handleRfc1950HeaderBytes; }
-            set { _handleRfc1950HeaderBytes = value; }
-        }
-        internal int wbits; // log2(window size)  (8..15, defaults to 15)
-
-        internal InflateBlocks blocks; // current inflate_blocks state
-
-        public InflateManager() { }
-
-        public InflateManager(bool expectRfc1950HeaderBytes)
-        {
-            _handleRfc1950HeaderBytes = expectRfc1950HeaderBytes;
-        }
-
-        internal int Reset()
-        {
-            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
-            _codec.Message = null;
-            mode = HandleRfc1950HeaderBytes ? InflateManagerMode.METHOD : InflateManagerMode.BLOCKS;
-            blocks.Reset();
-            return ZlibConstants.Z_OK;
-        }
-
-        internal int End()
-        {
-            if (blocks != null)
-                blocks.Free();
-            blocks = null;
-            return ZlibConstants.Z_OK;
-        }
-
-        internal int Initialize(ZlibCodec codec, int w)
-        {
-            _codec = codec;
-            _codec.Message = null;
-            blocks = null;
-
-            // handle undocumented nowrap option (no zlib header or check)
-            //nowrap = 0;
-            //if (w < 0)
-            //{
-            //    w = - w;
-            //    nowrap = 1;
-            //}
-
-            // set window size
-            if (w < 8 || w > 15)
-            {
-                End();
-                throw new ZlibException("Bad window size.");
-
-                //return ZlibConstants.Z_STREAM_ERROR;
-            }
-            wbits = w;
-
-            blocks = new InflateBlocks(codec,
-                HandleRfc1950HeaderBytes ? this : null,
-                1 << w);
-
-            // reset state
-            Reset();
-            return ZlibConstants.Z_OK;
-        }
-
-
-        internal int Inflate(FlushType flush)
-        {
-            int b;
-
-            if (_codec.InputBuffer == null)
-                throw new ZlibException("InputBuffer is null. ");
-
-//             int f = (flush == FlushType.Finish)
-//                 ? ZlibConstants.Z_BUF_ERROR
-//                 : ZlibConstants.Z_OK;
-
-            // workitem 8870
-            int f = ZlibConstants.Z_OK;
-            int r = ZlibConstants.Z_BUF_ERROR;
-
-            while (true)
-            {
-                switch (mode)
-                {
-                    case InflateManagerMode.METHOD:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        if (((method = _codec.InputBuffer[_codec.NextIn++]) & 0xf) != Z_DEFLATED)
-                        {
-                            mode = InflateManagerMode.BAD;
-                            _codec.Message = String.Format("unknown compression method (0x{0:X2})", method);
-                            marker = 5; // can't try inflateSync
-                            break;
-                        }
-                        if ((method >> 4) + 8 > wbits)
-                        {
-                            mode = InflateManagerMode.BAD;
-                            _codec.Message = String.Format("invalid window size ({0})", (method >> 4) + 8);
-                            marker = 5; // can't try inflateSync
-                            break;
-                        }
-                        mode = InflateManagerMode.FLAG;
-                        break;
-
-
-                    case InflateManagerMode.FLAG:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        b = (_codec.InputBuffer[_codec.NextIn++]) & 0xff;
-
-                        if ((((method << 8) + b) % 31) != 0)
-                        {
-                            mode = InflateManagerMode.BAD;
-                            _codec.Message = "incorrect header check";
-                            marker = 5; // can't try inflateSync
-                            break;
-                        }
-
-                        mode = ((b & PRESET_DICT) == 0)
-                            ? InflateManagerMode.BLOCKS
-                            : InflateManagerMode.DICT4;
-                        break;
-
-                    case InflateManagerMode.DICT4:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
-                        mode = InflateManagerMode.DICT3;
-                        break;
-
-                    case InflateManagerMode.DICT3:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
-                        mode = InflateManagerMode.DICT2;
-                        break;
-
-                    case InflateManagerMode.DICT2:
-
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
-                        mode = InflateManagerMode.DICT1;
-                        break;
-
-
-                    case InflateManagerMode.DICT1:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
-                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
-                        _codec._Adler32 = expectedCheck;
-                        mode = InflateManagerMode.DICT0;
-                        return ZlibConstants.Z_NEED_DICT;
-
-
-                    case InflateManagerMode.DICT0:
-                        mode = InflateManagerMode.BAD;
-                        _codec.Message = "need dictionary";
-                        marker = 0; // can try inflateSync
-                        return ZlibConstants.Z_STREAM_ERROR;
-
-
-                    case InflateManagerMode.BLOCKS:
-                        r = blocks.Process(r);
-                        if (r == ZlibConstants.Z_DATA_ERROR)
-                        {
-                            mode = InflateManagerMode.BAD;
-                            marker = 0; // can try inflateSync
-                            break;
-                        }
-
-                        if (r == ZlibConstants.Z_OK) r = f;
-
-                        if (r != ZlibConstants.Z_STREAM_END)
-                            return r;
-
-                        r = f;
-                        computedCheck = blocks.Reset();
-                        if (!HandleRfc1950HeaderBytes)
-                        {
-                            mode = InflateManagerMode.DONE;
-                            return ZlibConstants.Z_STREAM_END;
-                        }
-                        mode = InflateManagerMode.CHECK4;
-                        break;
-
-                    case InflateManagerMode.CHECK4:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
-                        mode = InflateManagerMode.CHECK3;
-                        break;
-
-                    case InflateManagerMode.CHECK3:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
-                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
-                        mode = InflateManagerMode.CHECK2;
-                        break;
-
-                    case InflateManagerMode.CHECK2:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--;
-                        _codec.TotalBytesIn++;
-                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
-                        mode = InflateManagerMode.CHECK1;
-                        break;
-
-                    case InflateManagerMode.CHECK1:
-                        if (_codec.AvailableBytesIn == 0) return r;
-                        r = f;
-                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
-                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
-                        if (computedCheck != expectedCheck)
-                        {
-                            mode = InflateManagerMode.BAD;
-                            _codec.Message = "incorrect data check";
-                            marker = 5; // can't try inflateSync
-                            break;
-                        }
-                        mode = InflateManagerMode.DONE;
-                        return ZlibConstants.Z_STREAM_END;
-
-                    case InflateManagerMode.DONE:
-                        return ZlibConstants.Z_STREAM_END;
-
-                    case InflateManagerMode.BAD:
-                        throw new ZlibException(String.Format("Bad state ({0})", _codec.Message));
-
-                    default:
-                        throw new ZlibException("Stream error.");
-
-                }
-            }
-        }
-
-
-
-        internal int SetDictionary(byte[] dictionary)
-        {
-            int index = 0;
-            int length = dictionary.Length;
-            if (mode != InflateManagerMode.DICT0)
-                throw new ZlibException("Stream error.");
-
-            if (Adler.Adler32(1, dictionary, 0, dictionary.Length) != _codec._Adler32)
-            {
-                return ZlibConstants.Z_DATA_ERROR;
-            }
-
-            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
-
-            if (length >= (1 << wbits))
-            {
-                length = (1 << wbits) - 1;
-                index = dictionary.Length - length;
-            }
-            blocks.SetDictionary(dictionary, index, length);
-            mode = InflateManagerMode.BLOCKS;
-            return ZlibConstants.Z_OK;
-        }
-
-
-        private static readonly byte[] mark = new byte[] { 0, 0, 0xff, 0xff };
-
-        internal int Sync()
-        {
-            int n; // number of bytes to look at
-            int p; // pointer to bytes
-            int m; // number of marker bytes found in a row
-            long r, w; // temporaries to save total_in and total_out
-
-            // set up
-            if (mode != InflateManagerMode.BAD)
-            {
-                mode = InflateManagerMode.BAD;
-                marker = 0;
-            }
-            if ((n = _codec.AvailableBytesIn) == 0)
-                return ZlibConstants.Z_BUF_ERROR;
-            p = _codec.NextIn;
-            m = marker;
-
-            // search
-            while (n != 0 && m < 4)
-            {
-                if (_codec.InputBuffer[p] == mark[m])
-                {
-                    m++;
-                }
-                else if (_codec.InputBuffer[p] != 0)
-                {
-                    m = 0;
-                }
-                else
-                {
-                    m = 4 - m;
-                }
-                p++; n--;
-            }
-
-            // restore
-            _codec.TotalBytesIn += p - _codec.NextIn;
-            _codec.NextIn = p;
-            _codec.AvailableBytesIn = n;
-            marker = m;
-
-            // return no joy or set up to restart on a new block
-            if (m != 4)
-            {
-                return ZlibConstants.Z_DATA_ERROR;
-            }
-            r = _codec.TotalBytesIn;
-            w = _codec.TotalBytesOut;
-            Reset();
-            _codec.TotalBytesIn = r;
-            _codec.TotalBytesOut = w;
-            mode = InflateManagerMode.BLOCKS;
-            return ZlibConstants.Z_OK;
-        }
-
-
-        // Returns true if inflate is currently at the end of a block generated
-        // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
-        // implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
-        // but removes the length bytes of the resulting empty stored block. When
-        // decompressing, PPP checks that at the end of input packet, inflate is
-        // waiting for these length bytes.
-        internal int SyncPoint(ZlibCodec z)
-        {
-            return blocks.SyncPoint();
-        }
-    }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/ParallelDeflateOutputStream.cs b/EPPlus/Packaging/DotNetZip/Zlib/ParallelDeflateOutputStream.cs
deleted file mode 100644
index 3fc9685..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/ParallelDeflateOutputStream.cs
+++ /dev/null
@@ -1,1386 +0,0 @@
-//#define Trace
-
-// ParallelDeflateOutputStream.cs
-// ------------------------------------------------------------------
-//
-// A DeflateStream that does compression only, it uses a
-// divide-and-conquer approach with multiple threads to exploit multiple
-// CPUs for the DEFLATE computation.
-//
-// last saved: <2011-July-31 14:49:40>
-//
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 by Dino Chiesa
-// All rights reserved!
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.IO;
-
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    internal class WorkItem
-    {
-        public byte[] buffer;
-        public byte[] compressed;
-        public int crc;
-        public int index;
-        public int ordinal;
-        public int inputBytesAvailable;
-        public int compressedBytesAvailable;
-        public ZlibCodec compressor;
-
-        public WorkItem(int size,
-                        Ionic.Zlib.CompressionLevel compressLevel,
-                        CompressionStrategy strategy,
-                        int ix)
-        {
-            this.buffer= new byte[size];
-            // alloc 5 bytes overhead for every block (margin of safety= 2)
-            int n = size + ((size / 32768)+1) * 5 * 2;
-            this.compressed = new byte[n];
-            this.compressor = new ZlibCodec();
-            this.compressor.InitializeDeflate(compressLevel, false);
-            this.compressor.OutputBuffer = this.compressed;
-            this.compressor.InputBuffer = this.buffer;
-            this.index = ix;
-        }
-    }
-
-    /// <summary>
-    ///   A class for compressing streams using the
-    ///   Deflate algorithm with multiple threads.
-    /// </summary>
-    ///
-    /// <remarks>
-    /// <para>
-    ///   This class performs DEFLATE compression through writing.  For
-    ///   more information on the Deflate algorithm, see IETF RFC 1951,
-    ///   "DEFLATE Compressed Data Format Specification version 1.3."
-    /// </para>
-    ///
-    /// <para>
-    ///   This class is similar to <see cref="Ionic.Zlib.DeflateStream"/>, except
-    ///   that this class is for compression only, and this implementation uses an
-    ///   approach that employs multiple worker threads to perform the DEFLATE.  On
-    ///   a multi-cpu or multi-core computer, the performance of this class can be
-    ///   significantly higher than the single-threaded DeflateStream, particularly
-    ///   for larger streams.  How large?  Anything over 10mb is a good candidate
-    ///   for parallel compression.
-    /// </para>
-    ///
-    /// <para>
-    ///   The tradeoff is that this class uses more memory and more CPU than the
-    ///   vanilla DeflateStream, and also is less efficient as a compressor. For
-    ///   large files the size of the compressed data stream can be less than 1%
-    ///   larger than the size of a compressed data stream from the vanialla
-    ///   DeflateStream.  For smaller files the difference can be larger.  The
-    ///   difference will also be larger if you set the BufferSize to be lower than
-    ///   the default value.  Your mileage may vary. Finally, for small files, the
-    ///   ParallelDeflateOutputStream can be much slower than the vanilla
-    ///   DeflateStream, because of the overhead associated to using the thread
-    ///   pool.
-    /// </para>
-    ///
-    /// </remarks>
-    /// <seealso cref="Ionic.Zlib.DeflateStream" />
-    public class ParallelDeflateOutputStream : System.IO.Stream
-    {
-
-        private static readonly int IO_BUFFER_SIZE_DEFAULT = 64 * 1024;  // 128k
-        private static readonly int BufferPairsPerCore = 4;
-
-        private System.Collections.Generic.List<WorkItem> _pool;
-        private bool                        _leaveOpen;
-        private bool                        emitting;
-        private System.IO.Stream            _outStream;
-        private int                         _maxBufferPairs;
-        private int                         _bufferSize = IO_BUFFER_SIZE_DEFAULT;
-        private AutoResetEvent              _newlyCompressedBlob;
-        //private ManualResetEvent            _writingDone;
-        //private ManualResetEvent            _sessionReset;
-        private object                      _outputLock = new object();
-        private bool                        _isClosed;
-        private bool                        _firstWriteDone;
-        private int                         _currentlyFilling;
-        private int                         _lastFilled;
-        private int                         _lastWritten;
-        private int                         _latestCompressed;
-        private int                         _Crc32;
-        private Ionic.Crc.CRC32             _runningCrc;
-        private object                      _latestLock = new object();
-        private System.Collections.Generic.Queue<int>     _toWrite;
-        private System.Collections.Generic.Queue<int>     _toFill;
-        private Int64                       _totalBytesProcessed;
-        private Ionic.Zlib.CompressionLevel _compressLevel;
-        private volatile Exception          _pendingException;
-        private bool                        _handlingException;
-        private object                      _eLock = new Object();  // protects _pendingException
-
-        // This bitfield is used only when Trace is defined.
-        //private TraceBits _DesiredTrace = TraceBits.Write | TraceBits.WriteBegin |
-        //TraceBits.WriteDone | TraceBits.Lifecycle | TraceBits.Fill | TraceBits.Flush |
-        //TraceBits.Session;
-
-        //private TraceBits _DesiredTrace = TraceBits.WriteBegin | TraceBits.WriteDone | TraceBits.Synch | TraceBits.Lifecycle  | TraceBits.Session ;
-
-        private TraceBits _DesiredTrace =
-            TraceBits.Session |
-            TraceBits.Compress |
-            TraceBits.WriteTake |
-            TraceBits.WriteEnter |
-            TraceBits.EmitEnter |
-            TraceBits.EmitDone |
-            TraceBits.EmitLock |
-            TraceBits.EmitSkip |
-            TraceBits.EmitBegin;
-
-        /// <summary>
-        /// Create a ParallelDeflateOutputStream.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This stream compresses data written into it via the DEFLATE
-        ///   algorithm (see RFC 1951), and writes out the compressed byte stream.
-        /// </para>
-        ///
-        /// <para>
-        ///   The instance will use the default compression level, the default
-        ///   buffer sizes and the default number of threads and buffers per
-        ///   thread.
-        /// </para>
-        ///
-        /// <para>
-        ///   This class is similar to <see cref="Ionic.Zlib.DeflateStream"/>,
-        ///   except that this implementation uses an approach that employs
-        ///   multiple worker threads to perform the DEFLATE.  On a multi-cpu or
-        ///   multi-core computer, the performance of this class can be
-        ///   significantly higher than the single-threaded DeflateStream,
-        ///   particularly for larger streams.  How large?  Anything over 10mb is
-        ///   a good candidate for parallel compression.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        /// This example shows how to use a ParallelDeflateOutputStream to compress
-        /// data.  It reads a file, compresses it, and writes the compressed data to
-        /// a second, output file.
-        ///
-        /// <code>
-        /// byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        /// int n= -1;
-        /// String outputFile = fileToCompress + ".compressed";
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(outputFile))
-        ///     {
-        ///         using (Stream compressor = new ParallelDeflateOutputStream(raw))
-        ///         {
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Dim buffer As Byte() = New Byte(4096) {}
-        /// Dim n As Integer = -1
-        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(outputFile)
-        ///         Using compressor As Stream = New ParallelDeflateOutputStream(raw)
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        /// <param name="stream">The stream to which compressed data will be written.</param>
-        public ParallelDeflateOutputStream(System.IO.Stream stream)
-            : this(stream, CompressionLevel.Default, CompressionStrategy.Default, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a ParallelDeflateOutputStream using the specified CompressionLevel.
-        /// </summary>
-        /// <remarks>
-        ///   See the <see cref="ParallelDeflateOutputStream(System.IO.Stream)"/>
-        ///   constructor for example code.
-        /// </remarks>
-        /// <param name="stream">The stream to which compressed data will be written.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public ParallelDeflateOutputStream(System.IO.Stream stream, CompressionLevel level)
-            : this(stream, level, CompressionStrategy.Default, false)
-        {
-        }
-
-        /// <summary>
-        /// Create a ParallelDeflateOutputStream and specify whether to leave the captive stream open
-        /// when the ParallelDeflateOutputStream is closed.
-        /// </summary>
-        /// <remarks>
-        ///   See the <see cref="ParallelDeflateOutputStream(System.IO.Stream)"/>
-        ///   constructor for example code.
-        /// </remarks>
-        /// <param name="stream">The stream to which compressed data will be written.</param>
-        /// <param name="leaveOpen">
-        ///    true if the application would like the stream to remain open after inflation/deflation.
-        /// </param>
-        public ParallelDeflateOutputStream(System.IO.Stream stream, bool leaveOpen)
-            : this(stream, CompressionLevel.Default, CompressionStrategy.Default, leaveOpen)
-        {
-        }
-
-        /// <summary>
-        /// Create a ParallelDeflateOutputStream and specify whether to leave the captive stream open
-        /// when the ParallelDeflateOutputStream is closed.
-        /// </summary>
-        /// <remarks>
-        ///   See the <see cref="ParallelDeflateOutputStream(System.IO.Stream)"/>
-        ///   constructor for example code.
-        /// </remarks>
-        /// <param name="stream">The stream to which compressed data will be written.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        /// <param name="leaveOpen">
-        ///    true if the application would like the stream to remain open after inflation/deflation.
-        /// </param>
-        public ParallelDeflateOutputStream(System.IO.Stream stream, CompressionLevel level, bool leaveOpen)
-            : this(stream, CompressionLevel.Default, CompressionStrategy.Default, leaveOpen)
-        {
-        }
-
-        /// <summary>
-        /// Create a ParallelDeflateOutputStream using the specified
-        /// CompressionLevel and CompressionStrategy, and specifying whether to
-        /// leave the captive stream open when the ParallelDeflateOutputStream is
-        /// closed.
-        /// </summary>
-        /// <remarks>
-        ///   See the <see cref="ParallelDeflateOutputStream(System.IO.Stream)"/>
-        ///   constructor for example code.
-        /// </remarks>
-        /// <param name="stream">The stream to which compressed data will be written.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        /// <param name="strategy">
-        ///   By tweaking this parameter, you may be able to optimize the compression for
-        ///   data with particular characteristics.
-        /// </param>
-        /// <param name="leaveOpen">
-        ///    true if the application would like the stream to remain open after inflation/deflation.
-        /// </param>
-        public ParallelDeflateOutputStream(System.IO.Stream stream,
-                                           CompressionLevel level,
-                                           CompressionStrategy strategy,
-                                           bool leaveOpen)
-        {
-            TraceOutput(TraceBits.Lifecycle | TraceBits.Session, "-------------------------------------------------------");
-            TraceOutput(TraceBits.Lifecycle | TraceBits.Session, "Create {0:X8}", this.GetHashCode());
-            _outStream = stream;
-            _compressLevel= level;
-            Strategy = strategy;
-            _leaveOpen = leaveOpen;
-            this.MaxBufferPairs = 16; // default
-        }
-
-
-        /// <summary>
-        ///   The ZLIB strategy to be used during compression.
-        /// </summary>
-        ///
-        public CompressionStrategy Strategy
-        {
-            get;
-            private set;
-        }
-
-        /// <summary>
-        ///   The maximum number of buffer pairs to use.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   This property sets an upper limit on the number of memory buffer
-        ///   pairs to create.  The implementation of this stream allocates
-        ///   multiple buffers to facilitate parallel compression.  As each buffer
-        ///   fills up, this stream uses <see
-        ///   cref="System.Threading.ThreadPool.QueueUserWorkItem(WaitCallback)">
-        ///   ThreadPool.QueueUserWorkItem()</see>
-        ///   to compress those buffers in a background threadpool thread. After a
-        ///   buffer is compressed, it is re-ordered and written to the output
-        ///   stream.
-        /// </para>
-        ///
-        /// <para>
-        ///   A higher number of buffer pairs enables a higher degree of
-        ///   parallelism, which tends to increase the speed of compression on
-        ///   multi-cpu computers.  On the other hand, a higher number of buffer
-        ///   pairs also implies a larger memory consumption, more active worker
-        ///   threads, and a higher cpu utilization for any compression. This
-        ///   property enables the application to limit its memory consumption and
-        ///   CPU utilization behavior depending on requirements.
-        /// </para>
-        ///
-        /// <para>
-        ///   For each compression "task" that occurs in parallel, there are 2
-        ///   buffers allocated: one for input and one for output.  This property
-        ///   sets a limit for the number of pairs.  The total amount of storage
-        ///   space allocated for buffering will then be (N*S*2), where N is the
-        ///   number of buffer pairs, S is the size of each buffer (<see
-        ///   cref="BufferSize"/>).  By default, DotNetZip allocates 4 buffer
-        ///   pairs per CPU core, so if your machine has 4 cores, and you retain
-        ///   the default buffer size of 128k, then the
-        ///   ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer
-        ///   memory in total, or 4mb, in blocks of 128kb.  If you then set this
-        ///   property to 8, then the number will be 8 * 2 * 128kb of buffer
-        ///   memory, or 2mb.
-        /// </para>
-        ///
-        /// <para>
-        ///   CPU utilization will also go up with additional buffers, because a
-        ///   larger number of buffer pairs allows a larger number of background
-        ///   threads to compress in parallel. If you find that parallel
-        ///   compression is consuming too much memory or CPU, you can adjust this
-        ///   value downward.
-        /// </para>
-        ///
-        /// <para>
-        ///   The default value is 16. Different values may deliver better or
-        ///   worse results, depending on your priorities and the dynamic
-        ///   performance characteristics of your storage and compute resources.
-        /// </para>
-        ///
-        /// <para>
-        ///   This property is not the number of buffer pairs to use; it is an
-        ///   upper limit. An illustration: Suppose you have an application that
-        ///   uses the default value of this property (which is 16), and it runs
-        ///   on a machine with 2 CPU cores. In that case, DotNetZip will allocate
-        ///   4 buffer pairs per CPU core, for a total of 8 pairs.  The upper
-        ///   limit specified by this property has no effect.
-        /// </para>
-        ///
-        /// <para>
-        ///   The application can set this value at any time, but it is effective
-        ///   only before the first call to Write(), which is when the buffers are
-        ///   allocated.
-        /// </para>
-        /// </remarks>
-        public int MaxBufferPairs
-        {
-            get
-            {
-                return _maxBufferPairs;
-            }
-            set
-            {
-                if (value < 4)
-                    throw new ArgumentException("MaxBufferPairs",
-                                                "Value must be 4 or greater.");
-                _maxBufferPairs = value;
-            }
-        }
-
-        /// <summary>
-        ///   The size of the buffers used by the compressor threads.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   The default buffer size is 128k. The application can set this value
-        ///   at any time, but it is effective only before the first Write().
-        /// </para>
-        ///
-        /// <para>
-        ///   Larger buffer sizes implies larger memory consumption but allows
-        ///   more efficient compression. Using smaller buffer sizes consumes less
-        ///   memory but may result in less effective compression.  For example,
-        ///   using the default buffer size of 128k, the compression delivered is
-        ///   within 1% of the compression delivered by the single-threaded <see
-        ///   cref="Ionic.Zlib.DeflateStream"/>.  On the other hand, using a
-        ///   BufferSize of 8k can result in a compressed data stream that is 5%
-        ///   larger than that delivered by the single-threaded
-        ///   <c>DeflateStream</c>.  Excessively small buffer sizes can also cause
-        ///   the speed of the ParallelDeflateOutputStream to drop, because of
-        ///   larger thread scheduling overhead dealing with many many small
-        ///   buffers.
-        /// </para>
-        ///
-        /// <para>
-        ///   The total amount of storage space allocated for buffering will be
-        ///   (N*S*2), where N is the number of buffer pairs, and S is the size of
-        ///   each buffer (this property). There are 2 buffers used by the
-        ///   compressor, one for input and one for output.  By default, DotNetZip
-        ///   allocates 4 buffer pairs per CPU core, so if your machine has 4
-        ///   cores, then the number of buffer pairs used will be 16. If you
-        ///   accept the default value of this property, 128k, then the
-        ///   ParallelDeflateOutputStream will use 16 * 2 * 128kb of buffer memory
-        ///   in total, or 4mb, in blocks of 128kb.  If you set this property to
-        ///   64kb, then the number will be 16 * 2 * 64kb of buffer memory, or
-        ///   2mb.
-        /// </para>
-        ///
-        /// </remarks>
-        public int BufferSize
-        {
-            get { return _bufferSize;}
-            set
-            {
-                if (value < 1024)
-                    throw new ArgumentOutOfRangeException("BufferSize",
-                                                          "BufferSize must be greater than 1024 bytes");
-                _bufferSize = value;
-            }
-        }
-
-        /// <summary>
-        /// The CRC32 for the data that was written out, prior to compression.
-        /// </summary>
-        /// <remarks>
-        /// This value is meaningful only after a call to Close().
-        /// </remarks>
-        public int Crc32 { get { return _Crc32; } }
-
-
-        /// <summary>
-        /// The total number of uncompressed bytes processed by the ParallelDeflateOutputStream.
-        /// </summary>
-        /// <remarks>
-        /// This value is meaningful only after a call to Close().
-        /// </remarks>
-        public Int64 BytesProcessed { get { return _totalBytesProcessed; } }
-
-
-        private void _InitializePoolOfWorkItems()
-        {
-            _toWrite = new Queue<int>();
-            _toFill = new Queue<int>();
-            _pool = new System.Collections.Generic.List<WorkItem>();
-            int nTasks = BufferPairsPerCore * Environment.ProcessorCount;
-            nTasks = Math.Min(nTasks, _maxBufferPairs);
-            for(int i=0; i < nTasks; i++)
-            {
-                _pool.Add(new WorkItem(_bufferSize, _compressLevel, Strategy, i));
-                _toFill.Enqueue(i);
-            }
-
-            _newlyCompressedBlob = new AutoResetEvent(false);
-            _runningCrc = new Ionic.Crc.CRC32();
-            _currentlyFilling = -1;
-            _lastFilled = -1;
-            _lastWritten = -1;
-            _latestCompressed = -1;
-        }
-
-
-
-
-        /// <summary>
-        ///   Write data to the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   To use the ParallelDeflateOutputStream to compress data, create a
-        ///   ParallelDeflateOutputStream with CompressionMode.Compress, passing a
-        ///   writable output stream.  Then call Write() on that
-        ///   ParallelDeflateOutputStream, providing uncompressed data as input.  The
-        ///   data sent to the output stream will be the compressed form of the data
-        ///   written.
-        /// </para>
-        ///
-        /// <para>
-        ///   To decompress data, use the <see cref="Ionic.Zlib.DeflateStream"/> class.
-        /// </para>
-        ///
-        /// </remarks>
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            bool mustWait = false;
-
-            // This method does this:
-            //   0. handles any pending exceptions
-            //   1. write any buffers that are ready to be written,
-            //   2. fills a work buffer; when full, flip state to 'Filled',
-            //   3. if more data to be written,  goto step 1
-
-            if (_isClosed)
-                throw new InvalidOperationException();
-
-            // dispense any exceptions that occurred on the BG threads
-            if (_pendingException != null)
-            {
-                _handlingException = true;
-                var pe = _pendingException;
-                _pendingException = null;
-                throw pe;
-            }
-
-            if (count == 0) return;
-
-            if (!_firstWriteDone)
-            {
-                // Want to do this on first Write, first session, and not in the
-                // constructor.  We want to allow MaxBufferPairs to
-                // change after construction, but before first Write.
-                _InitializePoolOfWorkItems();
-                _firstWriteDone = true;
-            }
-
-
-            do
-            {
-                // may need to make buffers available
-                EmitPendingBuffers(false, mustWait);
-
-                mustWait = false;
-                // use current buffer, or get a new buffer to fill
-                int ix = -1;
-                if (_currentlyFilling >= 0)
-                {
-                    ix = _currentlyFilling;
-                    TraceOutput(TraceBits.WriteTake,
-                                "Write    notake   wi({0}) lf({1})",
-                                ix,
-                                _lastFilled);
-                }
-                else
-                {
-                    TraceOutput(TraceBits.WriteTake, "Write    take?");
-                    if (_toFill.Count == 0)
-                    {
-                        // no available buffers, so... need to emit
-                        // compressed buffers.
-                        mustWait = true;
-                        continue;
-                    }
-
-                    ix = _toFill.Dequeue();
-                    TraceOutput(TraceBits.WriteTake,
-                                "Write    take     wi({0}) lf({1})",
-                                ix,
-                                _lastFilled);
-                    ++_lastFilled; // TODO: consider rollover?
-                }
-
-                WorkItem workitem = _pool[ix];
-
-                int limit = ((workitem.buffer.Length - workitem.inputBytesAvailable) > count)
-                    ? count
-                    : (workitem.buffer.Length - workitem.inputBytesAvailable);
-
-                workitem.ordinal = _lastFilled;
-
-                TraceOutput(TraceBits.Write,
-                            "Write    lock     wi({0}) ord({1}) iba({2})",
-                            workitem.index,
-                            workitem.ordinal,
-                            workitem.inputBytesAvailable
-                            );
-
-                // copy from the provided buffer to our workitem, starting at
-                // the tail end of whatever data we might have in there currently.
-                Buffer.BlockCopy(buffer,
-                                 offset,
-                                 workitem.buffer,
-                                 workitem.inputBytesAvailable,
-                                 limit);
-
-                count -= limit;
-                offset += limit;
-                workitem.inputBytesAvailable += limit;
-                if (workitem.inputBytesAvailable == workitem.buffer.Length)
-                {
-                    // No need for interlocked.increment: the Write()
-                    // method is documented as not multi-thread safe, so
-                    // we can assume Write() calls come in from only one
-                    // thread.
-                    TraceOutput(TraceBits.Write,
-                                "Write    QUWI     wi({0}) ord({1}) iba({2}) nf({3})",
-                                workitem.index,
-                                workitem.ordinal,
-                                workitem.inputBytesAvailable );
-
-                    if (!ThreadPool.QueueUserWorkItem( _DeflateOne, workitem ))
-                        throw new Exception("Cannot enqueue workitem");
-
-                    _currentlyFilling = -1; // will get a new buffer next time
-                }
-                else
-                    _currentlyFilling = ix;
-
-                if (count > 0)
-                    TraceOutput(TraceBits.WriteEnter, "Write    more");
-            }
-            while (count > 0);  // until no more to write
-
-            TraceOutput(TraceBits.WriteEnter, "Write    exit");
-            return;
-        }
-
-
-
-        private void _FlushFinish()
-        {
-            // After writing a series of compressed buffers, each one closed
-            // with Flush.Sync, we now write the final one as Flush.Finish,
-            // and then stop.
-            byte[] buffer = new byte[128];
-            var compressor = new ZlibCodec();
-            int rc = compressor.InitializeDeflate(_compressLevel, false);
-            compressor.InputBuffer = null;
-            compressor.NextIn = 0;
-            compressor.AvailableBytesIn = 0;
-            compressor.OutputBuffer = buffer;
-            compressor.NextOut = 0;
-            compressor.AvailableBytesOut = buffer.Length;
-            rc = compressor.Deflate(FlushType.Finish);
-
-            if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
-                throw new Exception("deflating: " + compressor.Message);
-
-            if (buffer.Length - compressor.AvailableBytesOut > 0)
-            {
-                TraceOutput(TraceBits.EmitBegin,
-                            "Emit     begin    flush bytes({0})",
-                            buffer.Length - compressor.AvailableBytesOut);
-
-                _outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
-
-                TraceOutput(TraceBits.EmitDone,
-                            "Emit     done     flush");
-            }
-
-            compressor.EndDeflate();
-
-            _Crc32 = _runningCrc.Crc32Result;
-        }
-
-
-        private void _Flush(bool lastInput)
-        {
-            if (_isClosed)
-                throw new InvalidOperationException();
-
-            if (emitting) return;
-
-            // compress any partial buffer
-            if (_currentlyFilling >= 0)
-            {
-                WorkItem workitem = _pool[_currentlyFilling];
-                _DeflateOne(workitem);
-                _currentlyFilling = -1; // get a new buffer next Write()
-            }
-
-            if (lastInput)
-            {
-                EmitPendingBuffers(true, false);
-                _FlushFinish();
-            }
-            else
-            {
-                EmitPendingBuffers(false, false);
-            }
-        }
-
-
-
-        /// <summary>
-        /// Flush the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            if (_pendingException != null)
-            {
-                _handlingException = true;
-                var pe = _pendingException;
-                _pendingException = null;
-                throw pe;
-            }
-            if (_handlingException)
-                return;
-
-            _Flush(false);
-        }
-
-
-        /// <summary>
-        /// Close the stream.
-        /// </summary>
-        /// <remarks>
-        /// You must call Close on the stream to guarantee that all of the data written in has
-        /// been compressed, and the compressed data has been written out.
-        /// </remarks>
-        public override void Close()
-        {
-            TraceOutput(TraceBits.Session, "Close {0:X8}", this.GetHashCode());
-
-            if (_pendingException != null)
-            {
-                _handlingException = true;
-                var pe = _pendingException;
-                _pendingException = null;
-                throw pe;
-            }
-
-            if (_handlingException)
-                return;
-
-            if (_isClosed) return;
-
-            _Flush(true);
-
-            if (!_leaveOpen)
-                _outStream.Close();
-
-            _isClosed= true;
-        }
-
-
-
-        // workitem 10030 - implement a new Dispose method
-
-        /// <summary>Dispose the object</summary>
-        /// <remarks>
-        ///   <para>
-        ///     Because ParallelDeflateOutputStream is IDisposable, the
-        ///     application must call this method when finished using the instance.
-        ///   </para>
-        ///   <para>
-        ///     This method is generally called implicitly upon exit from
-        ///     a <c>using</c> scope in C# (<c>Using</c> in VB).
-        ///   </para>
-        /// </remarks>
-        new public void Dispose()
-        {
-            TraceOutput(TraceBits.Lifecycle, "Dispose  {0:X8}", this.GetHashCode());
-            Close();
-            _pool = null;
-            Dispose(true);
-        }
-
-
-
-        /// <summary>The Dispose method</summary>
-        /// <param name="disposing">
-        ///   indicates whether the Dispose method was invoked by user code.
-        /// </param>
-        protected override void Dispose(bool disposing)
-        {
-            base.Dispose(disposing);
-        }
-
-
-        /// <summary>
-        ///   Resets the stream for use with another stream.
-        /// </summary>
-        /// <remarks>
-        ///   Because the ParallelDeflateOutputStream is expensive to create, it
-        ///   has been designed so that it can be recycled and re-used.  You have
-        ///   to call Close() on the stream first, then you can call Reset() on
-        ///   it, to use it again on another stream.
-        /// </remarks>
-        ///
-        /// <param name="stream">
-        ///   The new output stream for this era.
-        /// </param>
-        ///
-        /// <example>
-        /// <code>
-        /// ParallelDeflateOutputStream deflater = null;
-        /// foreach (var inputFile in listOfFiles)
-        /// {
-        ///     string outputFile = inputFile + ".compressed";
-        ///     using (System.IO.Stream input = System.IO.File.OpenRead(inputFile))
-        ///     {
-        ///         using (var outStream = System.IO.File.Create(outputFile))
-        ///         {
-        ///             if (deflater == null)
-        ///                 deflater = new ParallelDeflateOutputStream(outStream,
-        ///                                                            CompressionLevel.Best,
-        ///                                                            CompressionStrategy.Default,
-        ///                                                            true);
-        ///             deflater.Reset(outStream);
-        ///
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 deflater.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        public void Reset(Stream stream)
-        {
-            TraceOutput(TraceBits.Session, "-------------------------------------------------------");
-            TraceOutput(TraceBits.Session, "Reset {0:X8} firstDone({1})", this.GetHashCode(), _firstWriteDone);
-
-            if (!_firstWriteDone) return;
-
-            // reset all status
-            _toWrite.Clear();
-            _toFill.Clear();
-            foreach (var workitem in _pool)
-            {
-                _toFill.Enqueue(workitem.index);
-                workitem.ordinal = -1;
-            }
-
-            _firstWriteDone = false;
-            _totalBytesProcessed = 0L;
-            _runningCrc = new Ionic.Crc.CRC32();
-            _isClosed= false;
-            _currentlyFilling = -1;
-            _lastFilled = -1;
-            _lastWritten = -1;
-            _latestCompressed = -1;
-            _outStream = stream;
-        }
-
-
-
-
-        private void EmitPendingBuffers(bool doAll, bool mustWait)
-        {
-            // When combining parallel deflation with a ZipSegmentedStream, it's
-            // possible for the ZSS to throw from within this method.  In that
-            // case, Close/Dispose will be called on this stream, if this stream
-            // is employed within a using or try/finally pair as required. But
-            // this stream is unaware of the pending exception, so the Close()
-            // method invokes this method AGAIN.  This can lead to a deadlock.
-            // Therefore, failfast if re-entering.
-
-            if (emitting) return;
-            emitting = true;
-            if (doAll || mustWait)
-                _newlyCompressedBlob.WaitOne();
-
-            do
-            {
-                int firstSkip = -1;
-                int millisecondsToWait = doAll ? 200 : (mustWait ? -1 : 0);
-                int nextToWrite = -1;
-
-                do
-                {
-                    if (Monitor.TryEnter(_toWrite, millisecondsToWait))
-                    {
-                        nextToWrite = -1;
-                        try
-                        {
-                            if (_toWrite.Count > 0)
-                                nextToWrite = _toWrite.Dequeue();
-                        }
-                        finally
-                        {
-                            Monitor.Exit(_toWrite);
-                        }
-
-                        if (nextToWrite >= 0)
-                        {
-                            WorkItem workitem = _pool[nextToWrite];
-                            if (workitem.ordinal != _lastWritten + 1)
-                            {
-                                // out of order. requeue and try again.
-                                TraceOutput(TraceBits.EmitSkip,
-                                            "Emit     skip     wi({0}) ord({1}) lw({2}) fs({3})",
-                                            workitem.index,
-                                            workitem.ordinal,
-                                            _lastWritten,
-                                            firstSkip);
-
-                                lock(_toWrite)
-                                {
-                                    _toWrite.Enqueue(nextToWrite);
-                                }
-
-                                if (firstSkip == nextToWrite)
-                                {
-                                    // We went around the list once.
-                                    // None of the items in the list is the one we want.
-                                    // Now wait for a compressor to signal again.
-                                    _newlyCompressedBlob.WaitOne();
-                                    firstSkip = -1;
-                                }
-                                else if (firstSkip == -1)
-                                    firstSkip = nextToWrite;
-
-                                continue;
-                            }
-
-                            firstSkip = -1;
-
-                            TraceOutput(TraceBits.EmitBegin,
-                                        "Emit     begin    wi({0}) ord({1})              cba({2})",
-                                        workitem.index,
-                                        workitem.ordinal,
-                                        workitem.compressedBytesAvailable);
-
-                            _outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable);
-                            _runningCrc.Combine(workitem.crc, workitem.inputBytesAvailable);
-                            _totalBytesProcessed += workitem.inputBytesAvailable;
-                            workitem.inputBytesAvailable = 0;
-
-                            TraceOutput(TraceBits.EmitDone,
-                                        "Emit     done     wi({0}) ord({1})              cba({2}) mtw({3})",
-                                        workitem.index,
-                                        workitem.ordinal,
-                                        workitem.compressedBytesAvailable,
-                                        millisecondsToWait);
-
-                            _lastWritten = workitem.ordinal;
-                            _toFill.Enqueue(workitem.index);
-
-                            // don't wait next time through
-                            if (millisecondsToWait == -1) millisecondsToWait = 0;
-                        }
-                    }
-                    else
-                        nextToWrite = -1;
-
-                } while (nextToWrite >= 0);
-
-            //} while (doAll && (_lastWritten != _latestCompressed));
-            } while (doAll && (_lastWritten != _latestCompressed || _lastWritten != _lastFilled));
-
-            emitting = false;
-        }
-
-
-
-#if OLD
-        private void _PerpetualWriterMethod(object state)
-        {
-            TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod START");
-
-            try
-            {
-                do
-                {
-                    // wait for the next session
-                    TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch    _sessionReset.WaitOne(begin) PWM");
-                    _sessionReset.WaitOne();
-                    TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch    _sessionReset.WaitOne(done)  PWM");
-
-                    if (_isDisposed) break;
-
-                    TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch    _sessionReset.Reset()        PWM");
-                    _sessionReset.Reset();
-
-                    // repeatedly write buffers as they become ready
-                    WorkItem workitem = null;
-                    Ionic.Zlib.CRC32 c= new Ionic.Zlib.CRC32();
-                    do
-                    {
-                        workitem = _pool[_nextToWrite % _pc];
-                        lock(workitem)
-                        {
-                            if (_noMoreInputForThisSegment)
-                                TraceOutput(TraceBits.Write,
-                                               "Write    drain    wi({0}) stat({1}) canuse({2})  cba({3})",
-                                               workitem.index,
-                                               workitem.status,
-                                               (workitem.status == (int)WorkItem.Status.Compressed),
-                                               workitem.compressedBytesAvailable);
-
-                            do
-                            {
-                                if (workitem.status == (int)WorkItem.Status.Compressed)
-                                {
-                                    TraceOutput(TraceBits.WriteBegin,
-                                                   "Write    begin    wi({0}) stat({1})              cba({2})",
-                                                   workitem.index,
-                                                   workitem.status,
-                                                   workitem.compressedBytesAvailable);
-
-                                    workitem.status = (int)WorkItem.Status.Writing;
-                                    _outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable);
-                                    c.Combine(workitem.crc, workitem.inputBytesAvailable);
-                                    _totalBytesProcessed += workitem.inputBytesAvailable;
-                                    _nextToWrite++;
-                                    workitem.inputBytesAvailable= 0;
-                                    workitem.status = (int)WorkItem.Status.Done;
-
-                                    TraceOutput(TraceBits.WriteDone,
-                                                   "Write    done     wi({0}) stat({1})              cba({2})",
-                                                   workitem.index,
-                                                   workitem.status,
-                                                   workitem.compressedBytesAvailable);
-
-
-                                    Monitor.Pulse(workitem);
-                                    break;
-                                }
-                                else
-                                {
-                                    int wcycles = 0;
-                                    // I've locked a workitem I cannot use.
-                                    // Therefore, wake someone else up, and then release the lock.
-                                    while (workitem.status != (int)WorkItem.Status.Compressed)
-                                    {
-                                        TraceOutput(TraceBits.WriteWait,
-                                                       "Write    waiting  wi({0}) stat({1}) nw({2}) nf({3}) nomore({4})",
-                                                       workitem.index,
-                                                       workitem.status,
-                                                       _nextToWrite, _nextToFill,
-                                                       _noMoreInputForThisSegment );
-
-                                        if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
-                                            break;
-
-                                        wcycles++;
-
-                                        // wake up someone else
-                                        Monitor.Pulse(workitem);
-                                        // release and wait
-                                        Monitor.Wait(workitem);
-
-                                        if (workitem.status == (int)WorkItem.Status.Compressed)
-                                            TraceOutput(TraceBits.WriteWait,
-                                                           "Write    A-OK     wi({0}) stat({1}) iba({2}) cba({3}) cyc({4})",
-                                                           workitem.index,
-                                                           workitem.status,
-                                                           workitem.inputBytesAvailable,
-                                                           workitem.compressedBytesAvailable,
-                                                           wcycles);
-                                    }
-
-                                    if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
-                                        break;
-
-                                }
-                            }
-                            while (true);
-                        }
-
-                        if (_noMoreInputForThisSegment)
-                            TraceOutput(TraceBits.Write,
-                                           "Write    nomore  nw({0}) nf({1}) break({2})",
-                                           _nextToWrite, _nextToFill, (_nextToWrite == _nextToFill));
-
-                        if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
-                            break;
-
-                    } while (true);
-
-
-                    // Finish:
-                    // After writing a series of buffers, closing each one with
-                    // Flush.Sync, we now write the final one as Flush.Finish, and
-                    // then stop.
-                    byte[] buffer = new byte[128];
-                    ZlibCodec compressor = new ZlibCodec();
-                    int rc = compressor.InitializeDeflate(_compressLevel, false);
-                    compressor.InputBuffer = null;
-                    compressor.NextIn = 0;
-                    compressor.AvailableBytesIn = 0;
-                    compressor.OutputBuffer = buffer;
-                    compressor.NextOut = 0;
-                    compressor.AvailableBytesOut = buffer.Length;
-                    rc = compressor.Deflate(FlushType.Finish);
-
-                    if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
-                        throw new Exception("deflating: " + compressor.Message);
-
-                    if (buffer.Length - compressor.AvailableBytesOut > 0)
-                    {
-                        TraceOutput(TraceBits.WriteBegin,
-                                       "Write    begin    flush bytes({0})",
-                                       buffer.Length - compressor.AvailableBytesOut);
-
-                        _outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
-
-                        TraceOutput(TraceBits.WriteBegin,
-                                       "Write    done     flush");
-                    }
-
-                    compressor.EndDeflate();
-
-                    _Crc32 = c.Crc32Result;
-
-                    // signal that writing is complete:
-                    TraceOutput(TraceBits.Synch, "Synch    _writingDone.Set()           PWM");
-                    _writingDone.Set();
-                }
-                while (true);
-            }
-            catch (System.Exception exc1)
-            {
-                lock(_eLock)
-                {
-                    // expose the exception to the main thread
-                    if (_pendingException!=null)
-                        _pendingException = exc1;
-                }
-            }
-
-            TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod FINIS");
-        }
-#endif
-
-
-
-
-        private void _DeflateOne(Object wi)
-        {
-            // compress one buffer
-            WorkItem workitem = (WorkItem) wi;
-            try
-            {
-                int myItem = workitem.index;
-                Ionic.Crc.CRC32 crc = new Ionic.Crc.CRC32();
-
-                // calc CRC on the buffer
-                crc.SlurpBlock(workitem.buffer, 0, workitem.inputBytesAvailable);
-
-                // deflate it
-                DeflateOneSegment(workitem);
-
-                // update status
-                workitem.crc = crc.Crc32Result;
-                TraceOutput(TraceBits.Compress,
-                            "Compress          wi({0}) ord({1}) len({2})",
-                            workitem.index,
-                            workitem.ordinal,
-                            workitem.compressedBytesAvailable
-                            );
-
-                lock(_latestLock)
-                {
-                    if (workitem.ordinal > _latestCompressed)
-                        _latestCompressed = workitem.ordinal;
-                }
-                lock (_toWrite)
-                {
-                    _toWrite.Enqueue(workitem.index);
-                }
-                _newlyCompressedBlob.Set();
-            }
-            catch (System.Exception exc1)
-            {
-                lock(_eLock)
-                {
-                    // expose the exception to the main thread
-                    if (_pendingException!=null)
-                        _pendingException = exc1;
-                }
-            }
-        }
-
-
-
-
-        private bool DeflateOneSegment(WorkItem workitem)
-        {
-            ZlibCodec compressor = workitem.compressor;
-            int rc= 0;
-            compressor.ResetDeflate();
-            compressor.NextIn = 0;
-
-            compressor.AvailableBytesIn = workitem.inputBytesAvailable;
-
-            // step 1: deflate the buffer
-            compressor.NextOut = 0;
-            compressor.AvailableBytesOut =  workitem.compressed.Length;
-            do
-            {
-                compressor.Deflate(FlushType.None);
-            }
-            while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
-
-            // step 2: flush (sync)
-            rc = compressor.Deflate(FlushType.Sync);
-
-            workitem.compressedBytesAvailable= (int) compressor.TotalBytesOut;
-            return true;
-        }
-
-
-        [System.Diagnostics.ConditionalAttribute("Trace")]
-        private void TraceOutput(TraceBits bits, string format, params object[] varParams)
-        {
-            if ((bits & _DesiredTrace) != 0)
-            {
-                lock(_outputLock)
-                {
-                    int tid = Thread.CurrentThread.GetHashCode();
-#if !SILVERLIGHT
-                    Console.ForegroundColor = (ConsoleColor) (tid % 8 + 8);
-#endif
-                    Console.Write("{0:000} PDOS ", tid);
-                    Console.WriteLine(format, varParams);
-#if !SILVERLIGHT
-                    Console.ResetColor();
-#endif
-                }
-            }
-        }
-
-
-        // used only when Trace is defined
-        [Flags]
-        enum TraceBits : uint
-        {
-            None         = 0,
-            NotUsed1     = 1,
-            EmitLock     = 2,
-            EmitEnter    = 4,    // enter _EmitPending
-            EmitBegin    = 8,    // begin to write out
-            EmitDone     = 16,   // done writing out
-            EmitSkip     = 32,   // writer skipping a workitem
-            EmitAll      = 58,   // All Emit flags
-            Flush        = 64,
-            Lifecycle    = 128,  // constructor/disposer
-            Session      = 256,  // Close/Reset
-            Synch        = 512,  // thread synchronization
-            Instance     = 1024, // instance settings
-            Compress     = 2048,  // compress task
-            Write        = 4096,    // filling buffers, when caller invokes Write()
-            WriteEnter   = 8192,    // upon entry to Write()
-            WriteTake    = 16384,    // on _toFill.Take()
-            All          = 0xffffffff,
-        }
-
-
-
-        /// <summary>
-        /// Indicates whether the stream supports Seek operations.
-        /// </summary>
-        /// <remarks>
-        /// Always returns false.
-        /// </remarks>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the stream supports Read operations.
-        /// </summary>
-        /// <remarks>
-        /// Always returns false.
-        /// </remarks>
-        public override bool CanRead
-        {
-            get {return false;}
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports Write operations.
-        /// </summary>
-        /// <remarks>
-        /// Returns true if the provided stream is writable.
-        /// </remarks>
-        public override bool CanWrite
-        {
-            get { return _outStream.CanWrite; }
-        }
-
-        /// <summary>
-        /// Reading this property always throws a NotSupportedException.
-        /// </summary>
-        public override long Length
-        {
-            get { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        /// Returns the current position of the output stream.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     Because the output gets written by a background thread,
-        ///     the value may change asynchronously.  Setting this
-        ///     property always throws a NotSupportedException.
-        ///   </para>
-        /// </remarks>
-        public override long Position
-        {
-            get { return _outStream.Position; }
-            set { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="buffer">
-        ///   The buffer into which data would be read, IF THIS METHOD
-        ///   ACTUALLY DID ANYTHING.
-        /// </param>
-        /// <param name="offset">
-        ///   The offset within that data array at which to insert the
-        ///   data that is read, IF THIS METHOD ACTUALLY DID
-        ///   ANYTHING.
-        /// </param>
-        /// <param name="count">
-        ///   The number of bytes to write, IF THIS METHOD ACTUALLY DID
-        ///   ANYTHING.
-        /// </param>
-        /// <returns>nothing.</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="offset">
-        ///   The offset to seek to....
-        ///   IF THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        /// <param name="origin">
-        ///   The reference specifying how to apply the offset....  IF
-        ///   THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        /// <returns>nothing. It always throws.</returns>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// This method always throws a NotSupportedException.
-        /// </summary>
-        /// <param name="value">
-        ///   The new value for the stream length....  IF
-        ///   THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-    }
-
-}
-
-
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/Tree.cs b/EPPlus/Packaging/DotNetZip/Zlib/Tree.cs
deleted file mode 100644
index c411d08..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/Tree.cs
+++ /dev/null
@@ -1,423 +0,0 @@
-// Tree.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-October-28 13:29:50>
-//
-// ------------------------------------------------------------------
-//
-// This module defines classes for zlib compression and
-// decompression. This code is derived from the jzlib implementation of
-// zlib. In keeping with the license for jzlib, the copyright to that
-// code is below.
-//
-// ------------------------------------------------------------------
-// 
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright 
-// notice, this list of conditions and the following disclaimer in 
-// the documentation and/or other materials provided with the distribution.
-// 
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    sealed class Tree
-    {
-        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
-                
-        // extra bits for each length code
-        internal static readonly int[] ExtraLengthBits = new int[]
-        {
-            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
-        };
-                
-        // extra bits for each distance code
-        internal static readonly int[] ExtraDistanceBits = new int[]
-        {
-            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
-        };
-                
-        // extra bits for each bit length code
-        internal static readonly int[] extra_blbits = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};
-                
-        internal static readonly sbyte[] bl_order = new sbyte[]{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-                
-                
-        // The lengths of the bit length codes are sent in order of decreasing
-        // probability, to avoid transmitting the lengths for unused bit
-        // length codes.
-                
-        internal const int Buf_size = 8 * 2;
-                
-        // see definition of array dist_code below
-        //internal const int DIST_CODE_LEN = 512;
-                
-        private static readonly sbyte[] _dist_code = new sbyte[]
-        {
-            0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7, 
-            8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,
-            10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
-            11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
-            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
-            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
-            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
-            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
-            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
-            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
-            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
-            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
-            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
-            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
-            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
-            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
-            0,   0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 
-            22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 
-            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
-            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
-            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
-            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
-            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
-            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
-            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
-            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
-            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
-            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
-            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
-            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
-            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-        };
-                
-        internal static readonly sbyte[] LengthCode = new sbyte[]
-        {
-            0,   1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11,
-            12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
-            16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17,
-            18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
-            20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-            21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-            22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-            23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
-        };
-                
-
-        internal static readonly int[] LengthBase = new int[]
-        {
-            0,   1,  2,  3,  4,  5,  6,   7,   8,  10,  12,  14, 16, 20, 24, 28,
-            32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0
-        };
-                
-
-        internal static readonly int[] DistanceBase = new int[]
-        {
-            0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,
-            256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
-        };
-
-        
-        /// <summary>
-        /// Map from a distance to a distance code.
-        /// </summary>
-        /// <remarks> 
-        /// No side effects. _dist_code[256] and _dist_code[257] are never used.
-        /// </remarks>
-        internal static int DistanceCode(int dist)
-        {
-            return (dist < 256)
-                ? _dist_code[dist]
-                : _dist_code[256 + SharedUtils.URShift(dist, 7)];
-        }
-
-        internal short[] dyn_tree; // the dynamic tree
-        internal int max_code; // largest code with non zero frequency
-        internal StaticTree staticTree; // the corresponding static tree
-                
-        // Compute the optimal bit lengths for a tree and update the total bit length
-        // for the current block.
-        // IN assertion: the fields freq and dad are set, heap[heap_max] and
-        //    above are the tree nodes sorted by increasing frequency.
-        // OUT assertions: the field len is set to the optimal bit length, the
-        //     array bl_count contains the frequencies for each bit length.
-        //     The length opt_len is updated; static_len is also updated if stree is
-        //     not null.
-        internal void  gen_bitlen(DeflateManager s)
-        {
-            short[] tree = dyn_tree;
-            short[] stree = staticTree.treeCodes;
-            int[] extra = staticTree.extraBits;
-            int base_Renamed = staticTree.extraBase;
-            int max_length = staticTree.maxLength;
-            int h; // heap index
-            int n, m; // iterate over the tree elements
-            int bits; // bit length
-            int xbits; // extra bits
-            short f; // frequency
-            int overflow = 0; // number of elements with bit length too large
-                        
-            for (bits = 0; bits <= InternalConstants.MAX_BITS; bits++)
-                s.bl_count[bits] = 0;
-                        
-            // In a first pass, compute the optimal bit lengths (which may
-            // overflow in the case of the bit length tree).
-            tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap
-                        
-            for (h = s.heap_max + 1; h < HEAP_SIZE; h++)
-            {
-                n = s.heap[h];
-                bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
-                if (bits > max_length)
-                {
-                    bits = max_length; overflow++;
-                }
-                tree[n * 2 + 1] = (short) bits;
-                // We overwrite tree[n*2+1] which is no longer needed
-                                
-                if (n > max_code)
-                    continue; // not a leaf node
-                                
-                s.bl_count[bits]++;
-                xbits = 0;
-                if (n >= base_Renamed)
-                    xbits = extra[n - base_Renamed];
-                f = tree[n * 2];
-                s.opt_len += f * (bits + xbits);
-                if (stree != null)
-                    s.static_len += f * (stree[n * 2 + 1] + xbits);
-            }
-            if (overflow == 0)
-                return ;
-                        
-            // This happens for example on obj2 and pic of the Calgary corpus
-            // Find the first bit length which could increase:
-            do 
-            {
-                bits = max_length - 1;
-                while (s.bl_count[bits] == 0)
-                    bits--;
-                s.bl_count[bits]--; // move one leaf down the tree
-                s.bl_count[bits + 1] = (short) (s.bl_count[bits + 1] + 2); // move one overflow item as its brother
-                s.bl_count[max_length]--;
-                // The brother of the overflow item also moves one step up,
-                // but this does not affect bl_count[max_length]
-                overflow -= 2;
-            }
-            while (overflow > 0);
-                        
-            for (bits = max_length; bits != 0; bits--)
-            {
-                n = s.bl_count[bits];
-                while (n != 0)
-                {
-                    m = s.heap[--h];
-                    if (m > max_code)
-                        continue;
-                    if (tree[m * 2 + 1] != bits)
-                    {
-                        s.opt_len = (int) (s.opt_len + ((long) bits - (long) tree[m * 2 + 1]) * (long) tree[m * 2]);
-                        tree[m * 2 + 1] = (short) bits;
-                    }
-                    n--;
-                }
-            }
-        }
-                
-        // Construct one Huffman tree and assigns the code bit strings and lengths.
-        // Update the total bit length for the current block.
-        // IN assertion: the field freq is set for all tree elements.
-        // OUT assertions: the fields len and code are set to the optimal bit length
-        //     and corresponding code. The length opt_len is updated; static_len is
-        //     also updated if stree is not null. The field max_code is set.
-        internal void  build_tree(DeflateManager s)
-        {
-            short[] tree  = dyn_tree;
-            short[] stree = staticTree.treeCodes;
-            int elems     = staticTree.elems;
-            int n, m;            // iterate over heap elements
-            int max_code  = -1;  // largest code with non zero frequency
-            int node;            // new node being created
-                        
-            // Construct the initial heap, with least frequent element in
-            // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
-            // heap[0] is not used.
-            s.heap_len = 0;
-            s.heap_max = HEAP_SIZE;
-                        
-            for (n = 0; n < elems; n++)
-            {
-                if (tree[n * 2] != 0)
-                {
-                    s.heap[++s.heap_len] = max_code = n;
-                    s.depth[n] = 0;
-                }
-                else
-                {
-                    tree[n * 2 + 1] = 0;
-                }
-            }
-                        
-            // The pkzip format requires that at least one distance code exists,
-            // and that at least one bit should be sent even if there is only one
-            // possible code. So to avoid special checks later on we force at least
-            // two codes of non zero frequency.
-            while (s.heap_len < 2)
-            {
-                node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0);
-                tree[node * 2] = 1;
-                s.depth[node] = 0;
-                s.opt_len--;
-                if (stree != null)
-                    s.static_len -= stree[node * 2 + 1];
-                // node is 0 or 1 so it does not have extra bits
-            }
-            this.max_code = max_code;
-                        
-            // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
-            // establish sub-heaps of increasing lengths:
-                        
-            for (n = s.heap_len / 2; n >= 1; n--)
-                s.pqdownheap(tree, n);
-                        
-            // Construct the Huffman tree by repeatedly combining the least two
-            // frequent nodes.
-                        
-            node = elems; // next internal node of the tree
-            do 
-            {
-                // n = node of least frequency
-                n = s.heap[1];
-                s.heap[1] = s.heap[s.heap_len--];
-                s.pqdownheap(tree, 1);
-                m = s.heap[1]; // m = node of next least frequency
-                                
-                s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
-                s.heap[--s.heap_max] = m;
-                                
-                // Create a new node father of n and m
-                tree[node * 2] = unchecked((short) (tree[n * 2] + tree[m * 2]));
-                s.depth[node] = (sbyte) (System.Math.Max((byte) s.depth[n], (byte) s.depth[m]) + 1);
-                tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node;
-                                
-                // and insert the new node in the heap
-                s.heap[1] = node++;
-                s.pqdownheap(tree, 1);
-            }
-            while (s.heap_len >= 2);
-                        
-            s.heap[--s.heap_max] = s.heap[1];
-                        
-            // At this point, the fields freq and dad are set. We can now
-            // generate the bit lengths.
-                        
-            gen_bitlen(s);
-                        
-            // The field len is now set, we can generate the bit codes
-            gen_codes(tree, max_code, s.bl_count);
-        }
-                
-        // Generate the codes for a given tree and bit counts (which need not be
-        // optimal).
-        // IN assertion: the array bl_count contains the bit length statistics for
-        // the given tree and the field len is set for all tree elements.
-        // OUT assertion: the field code is set for all tree elements of non
-        //     zero code length.
-        internal static void  gen_codes(short[] tree, int max_code, short[] bl_count)
-        {
-            short[] next_code = new short[InternalConstants.MAX_BITS + 1]; // next code value for each bit length
-            short code = 0; // running code value
-            int bits; // bit index
-            int n; // code index
-                        
-            // The distribution counts are first used to generate the code values
-            // without bit reversal.
-            for (bits = 1; bits <= InternalConstants.MAX_BITS; bits++)
-                unchecked {
-                    next_code[bits] = code = (short) ((code + bl_count[bits - 1]) << 1);
-                }
-                        
-            // Check that the bit counts in bl_count are consistent. The last code
-            // must be all ones.
-            //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
-            //        "inconsistent bit counts");
-            //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
-                        
-            for (n = 0; n <= max_code; n++)
-            {
-                int len = tree[n * 2 + 1];
-                if (len == 0)
-                    continue;
-                // Now reverse the bits
-                tree[n * 2] =  unchecked((short) (bi_reverse(next_code[len]++, len)));
-            }
-        }
-                
-        // Reverse the first len bits of a code, using straightforward code (a faster
-        // method would use a table)
-        // IN assertion: 1 <= len <= 15
-        internal static int bi_reverse(int code, int len)
-        {
-            int res = 0;
-            do 
-            {
-                res |= code & 1;
-                code >>= 1; //SharedUtils.URShift(code, 1);
-                res <<= 1;
-            }
-            while (--len > 0);
-            return res >> 1;
-        }
-    }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/Zlib.cs b/EPPlus/Packaging/DotNetZip/Zlib/Zlib.cs
deleted file mode 100644
index 06d8e7d..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/Zlib.cs
+++ /dev/null
@@ -1,546 +0,0 @@
-// Zlib.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009-2011 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// Last Saved: <2011-August-03 19:52:28>
-//
-// ------------------------------------------------------------------
-//
-// This module defines classes for ZLIB compression and
-// decompression. This code is derived from the jzlib implementation of
-// zlib, but significantly modified.  The object model is not the same,
-// and many of the behaviors are new or different.  Nonetheless, in
-// keeping with the license for jzlib, the copyright to that code is
-// included below.
-//
-// ------------------------------------------------------------------
-//
-// The following notice applies to jzlib:
-//
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in
-// the documentation and/or other materials provided with the distribution.
-//
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// -----------------------------------------------------------------------
-//
-// jzlib is based on zlib-1.1.3.
-//
-// The following notice applies to zlib:
-//
-// -----------------------------------------------------------------------
-//
-// Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler
-//
-//   The ZLIB software is provided 'as-is', without any express or implied
-//   warranty.  In no event will the authors be held liable for any damages
-//   arising from the use of this software.
-//
-//   Permission is granted to anyone to use this software for any purpose,
-//   including commercial applications, and to alter it and redistribute it
-//   freely, subject to the following restrictions:
-//
-//   1. The origin of this software must not be misrepresented; you must not
-//      claim that you wrote the original software. If you use this software
-//      in a product, an acknowledgment in the product documentation would be
-//      appreciated but is not required.
-//   2. Altered source versions must be plainly marked as such, and must not be
-//      misrepresented as being the original software.
-//   3. This notice may not be removed or altered from any source distribution.
-//
-//   Jean-loup Gailly jloup@gzip.org
-//   Mark Adler madler@alumni.caltech.edu
-//
-// -----------------------------------------------------------------------
-
-
-
-using System;
-using Interop=System.Runtime.InteropServices;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-
-    /// <summary>
-    /// Describes how to flush the current deflate operation.
-    /// </summary>
-    /// <remarks>
-    /// The different FlushType values are useful when using a Deflate in a streaming application.
-    /// </remarks>
-    public enum FlushType
-    {
-        /// <summary>No flush at all.</summary>
-        None = 0,
-
-        /// <summary>Closes the current block, but doesn't flush it to
-        /// the output. Used internally only in hypothetical
-        /// scenarios.  This was supposed to be removed by Zlib, but it is
-        /// still in use in some edge cases.
-        /// </summary>
-        Partial,
-
-        /// <summary>
-        /// Use this during compression to specify that all pending output should be
-        /// flushed to the output buffer and the output should be aligned on a byte
-        /// boundary.  You might use this in a streaming communication scenario, so that
-        /// the decompressor can get all input data available so far.  When using this
-        /// with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if
-        /// enough output space has been provided before the call.  Flushing will
-        /// degrade compression and so it should be used only when necessary.
-        /// </summary>
-        Sync,
-
-        /// <summary>
-        /// Use this during compression to specify that all output should be flushed, as
-        /// with <c>FlushType.Sync</c>, but also, the compression state should be reset
-        /// so that decompression can restart from this point if previous compressed
-        /// data has been damaged or if random access is desired.  Using
-        /// <c>FlushType.Full</c> too often can significantly degrade the compression.
-        /// </summary>
-        Full,
-
-        /// <summary>Signals the end of the compression/decompression stream.</summary>
-        Finish,
-    }
-
-
-    /// <summary>
-    /// The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.
-    /// </summary>
-    public enum CompressionLevel
-    {
-        /// <summary>
-        /// None means that the data will be simply stored, with no change at all.
-        /// If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None
-        /// cannot be opened with the default zip reader. Use a different CompressionLevel.
-        /// </summary>
-        None= 0,
-        /// <summary>
-        /// Same as None.
-        /// </summary>
-        Level0 = 0,
-
-        /// <summary>
-        /// The fastest but least effective compression.
-        /// </summary>
-        BestSpeed = 1,
-
-        /// <summary>
-        /// A synonym for BestSpeed.
-        /// </summary>
-        Level1 = 1,
-
-        /// <summary>
-        /// A little slower, but better, than level 1.
-        /// </summary>
-        Level2 = 2,
-
-        /// <summary>
-        /// A little slower, but better, than level 2.
-        /// </summary>
-        Level3 = 3,
-
-        /// <summary>
-        /// A little slower, but better, than level 3.
-        /// </summary>
-        Level4 = 4,
-
-        /// <summary>
-        /// A little slower than level 4, but with better compression.
-        /// </summary>
-        Level5 = 5,
-
-        /// <summary>
-        /// The default compression level, with a good balance of speed and compression efficiency.
-        /// </summary>
-        Default = 6,
-        /// <summary>
-        /// A synonym for Default.
-        /// </summary>
-        Level6 = 6,
-
-        /// <summary>
-        /// Pretty good compression!
-        /// </summary>
-        Level7 = 7,
-
-        /// <summary>
-        ///  Better compression than Level7!
-        /// </summary>
-        Level8 = 8,
-
-        /// <summary>
-        /// The "best" compression, where best means greatest reduction in size of the input data stream.
-        /// This is also the slowest compression.
-        /// </summary>
-        BestCompression = 9,
-
-        /// <summary>
-        /// A synonym for BestCompression.
-        /// </summary>
-        Level9 = 9,
-    }
-
-    /// <summary>
-    /// Describes options for how the compression algorithm is executed.  Different strategies
-    /// work better on different sorts of data.  The strategy parameter can affect the compression
-    /// ratio and the speed of compression but not the correctness of the compresssion.
-    /// </summary>
-    public enum CompressionStrategy
-    {
-        /// <summary>
-        /// The default strategy is probably the best for normal data.
-        /// </summary>
-        Default = 0,
-
-        /// <summary>
-        /// The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a
-        /// filter or predictor.  By this definition, filtered data consists mostly of small
-        /// values with a somewhat random distribution.  In this case, the compression algorithm
-        /// is tuned to compress them better.  The effect of <c>Filtered</c> is to force more Huffman
-        /// coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>.
-        /// </summary>
-        Filtered = 1,
-
-        /// <summary>
-        /// Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no
-        /// string matching.
-        /// </summary>
-        HuffmanOnly = 2,
-    }
-
-
-    /// <summary>
-    /// An enum to specify the direction of transcoding - whether to compress or decompress.
-    /// </summary>
-    public enum CompressionMode
-    {
-        /// <summary>
-        /// Used to specify that the stream should compress the data.
-        /// </summary>
-        Compress= 0,
-        /// <summary>
-        /// Used to specify that the stream should decompress the data.
-        /// </summary>
-        Decompress = 1,
-    }
-
-
-    /// <summary>
-    /// A general purpose exception class for exceptions in the Zlib library.
-    /// </summary>
-    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000E")]
-    public class ZlibException : System.Exception
-    {
-        /// <summary>
-        /// The ZlibException class captures exception information generated
-        /// by the Zlib library.
-        /// </summary>
-        public ZlibException()
-            : base()
-        {
-        }
-
-        /// <summary>
-        /// This ctor collects a message attached to the exception.
-        /// </summary>
-        /// <param name="s">the message for the exception.</param>
-        public ZlibException(System.String s)
-            : base(s)
-        {
-        }
-    }
-
-
-    internal class SharedUtils
-    {
-        /// <summary>
-        /// Performs an unsigned bitwise right shift with the specified number
-        /// </summary>
-        /// <param name="number">Number to operate on</param>
-        /// <param name="bits">Ammount of bits to shift</param>
-        /// <returns>The resulting number from the shift operation</returns>
-        public static int URShift(int number, int bits)
-        {
-            return (int)((uint)number >> bits);
-        }
-
-#if NOT
-        /// <summary>
-        /// Performs an unsigned bitwise right shift with the specified number
-        /// </summary>
-        /// <param name="number">Number to operate on</param>
-        /// <param name="bits">Ammount of bits to shift</param>
-        /// <returns>The resulting number from the shift operation</returns>
-        public static long URShift(long number, int bits)
-        {
-            return (long) ((UInt64)number >> bits);
-        }
-#endif
-
-        /// <summary>
-        ///   Reads a number of characters from the current source TextReader and writes
-        ///   the data to the target array at the specified index.
-        /// </summary>
-        ///
-        /// <param name="sourceTextReader">The source TextReader to read from</param>
-        /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
-        /// <param name="start">The starting index of the target array.</param>
-        /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
-        ///
-        /// <returns>
-        ///   The number of characters read. The number will be less than or equal to
-        ///   count depending on the data available in the source TextReader. Returns -1
-        ///   if the end of the stream is reached.
-        /// </returns>
-        public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, byte[] target, int start, int count)
-        {
-            // Returns 0 bytes if not enough space in target
-            if (target.Length == 0) return 0;
-
-            char[] charArray = new char[target.Length];
-            int bytesRead = sourceTextReader.Read(charArray, start, count);
-
-            // Returns -1 if EOF
-            if (bytesRead == 0) return -1;
-
-            for (int index = start; index < start + bytesRead; index++)
-                target[index] = (byte)charArray[index];
-
-            return bytesRead;
-        }
-
-
-        internal static byte[] ToByteArray(System.String sourceString)
-        {
-            return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
-        }
-
-
-        internal static char[] ToCharArray(byte[] byteArray)
-        {
-            return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
-        }
-    }
-
-    internal static class InternalConstants
-    {
-        internal static readonly int MAX_BITS     = 15;
-        internal static readonly int BL_CODES     = 19;
-        internal static readonly int D_CODES      = 30;
-        internal static readonly int LITERALS     = 256;
-        internal static readonly int LENGTH_CODES = 29;
-        internal static readonly int L_CODES      = (LITERALS + 1 + LENGTH_CODES);
-
-        // Bit length codes must not exceed MAX_BL_BITS bits
-        internal static readonly int MAX_BL_BITS  = 7;
-
-        // repeat previous bit length 3-6 times (2 bits of repeat count)
-        internal static readonly int REP_3_6      = 16;
-
-        // repeat a zero length 3-10 times  (3 bits of repeat count)
-        internal static readonly int REPZ_3_10    = 17;
-
-        // repeat a zero length 11-138 times  (7 bits of repeat count)
-        internal static readonly int REPZ_11_138  = 18;
-
-    }
-
-    internal sealed class StaticTree
-    {
-        internal static readonly short[] lengthAndLiteralsTreeCodes = new short[] {
-            12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8,
-            28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8,
-             2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8,
-            18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8,
-            10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, 8,
-            26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8,
-             6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8,
-            22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8,
-            14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8,
-            30, 8, 158, 8, 94, 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8,
-             1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8,
-            17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, 8, 241, 8,
-             9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8,
-            25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8,
-             5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8,
-            21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8,
-            13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8,
-            29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8,
-            19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9,
-            51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9,
-            11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9,
-            43, 9, 299, 9, 171, 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9,
-            27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9,
-            59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, 9, 251, 9, 507, 9,
-             7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9,
-            39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9,
-            23, 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9,
-            55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9,
-            15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, 207, 9, 463, 9,
-            47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9,
-            31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, 479, 9,
-            63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9,
-             0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7,
-             8, 7, 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7,
-             4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7,
-             3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, 99, 8, 227, 8
-        };
-
-        internal static readonly short[] distTreeCodes = new short[] {
-            0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5,
-            2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5,
-            1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5,
-            3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 };
-
-        internal static readonly StaticTree Literals;
-        internal static readonly StaticTree Distances;
-        internal static readonly StaticTree BitLengths;
-
-        internal short[] treeCodes; // static tree or null
-        internal int[] extraBits;   // extra bits for each code or null
-        internal int extraBase;     // base index for extra_bits
-        internal int elems;         // max number of elements in the tree
-        internal int maxLength;     // max bit length for the codes
-
-        private StaticTree(short[] treeCodes, int[] extraBits, int extraBase, int elems, int maxLength)
-        {
-            this.treeCodes = treeCodes;
-            this.extraBits = extraBits;
-            this.extraBase = extraBase;
-            this.elems = elems;
-            this.maxLength = maxLength;
-        }
-        static StaticTree()
-        {
-            Literals = new StaticTree(lengthAndLiteralsTreeCodes, Tree.ExtraLengthBits, InternalConstants.LITERALS + 1, InternalConstants.L_CODES, InternalConstants.MAX_BITS);
-            Distances = new StaticTree(distTreeCodes, Tree.ExtraDistanceBits, 0, InternalConstants.D_CODES, InternalConstants.MAX_BITS);
-            BitLengths = new StaticTree(null, Tree.extra_blbits, 0, InternalConstants.BL_CODES, InternalConstants.MAX_BL_BITS);
-        }
-    }
-
-
-
-    /// <summary>
-    /// Computes an Adler-32 checksum.
-    /// </summary>
-    /// <remarks>
-    /// The Adler checksum is similar to a CRC checksum, but faster to compute, though less
-    /// reliable.  It is used in producing RFC1950 compressed streams.  The Adler checksum
-    /// is a required part of the "ZLIB" standard.  Applications will almost never need to
-    /// use this class directly.
-    /// </remarks>
-    ///
-    /// <exclude/>
-    public sealed class Adler
-    {
-        // largest prime smaller than 65536
-        private static readonly uint BASE = 65521;
-        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
-        private static readonly int NMAX = 5552;
-
-
-#pragma warning disable 3001
-#pragma warning disable 3002
-
-        /// <summary>
-        ///   Calculates the Adler32 checksum.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This is used within ZLIB.  You probably don't need to use this directly.
-        ///   </para>
-        /// </remarks>
-        /// <example>
-        ///    To compute an Adler32 checksum on a byte array:
-        ///  <code>
-        ///    var adler = Adler.Adler32(0, null, 0, 0);
-        ///    adler = Adler.Adler32(adler, buffer, index, length);
-        ///  </code>
-        /// </example>
-        public static uint Adler32(uint adler, byte[] buf, int index, int len)
-        {
-            if (buf == null)
-                return 1;
-
-            uint s1 = (uint) (adler & 0xffff);
-            uint s2 = (uint) ((adler >> 16) & 0xffff);
-
-            while (len > 0)
-            {
-                int k = len < NMAX ? len : NMAX;
-                len -= k;
-                while (k >= 16)
-                {
-                    //s1 += (buf[index++] & 0xff); s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    s1 += buf[index++]; s2 += s1;
-                    k -= 16;
-                }
-                if (k != 0)
-                {
-                    do
-                    {
-                        s1 += buf[index++];
-                        s2 += s1;
-                    }
-                    while (--k != 0);
-                }
-                s1 %= BASE;
-                s2 %= BASE;
-            }
-            return (uint)((s2 << 16) | s1);
-        }
-#pragma warning restore 3001
-#pragma warning restore 3002
-
-    }
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/ZlibBaseStream.cs b/EPPlus/Packaging/DotNetZip/Zlib/ZlibBaseStream.cs
deleted file mode 100644
index 3215e3a..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/ZlibBaseStream.cs
+++ /dev/null
@@ -1,628 +0,0 @@
-// ZlibBaseStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-August-06 21:22:38>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZlibBaseStream class, which is an intnernal
-// base class for DeflateStream, ZlibStream and GZipStream.
-//
-// ------------------------------------------------------------------
-
-using OfficeOpenXml.Packaging.Ionic.Crc;
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-
-    internal enum ZlibStreamFlavor { ZLIB = 1950, DEFLATE = 1951, GZIP = 1952 }
-
-    internal class ZlibBaseStream : System.IO.Stream
-    {
-        protected internal ZlibCodec _z = null; // deferred init... new ZlibCodec();
-
-        protected internal StreamMode _streamMode = StreamMode.Undefined;
-        protected internal FlushType _flushMode;
-        protected internal ZlibStreamFlavor _flavor;
-        protected internal CompressionMode _compressionMode;
-        protected internal CompressionLevel _level;
-        protected internal bool _leaveOpen;
-        protected internal byte[] _workingBuffer;
-        protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
-        protected internal byte[] _buf1 = new byte[1];
-
-        protected internal System.IO.Stream _stream;
-        protected internal CompressionStrategy Strategy = CompressionStrategy.Default;
-
-        // workitem 7159
-        CRC32 crc;
-        protected internal string _GzipFileName;
-        protected internal string _GzipComment;
-        protected internal DateTime _GzipMtime;
-        protected internal int _gzipHeaderByteCount;
-
-        internal int Crc32 { get { if (crc == null) return 0; return crc.Crc32Result; } }
-
-        public ZlibBaseStream(System.IO.Stream stream,
-                              CompressionMode compressionMode,
-                              CompressionLevel level,
-                              ZlibStreamFlavor flavor,
-                              bool leaveOpen)
-            : base()
-        {
-            this._flushMode = FlushType.None;
-            //this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
-            this._stream = stream;
-            this._leaveOpen = leaveOpen;
-            this._compressionMode = compressionMode;
-            this._flavor = flavor;
-            this._level = level;
-            // workitem 7159
-            if (flavor == ZlibStreamFlavor.GZIP)
-            {
-                this.crc = new Ionic.Crc.CRC32();
-            }
-        }
-
-
-        protected internal bool _wantCompress
-        {
-            get
-            {
-                return (this._compressionMode == CompressionMode.Compress);
-            }
-        }
-
-        private ZlibCodec z
-        {
-            get
-            {
-                if (_z == null)
-                {
-                    bool wantRfc1950Header = (this._flavor == ZlibStreamFlavor.ZLIB);
-                    _z = new ZlibCodec();
-                    if (this._compressionMode == CompressionMode.Decompress)
-                    {
-                        _z.InitializeInflate(wantRfc1950Header);
-                    }
-                    else
-                    {
-                        _z.Strategy = Strategy;
-                        _z.InitializeDeflate(this._level, wantRfc1950Header);
-                    }
-                }
-                return _z;
-            }
-        }
-
-
-
-        private byte[] workingBuffer
-        {
-            get
-            {
-                if (_workingBuffer == null)
-                    _workingBuffer = new byte[_bufferSize];
-                return _workingBuffer;
-            }
-        }
-
-
-
-        public override void Write(System.Byte[] buffer, int offset, int count)
-        {
-            // workitem 7159
-            // calculate the CRC on the unccompressed data  (before writing)
-            if (crc != null)
-                crc.SlurpBlock(buffer, offset, count);
-
-            if (_streamMode == StreamMode.Undefined)
-                _streamMode = StreamMode.Writer;
-            else if (_streamMode != StreamMode.Writer)
-                throw new ZlibException("Cannot Write after Reading.");
-
-            if (count == 0)
-                return;
-
-            // first reference of z property will initialize the private var _z
-            z.InputBuffer = buffer;
-            _z.NextIn = offset;
-            _z.AvailableBytesIn = count;
-            bool done = false;
-            do
-            {
-                _z.OutputBuffer = workingBuffer;
-                _z.NextOut = 0;
-                _z.AvailableBytesOut = _workingBuffer.Length;
-                int rc = (_wantCompress)
-                    ? _z.Deflate(_flushMode)
-                    : _z.Inflate(_flushMode);
-                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-                    throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);
-
-                //if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
-                _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
-
-                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
-
-                // If GZIP and de-compress, we're done when 8 bytes remain.
-                if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
-                    done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
-
-            }
-            while (!done);
-        }
-
-
-
-        private void finish()
-        {
-            if (_z == null) return;
-
-            if (_streamMode == StreamMode.Writer)
-            {
-                bool done = false;
-                do
-                {
-                    _z.OutputBuffer = workingBuffer;
-                    _z.NextOut = 0;
-                    _z.AvailableBytesOut = _workingBuffer.Length;
-                    int rc = (_wantCompress)
-                        ? _z.Deflate(FlushType.Finish)
-                        : _z.Inflate(FlushType.Finish);
-
-                    if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
-                    {
-                        string verb = (_wantCompress ? "de" : "in") + "flating";
-                        if (_z.Message == null)
-                            throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
-                        else
-                            throw new ZlibException(verb + ": " + _z.Message);
-                    }
-
-                    if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
-                    {
-                        _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
-                    }
-
-                    done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
-                    // If GZIP and de-compress, we're done when 8 bytes remain.
-                    if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
-                        done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
-
-                }
-                while (!done);
-
-                Flush();
-
-                // workitem 7159
-                if (_flavor == ZlibStreamFlavor.GZIP)
-                {
-                    if (_wantCompress)
-                    {
-                        // Emit the GZIP trailer: CRC32 and  size mod 2^32
-                        int c1 = crc.Crc32Result;
-                        _stream.Write(BitConverter.GetBytes(c1), 0, 4);
-                        int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
-                        _stream.Write(BitConverter.GetBytes(c2), 0, 4);
-                    }
-                    else
-                    {
-                        throw new ZlibException("Writing with decompression is not supported.");
-                    }
-                }
-            }
-            // workitem 7159
-            else if (_streamMode == StreamMode.Reader)
-            {
-                if (_flavor == ZlibStreamFlavor.GZIP)
-                {
-                    if (!_wantCompress)
-                    {
-                        // workitem 8501: handle edge case (decompress empty stream)
-                        if (_z.TotalBytesOut == 0L)
-                            return;
-
-                        // Read and potentially verify the GZIP trailer:
-                        // CRC32 and size mod 2^32
-                        byte[] trailer = new byte[8];
-
-                        // workitems 8679 & 12554
-                        if (_z.AvailableBytesIn < 8)
-                        {
-                            // Make sure we have read to the end of the stream
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
-                            int bytesNeeded = 8 - _z.AvailableBytesIn;
-                            int bytesRead = _stream.Read(trailer,
-                                                         _z.AvailableBytesIn,
-                                                         bytesNeeded);
-                            if (bytesNeeded != bytesRead)
-                            {
-                                throw new ZlibException(String.Format("Missing or incomplete GZIP trailer. Expected 8 bytes, got {0}.",
-                                                                      _z.AvailableBytesIn + bytesRead));
-                            }
-                        }
-                        else
-                        {
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
-                        }
-
-                        Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
-                        Int32 crc32_actual = crc.Crc32Result;
-                        Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
-                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
-
-                        if (crc32_actual != crc32_expected)
-                            throw new ZlibException(String.Format("Bad CRC32 in GZIP trailer. (actual({0:X8})!=expected({1:X8}))", crc32_actual, crc32_expected));
-
-                        if (isize_actual != isize_expected)
-                            throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));
-
-                    }
-                    else
-                    {
-                        throw new ZlibException("Reading with compression is not supported.");
-                    }
-                }
-            }
-        }
-
-
-        private void end()
-        {
-            if (z == null)
-                return;
-            if (_wantCompress)
-            {
-                _z.EndDeflate();
-            }
-            else
-            {
-                _z.EndInflate();
-            }
-            _z = null;
-        }
-
-
-        public override void Close()
-        {
-            if (_stream == null) return;
-            try
-            {
-                finish();
-            }
-            finally
-            {
-                end();
-                if (!_leaveOpen) _stream.Close();
-                _stream = null;
-            }
-        }
-
-        public override void Flush()
-        {
-            _stream.Flush();
-        }
-
-        public override System.Int64 Seek(System.Int64 offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotImplementedException();
-            //_outStream.Seek(offset, origin);
-        }
-        public override void SetLength(System.Int64 value)
-        {
-            _stream.SetLength(value);
-        }
-
-
-#if NOT
-        public int Read()
-        {
-            if (Read(_buf1, 0, 1) == 0)
-                return 0;
-            // calculate CRC after reading
-            if (crc!=null)
-                crc.SlurpBlock(_buf1,0,1);
-            return (_buf1[0] & 0xFF);
-        }
-#endif
-
-        private bool nomoreinput = false;
-
-
-
-        private string ReadZeroTerminatedString()
-        {
-            var list = new System.Collections.Generic.List<byte>();
-            bool done = false;
-            do
-            {
-                // workitem 7740
-                int n = _stream.Read(_buf1, 0, 1);
-                if (n != 1)
-                    throw new ZlibException("Unexpected EOF reading GZIP header.");
-                else
-                {
-                    if (_buf1[0] == 0)
-                        done = true;
-                    else
-                        list.Add(_buf1[0]);
-                }
-            } while (!done);
-            byte[] a = list.ToArray();
-            return GZipStream.iso8859dash1.GetString(a, 0, a.Length);
-        }
-
-
-        private int _ReadAndValidateGzipHeader()
-        {
-            int totalBytesRead = 0;
-            // read the header on the first read
-            byte[] header = new byte[10];
-            int n = _stream.Read(header, 0, header.Length);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
-                return 0;
-
-            if (n != 10)
-                throw new ZlibException("Not a valid GZIP stream.");
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-                throw new ZlibException("Bad GZIP header.");
-
-            Int32 timet = BitConverter.ToInt32(header, 4);
-            _GzipMtime = GZipStream._unixEpoch.AddSeconds(timet);
-            totalBytesRead += n;
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = _stream.Read(header, 0, 2); // 2-byte length field
-                totalBytesRead += n;
-
-                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
-                byte[] extra = new byte[extraLength];
-                n = _stream.Read(extra, 0, extra.Length);
-                if (n != extraLength)
-                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-                totalBytesRead += n;
-            }
-            if ((header[3] & 0x08) == 0x08)
-                _GzipFileName = ReadZeroTerminatedString();
-            if ((header[3] & 0x10) == 0x010)
-                _GzipComment = ReadZeroTerminatedString();
-            if ((header[3] & 0x02) == 0x02)
-                Read(_buf1, 0, 1); // CRC16, ignore
-
-            return totalBytesRead;
-        }
-
-
-
-        public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
-        {
-            // According to MS documentation, any implementation of the IO.Stream.Read function must:
-            // (a) throw an exception if offset & count reference an invalid part of the buffer,
-            //     or if count < 0, or if buffer is null
-            // (b) return 0 only upon EOF, or if count = 0
-            // (c) if not EOF, then return at least 1 byte, up to <count> bytes
-
-            if (_streamMode == StreamMode.Undefined)
-            {
-                if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
-                // for the first read, set up some controls.
-                _streamMode = StreamMode.Reader;
-                // (The first reference to _z goes through the private accessor which
-                // may initialize it.)
-                z.AvailableBytesIn = 0;
-                if (_flavor == ZlibStreamFlavor.GZIP)
-                {
-                    _gzipHeaderByteCount = _ReadAndValidateGzipHeader();
-                    // workitem 8501: handle edge case (decompress empty stream)
-                    if (_gzipHeaderByteCount == 0)
-                        return 0;
-                }
-            }
-
-            if (_streamMode != StreamMode.Reader)
-                throw new ZlibException("Cannot Read after Writing.");
-
-            if (count == 0) return 0;
-            if (nomoreinput && _wantCompress) return 0;  // workitem 8557
-            if (buffer == null) throw new ArgumentNullException("buffer");
-            if (count < 0) throw new ArgumentOutOfRangeException("count");
-            if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
-            if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");
-
-            int rc = 0;
-
-            // set up the output of the deflate/inflate codec:
-            _z.OutputBuffer = buffer;
-            _z.NextOut = offset;
-            _z.AvailableBytesOut = count;
-
-            // This is necessary in case _workingBuffer has been resized. (new byte[])
-            // (The first reference to _workingBuffer goes through the private accessor which
-            // may initialize it.)
-            _z.InputBuffer = workingBuffer;
-
-            do
-            {
-                // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
-                if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
-                {
-                    // No data available, so try to Read data from the captive stream.
-                    _z.NextIn = 0;
-                    _z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
-                    if (_z.AvailableBytesIn == 0)
-                        nomoreinput = true;
-
-                }
-                // we have data in InputBuffer; now compress or decompress as appropriate
-                rc = (_wantCompress)
-                    ? _z.Deflate(_flushMode)
-                    : _z.Inflate(_flushMode);
-
-                if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
-                    return 0;
-
-                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-                    throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));
-
-                if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
-                    break; // nothing more to read
-            }
-            //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
-            while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
-
-
-            // workitem 8557
-            // is there more room in output?
-            if (_z.AvailableBytesOut > 0)
-            {
-                if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
-                {
-                    // deferred
-                }
-
-                // are we completely done reading?
-                if (nomoreinput)
-                {
-                    // and in compression?
-                    if (_wantCompress)
-                    {
-                        // no more input data available; therefore we flush to
-                        // try to complete the read
-                        rc = _z.Deflate(FlushType.Finish);
-
-                        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-                            throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
-                    }
-                }
-            }
-
-
-            rc = (count - _z.AvailableBytesOut);
-
-            // calculate CRC after reading
-            if (crc != null)
-                crc.SlurpBlock(buffer, offset, rc);
-
-            return rc;
-        }
-
-
-
-        public override System.Boolean CanRead
-        {
-            get { return this._stream.CanRead; }
-        }
-
-        public override System.Boolean CanSeek
-        {
-            get { return this._stream.CanSeek; }
-        }
-
-        public override System.Boolean CanWrite
-        {
-            get { return this._stream.CanWrite; }
-        }
-
-        public override System.Int64 Length
-        {
-            get { return _stream.Length; }
-        }
-
-        public override long Position
-        {
-            get { throw new NotImplementedException(); }
-            set { throw new NotImplementedException(); }
-        }
-
-        internal enum StreamMode
-        {
-            Writer,
-            Reader,
-            Undefined,
-        }
-
-
-        public static void CompressString(String s, Stream compressor)
-        {
-            byte[] uncompressed = System.Text.Encoding.UTF8.GetBytes(s);
-            using (compressor)
-            {
-                compressor.Write(uncompressed, 0, uncompressed.Length);
-            }
-        }
-
-        public static void CompressBuffer(byte[] b, Stream compressor)
-        {
-            // workitem 8460
-            using (compressor)
-            {
-                compressor.Write(b, 0, b.Length);
-            }
-        }
-
-        public static String UncompressString(byte[] compressed, Stream decompressor)
-        {
-            // workitem 8460
-            byte[] working = new byte[1024];
-            var encoding = System.Text.Encoding.UTF8;
-            using (var output = new MemoryStream())
-            {
-                using (decompressor)
-                {
-                    int n;
-                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
-                    {
-                        output.Write(working, 0, n);
-                    }
-                }
-
-                // reset to allow read from start
-                output.Seek(0, SeekOrigin.Begin);
-                var sr = new StreamReader(output, encoding);
-                return sr.ReadToEnd();
-            }
-        }
-
-        public static byte[] UncompressBuffer(byte[] compressed, Stream decompressor)
-        {
-            // workitem 8460
-            byte[] working = new byte[1024];
-            using (var output = new MemoryStream())
-            {
-                using (decompressor)
-                {
-                    int n;
-                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
-                    {
-                        output.Write(working, 0, n);
-                    }
-                }
-                return output.ToArray();
-            }
-        }
-
-    }
-
-
-}
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/ZlibCodec.cs b/EPPlus/Packaging/DotNetZip/Zlib/ZlibCodec.cs
deleted file mode 100644
index 8cd6ce4..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/ZlibCodec.cs
+++ /dev/null
@@ -1,717 +0,0 @@
-// ZlibCodec.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-November-03 15:40:51>
-//
-// ------------------------------------------------------------------
-//
-// This module defines a Codec for ZLIB compression and
-// decompression. This code extends code that was based the jzlib
-// implementation of zlib, but this code is completely novel.  The codec
-// class is new, and encapsulates some behaviors that are new, and some
-// that were present in other classes in the jzlib code base.  In
-// keeping with the license for jzlib, the copyright to the jzlib code
-// is included below.
-//
-// ------------------------------------------------------------------
-// 
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright 
-// notice, this list of conditions and the following disclaimer in 
-// the documentation and/or other materials provided with the distribution.
-// 
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-using System;
-using Interop=System.Runtime.InteropServices;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    /// <summary>
-    /// Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).
-    /// </summary>
-    ///
-    /// <remarks>
-    /// This class compresses and decompresses data according to the Deflate algorithm
-    /// and optionally, the ZLIB format, as documented in <see
-    /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see
-    /// href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.
-    /// </remarks>
-    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000D")]
-    [Interop.ComVisible(true)]
-#if !NETCF    
-    [Interop.ClassInterface(Interop.ClassInterfaceType.AutoDispatch)]
-#endif
-    sealed public class ZlibCodec
-    {
-        /// <summary>
-        /// The buffer from which data is taken.
-        /// </summary>
-        public byte[] InputBuffer;
-
-        /// <summary>
-        /// An index into the InputBuffer array, indicating where to start reading. 
-        /// </summary>
-        public int NextIn;
-
-        /// <summary>
-        /// The number of bytes available in the InputBuffer, starting at NextIn. 
-        /// </summary>
-        /// <remarks>
-        /// Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 
-        /// The class will update this number as calls to Inflate/Deflate are made.
-        /// </remarks>
-        public int AvailableBytesIn;
-
-        /// <summary>
-        /// Total number of bytes read so far, through all calls to Inflate()/Deflate().
-        /// </summary>
-        public long TotalBytesIn;
-
-        /// <summary>
-        /// Buffer to store output data.
-        /// </summary>
-        public byte[] OutputBuffer;
-
-        /// <summary>
-        /// An index into the OutputBuffer array, indicating where to start writing. 
-        /// </summary>
-        public int NextOut;
-
-        /// <summary>
-        /// The number of bytes available in the OutputBuffer, starting at NextOut. 
-        /// </summary>
-        /// <remarks>
-        /// Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 
-        /// The class will update this number as calls to Inflate/Deflate are made.
-        /// </remarks>
-        public int AvailableBytesOut;
-
-        /// <summary>
-        /// Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
-        /// </summary>
-        public long TotalBytesOut;
-
-        /// <summary>
-        /// used for diagnostics, when something goes wrong!
-        /// </summary>
-        public System.String Message;
-
-        internal DeflateManager dstate;
-        internal InflateManager istate;
-
-        internal uint _Adler32;
-
-        /// <summary>
-        /// The compression level to use in this codec.  Useful only in compression mode.
-        /// </summary>
-        public CompressionLevel CompressLevel = CompressionLevel.Default;
-
-        /// <summary>
-        /// The number of Window Bits to use.  
-        /// </summary>
-        /// <remarks>
-        /// This gauges the size of the sliding window, and hence the 
-        /// compression effectiveness as well as memory consumption. It's best to just leave this 
-        /// setting alone if you don't know what it is.  The maximum value is 15 bits, which implies
-        /// a 32k window.  
-        /// </remarks>
-        public int WindowBits = ZlibConstants.WindowBitsDefault;
-
-        /// <summary>
-        /// The compression strategy to use.
-        /// </summary>
-        /// <remarks>
-        /// This is only effective in compression.  The theory offered by ZLIB is that different
-        /// strategies could potentially produce significant differences in compression behavior
-        /// for different data sets.  Unfortunately I don't have any good recommendations for how
-        /// to set it differently.  When I tested changing the strategy I got minimally different
-        /// compression performance. It's best to leave this property alone if you don't have a
-        /// good feel for it.  Or, you may want to produce a test harness that runs through the
-        /// different strategy options and evaluates them on different file types. If you do that,
-        /// let me know your results.
-        /// </remarks>
-        public CompressionStrategy Strategy = CompressionStrategy.Default;
-
-
-        /// <summary>
-        /// The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
-        /// </summary>
-        public int Adler32 { get { return (int)_Adler32; } }
-
-
-        /// <summary>
-        /// Create a ZlibCodec.
-        /// </summary>
-        /// <remarks>
-        /// If you use this default constructor, you will later have to explicitly call 
-        /// InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 
-        /// or decompress. 
-        /// </remarks>
-        public ZlibCodec() { }
-
-        /// <summary>
-        /// Create a ZlibCodec that either compresses or decompresses.
-        /// </summary>
-        /// <param name="mode">
-        /// Indicates whether the codec should compress (deflate) or decompress (inflate).
-        /// </param>
-        public ZlibCodec(CompressionMode mode)
-        {
-            if (mode == CompressionMode.Compress)
-            {
-                int rc = InitializeDeflate();
-                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for deflate.");
-            }
-            else if (mode == CompressionMode.Decompress)
-            {
-                int rc = InitializeInflate();
-                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for inflate.");
-            }
-            else throw new ZlibException("Invalid ZlibStreamFlavor.");
-        }
-
-        /// <summary>
-        /// Initialize the inflation state. 
-        /// </summary>
-        /// <remarks>
-        /// It is not necessary to call this before using the ZlibCodec to inflate data; 
-        /// It is implicitly called when you call the constructor.
-        /// </remarks>
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int InitializeInflate()
-        {
-            return InitializeInflate(this.WindowBits);
-        }
-
-        /// <summary>
-        /// Initialize the inflation state with an explicit flag to
-        /// govern the handling of RFC1950 header bytes.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// By default, the ZLIB header defined in <see
-        /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected.  If
-        /// you want to read a zlib stream you should specify true for
-        /// expectRfc1950Header.  If you have a deflate stream, you will want to specify
-        /// false. It is only necessary to invoke this initializer explicitly if you
-        /// want to specify false.
-        /// </remarks>
-        ///
-        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte
-        /// pair when reading the stream of data to be inflated.</param>
-        ///
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int InitializeInflate(bool expectRfc1950Header)
-        {
-            return InitializeInflate(this.WindowBits, expectRfc1950Header);
-        }
-
-        /// <summary>
-        /// Initialize the ZlibCodec for inflation, with the specified number of window bits. 
-        /// </summary>
-        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
-        /// then you shouldn't be calling this initializer.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int InitializeInflate(int windowBits)
-        {
-            this.WindowBits = windowBits;            
-            return InitializeInflate(windowBits, true);
-        }
-
-        /// <summary>
-        /// Initialize the inflation state with an explicit flag to govern the handling of
-        /// RFC1950 header bytes. 
-        /// </summary>
-        ///
-        /// <remarks>
-        /// If you want to read a zlib stream you should specify true for
-        /// expectRfc1950Header. In this case, the library will expect to find a ZLIB
-        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
-        /// 1950</see>, in the compressed stream.  If you will be reading a DEFLATE or
-        /// GZIP stream, which does not have such a header, you will want to specify
-        /// false.
-        /// </remarks>
-        ///
-        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 
-        /// the stream of data to be inflated.</param>
-        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
-        /// then you shouldn't be calling this initializer.</param>
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int InitializeInflate(int windowBits, bool expectRfc1950Header)
-        {
-            this.WindowBits = windowBits;
-            if (dstate != null) throw new ZlibException("You may not call InitializeInflate() after calling InitializeDeflate().");
-            istate = new InflateManager(expectRfc1950Header);
-            return istate.Initialize(this, windowBits);
-        }
-
-        /// <summary>
-        /// Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
-        /// </summary>
-        /// <remarks>
-        /// You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 
-        /// AvailableBytesOut  before calling this method.
-        /// </remarks>
-        /// <example>
-        /// <code>
-        /// private void InflateBuffer()
-        /// {
-        ///     int bufferSize = 1024;
-        ///     byte[] buffer = new byte[bufferSize];
-        ///     ZlibCodec decompressor = new ZlibCodec();
-        /// 
-        ///     Console.WriteLine("\n============================================");
-        ///     Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
-        ///     MemoryStream ms = new MemoryStream(DecompressedBytes);
-        /// 
-        ///     int rc = decompressor.InitializeInflate();
-        /// 
-        ///     decompressor.InputBuffer = CompressedBytes;
-        ///     decompressor.NextIn = 0;
-        ///     decompressor.AvailableBytesIn = CompressedBytes.Length;
-        /// 
-        ///     decompressor.OutputBuffer = buffer;
-        /// 
-        ///     // pass 1: inflate 
-        ///     do
-        ///     {
-        ///         decompressor.NextOut = 0;
-        ///         decompressor.AvailableBytesOut = buffer.Length;
-        ///         rc = decompressor.Inflate(FlushType.None);
-        /// 
-        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
-        ///             throw new Exception("inflating: " + decompressor.Message);
-        /// 
-        ///         ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
-        ///     }
-        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
-        /// 
-        ///     // pass 2: finish and flush
-        ///     do
-        ///     {
-        ///         decompressor.NextOut = 0;
-        ///         decompressor.AvailableBytesOut = buffer.Length;
-        ///         rc = decompressor.Inflate(FlushType.Finish);
-        /// 
-        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
-        ///             throw new Exception("inflating: " + decompressor.Message);
-        /// 
-        ///         if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)
-        ///             ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
-        ///     }
-        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
-        /// 
-        ///     decompressor.EndInflate();
-        /// }
-        ///
-        /// </code>
-        /// </example>
-        /// <param name="flush">The flush to use when inflating.</param>
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int Inflate(FlushType flush)
-        {
-            if (istate == null)
-                throw new ZlibException("No Inflate State!");
-            return istate.Inflate(flush);
-        }
-
-
-        /// <summary>
-        /// Ends an inflation session. 
-        /// </summary>
-        /// <remarks>
-        /// Call this after successively calling Inflate().  This will cause all buffers to be flushed. 
-        /// After calling this you cannot call Inflate() without a intervening call to one of the
-        /// InitializeInflate() overloads.
-        /// </remarks>
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int EndInflate()
-        {
-            if (istate == null)
-                throw new ZlibException("No Inflate State!");
-            int ret = istate.End();
-            istate = null;
-            return ret;
-        }
-
-        /// <summary>
-        /// I don't know what this does!
-        /// </summary>
-        /// <returns>Z_OK if everything goes well.</returns>
-        public int SyncInflate()
-        {
-            if (istate == null)
-                throw new ZlibException("No Inflate State!");
-            return istate.Sync();
-        }
-
-        /// <summary>
-        /// Initialize the ZlibCodec for deflation operation.
-        /// </summary>
-        /// <remarks>
-        /// The codec will use the MAX window bits and the default level of compression.
-        /// </remarks>
-        /// <example>
-        /// <code>
-        ///  int bufferSize = 40000;
-        ///  byte[] CompressedBytes = new byte[bufferSize];
-        ///  byte[] DecompressedBytes = new byte[bufferSize];
-        ///  
-        ///  ZlibCodec compressor = new ZlibCodec();
-        ///  
-        ///  compressor.InitializeDeflate(CompressionLevel.Default);
-        ///  
-        ///  compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
-        ///  compressor.NextIn = 0;
-        ///  compressor.AvailableBytesIn = compressor.InputBuffer.Length;
-        ///  
-        ///  compressor.OutputBuffer = CompressedBytes;
-        ///  compressor.NextOut = 0;
-        ///  compressor.AvailableBytesOut = CompressedBytes.Length;
-        ///  
-        ///  while (compressor.TotalBytesIn != TextToCompress.Length &amp;&amp; compressor.TotalBytesOut &lt; bufferSize)
-        ///  {
-        ///    compressor.Deflate(FlushType.None);
-        ///  }
-        ///  
-        ///  while (true)
-        ///  {
-        ///    int rc= compressor.Deflate(FlushType.Finish);
-        ///    if (rc == ZlibConstants.Z_STREAM_END) break;
-        ///  }
-        ///  
-        ///  compressor.EndDeflate();
-        ///   
-        /// </code>
-        /// </example>
-        /// <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>
-        public int InitializeDeflate()
-        {
-            return _InternalInitializeDeflate(true);
-        }
-
-        /// <summary>
-        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.
-        /// </summary>
-        /// <remarks>
-        /// The codec will use the maximum window bits (15) and the specified
-        /// CompressionLevel.  It will emit a ZLIB stream as it compresses.
-        /// </remarks>
-        /// <param name="level">The compression level for the codec.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int InitializeDeflate(CompressionLevel level)
-        {
-            this.CompressLevel = level;
-            return _InternalInitializeDeflate(true);
-        }
-
-
-        /// <summary>
-        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
-        /// and the explicit flag governing whether to emit an RFC1950 header byte pair.
-        /// </summary>
-        /// <remarks>
-        /// The codec will use the maximum window bits (15) and the specified CompressionLevel.
-        /// If you want to generate a zlib stream, you should specify true for
-        /// wantRfc1950Header. In this case, the library will emit a ZLIB
-        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
-        /// 1950</see>, in the compressed stream.  
-        /// </remarks>
-        /// <param name="level">The compression level for the codec.</param>
-        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int InitializeDeflate(CompressionLevel level, bool wantRfc1950Header)
-        {
-            this.CompressLevel = level;
-            return _InternalInitializeDeflate(wantRfc1950Header);
-        }
-
-
-        /// <summary>
-        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
-        /// and the specified number of window bits. 
-        /// </summary>
-        /// <remarks>
-        /// The codec will use the specified number of window bits and the specified CompressionLevel.
-        /// </remarks>
-        /// <param name="level">The compression level for the codec.</param>
-        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int InitializeDeflate(CompressionLevel level, int bits)
-        {
-            this.CompressLevel = level;
-            this.WindowBits = bits;
-            return _InternalInitializeDeflate(true);
-        }
-
-        /// <summary>
-        /// Initialize the ZlibCodec for deflation operation, using the specified
-        /// CompressionLevel, the specified number of window bits, and the explicit flag
-        /// governing whether to emit an RFC1950 header byte pair.
-        /// </summary>
-        ///
-        /// <param name="level">The compression level for the codec.</param>
-        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
-        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int InitializeDeflate(CompressionLevel level, int bits, bool wantRfc1950Header)
-        {
-            this.CompressLevel = level;
-            this.WindowBits = bits;
-            return _InternalInitializeDeflate(wantRfc1950Header);
-        }
-
-        private int _InternalInitializeDeflate(bool wantRfc1950Header)
-        {
-            if (istate != null) throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
-            dstate = new DeflateManager();
-            dstate.WantRfc1950HeaderBytes = wantRfc1950Header;
-
-            return dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy);
-        }
-
-        /// <summary>
-        /// Deflate one batch of data.
-        /// </summary>
-        /// <remarks>
-        /// You must have set InputBuffer and OutputBuffer before calling this method.
-        /// </remarks>
-        /// <example>
-        /// <code>
-        /// private void DeflateBuffer(CompressionLevel level)
-        /// {
-        ///     int bufferSize = 1024;
-        ///     byte[] buffer = new byte[bufferSize];
-        ///     ZlibCodec compressor = new ZlibCodec();
-        /// 
-        ///     Console.WriteLine("\n============================================");
-        ///     Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
-        ///     MemoryStream ms = new MemoryStream();
-        /// 
-        ///     int rc = compressor.InitializeDeflate(level);
-        /// 
-        ///     compressor.InputBuffer = UncompressedBytes;
-        ///     compressor.NextIn = 0;
-        ///     compressor.AvailableBytesIn = UncompressedBytes.Length;
-        /// 
-        ///     compressor.OutputBuffer = buffer;
-        /// 
-        ///     // pass 1: deflate 
-        ///     do
-        ///     {
-        ///         compressor.NextOut = 0;
-        ///         compressor.AvailableBytesOut = buffer.Length;
-        ///         rc = compressor.Deflate(FlushType.None);
-        /// 
-        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
-        ///             throw new Exception("deflating: " + compressor.Message);
-        /// 
-        ///         ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
-        ///     }
-        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
-        /// 
-        ///     // pass 2: finish and flush
-        ///     do
-        ///     {
-        ///         compressor.NextOut = 0;
-        ///         compressor.AvailableBytesOut = buffer.Length;
-        ///         rc = compressor.Deflate(FlushType.Finish);
-        /// 
-        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
-        ///             throw new Exception("deflating: " + compressor.Message);
-        /// 
-        ///         if (buffer.Length - compressor.AvailableBytesOut &gt; 0)
-        ///             ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
-        ///     }
-        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
-        /// 
-        ///     compressor.EndDeflate();
-        /// 
-        ///     ms.Seek(0, SeekOrigin.Begin);
-        ///     CompressedBytes = new byte[compressor.TotalBytesOut];
-        ///     ms.Read(CompressedBytes, 0, CompressedBytes.Length);
-        /// }
-        /// </code>
-        /// </example>
-        /// <param name="flush">whether to flush all data as you deflate. Generally you will want to 
-        /// use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to 
-        /// flush everything. 
-        /// </param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int Deflate(FlushType flush)
-        {
-            if (dstate == null)
-                throw new ZlibException("No Deflate State!");
-            return dstate.Deflate(flush);
-        }
-
-        /// <summary>
-        /// End a deflation session.
-        /// </summary>
-        /// <remarks>
-        /// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
-        /// </remarks>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int EndDeflate()
-        {
-            if (dstate == null)
-                throw new ZlibException("No Deflate State!");
-            // TODO: dinoch Tue, 03 Nov 2009  15:39 (test this)
-            //int ret = dstate.End();
-            dstate = null;
-            return ZlibConstants.Z_OK; //ret;
-        }
-
-        /// <summary>
-        /// Reset a codec for another deflation session.
-        /// </summary>
-        /// <remarks>
-        /// Call this to reset the deflation state.  For example if a thread is deflating
-        /// non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first
-        /// block and before the next Deflate(None) of the second block.
-        /// </remarks>
-        /// <returns>Z_OK if all goes well.</returns>
-        public void ResetDeflate()
-        {
-            if (dstate == null)
-                throw new ZlibException("No Deflate State!");
-            dstate.Reset();
-        }
-
-
-        /// <summary>
-        /// Set the CompressionStrategy and CompressionLevel for a deflation session.
-        /// </summary>
-        /// <param name="level">the level of compression to use.</param>
-        /// <param name="strategy">the strategy to use for compression.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int SetDeflateParams(CompressionLevel level, CompressionStrategy strategy)
-        {
-            if (dstate == null)
-                throw new ZlibException("No Deflate State!");
-            return dstate.SetParams(level, strategy);
-        }
-
-
-        /// <summary>
-        /// Set the dictionary to be used for either Inflation or Deflation.
-        /// </summary>
-        /// <param name="dictionary">The dictionary bytes to use.</param>
-        /// <returns>Z_OK if all goes well.</returns>
-        public int SetDictionary(byte[] dictionary)
-        {
-            if (istate != null)
-                return istate.SetDictionary(dictionary);
-
-            if (dstate != null)
-                return dstate.SetDictionary(dictionary);
-
-            throw new ZlibException("No Inflate or Deflate state!");
-        }
-
-        // Flush as much pending output as possible. All deflate() output goes
-        // through this function so some applications may wish to modify it
-        // to avoid allocating a large strm->next_out buffer and copying into it.
-        // (See also read_buf()).
-        internal void flush_pending()
-        {
-            int len = dstate.pendingCount;
-
-            if (len > AvailableBytesOut)
-                len = AvailableBytesOut;
-            if (len == 0)
-                return;
-
-            if (dstate.pending.Length <= dstate.nextPending ||
-                OutputBuffer.Length <= NextOut ||
-                dstate.pending.Length < (dstate.nextPending + len) ||
-                OutputBuffer.Length < (NextOut + len))
-            {
-                throw new ZlibException(String.Format("Invalid State. (pending.Length={0}, pendingCount={1})",
-                    dstate.pending.Length, dstate.pendingCount));
-            }
-
-            Array.Copy(dstate.pending, dstate.nextPending, OutputBuffer, NextOut, len);
-
-            NextOut             += len;
-            dstate.nextPending  += len;
-            TotalBytesOut       += len;
-            AvailableBytesOut   -= len;
-            dstate.pendingCount -= len;
-            if (dstate.pendingCount == 0)
-            {
-                dstate.nextPending = 0;
-            }
-        }
-
-        // Read a new buffer from the current input stream, update the adler32
-        // and total number of bytes read.  All deflate() input goes through
-        // this function so some applications may wish to modify it to avoid
-        // allocating a large strm->next_in buffer and copying from it.
-        // (See also flush_pending()).
-        internal int read_buf(byte[] buf, int start, int size)
-        {
-            int len = AvailableBytesIn;
-
-            if (len > size)
-                len = size;
-            if (len == 0)
-                return 0;
-
-            AvailableBytesIn -= len;
-
-            if (dstate.WantRfc1950HeaderBytes)
-            {
-                _Adler32 = Adler.Adler32(_Adler32, InputBuffer, NextIn, len);
-            }
-            Array.Copy(InputBuffer, NextIn, buf, start, len);
-            NextIn += len;
-            TotalBytesIn += len;
-            return len;
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/ZlibConstants.cs b/EPPlus/Packaging/DotNetZip/Zlib/ZlibConstants.cs
deleted file mode 100644
index 951f42a..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/ZlibConstants.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// ZlibConstants.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License. 
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs): 
-// Time-stamp: <2009-November-03 18:50:19>
-//
-// ------------------------------------------------------------------
-//
-// This module defines constants used by the zlib class library.  This
-// code is derived from the jzlib implementation of zlib, but
-// significantly modified.  In keeping with the license for jzlib, the
-// copyright to that code is included here.
-//
-// ------------------------------------------------------------------
-// 
-// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright 
-// notice, this list of conditions and the following disclaimer in 
-// the documentation and/or other materials provided with the distribution.
-// 
-// 3. The names of the authors may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-// -----------------------------------------------------------------------
-//
-// This program is based on zlib-1.1.3; credit to authors
-// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
-// and contributors of zlib.
-//
-// -----------------------------------------------------------------------
-
-
-using System;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-    /// <summary>
-    /// A bunch of constants used in the Zlib interface.
-    /// </summary>
-    public static class ZlibConstants
-    {
-        /// <summary>
-        /// The maximum number of window bits for the Deflate algorithm.
-        /// </summary>
-        public const int WindowBitsMax = 15; // 32K LZ77 window
-
-        /// <summary>
-        /// The default number of window bits for the Deflate algorithm.
-        /// </summary>
-        public const int WindowBitsDefault = WindowBitsMax;
-
-        /// <summary>
-        /// indicates everything is A-OK
-        /// </summary>
-        public const int Z_OK = 0;
-
-        /// <summary>
-        /// Indicates that the last operation reached the end of the stream.
-        /// </summary>
-        public const int Z_STREAM_END = 1;
-
-        /// <summary>
-        /// The operation ended in need of a dictionary. 
-        /// </summary>
-        public const int Z_NEED_DICT = 2;
-
-        /// <summary>
-        /// There was an error with the stream - not enough data, not open and readable, etc.
-        /// </summary>
-        public const int Z_STREAM_ERROR = -2;
-
-        /// <summary>
-        /// There was an error with the data - not enough data, bad data, etc.
-        /// </summary>
-        public const int Z_DATA_ERROR = -3;
-
-        /// <summary>
-        /// There was an error with the working buffer.
-        /// </summary>
-        public const int Z_BUF_ERROR = -5;
-
-        /// <summary>
-        /// The size of the working buffer used in the ZlibCodec class. Defaults to 8192 bytes.
-        /// </summary>
-#if NETCF        
-        public const int WorkingBufferSizeDefault = 8192;
-#else
-        public const int WorkingBufferSizeDefault = 16384; 
-#endif
-        /// <summary>
-        /// The minimum size of the working buffer used in the ZlibCodec class.  Currently it is 128 bytes.
-        /// </summary>
-        public const int WorkingBufferSizeMin = 1024;
-    }
-
-}
-
diff --git a/EPPlus/Packaging/DotNetZip/Zlib/ZlibStream.cs b/EPPlus/Packaging/DotNetZip/Zlib/ZlibStream.cs
deleted file mode 100644
index 460aee7..0000000
--- a/EPPlus/Packaging/DotNetZip/Zlib/ZlibStream.cs
+++ /dev/null
@@ -1,725 +0,0 @@
-// ZlibStream.cs
-// ------------------------------------------------------------------
-//
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
-// All rights reserved.
-//
-// This code module is part of DotNetZip, a zipfile class library.
-//
-// ------------------------------------------------------------------
-//
-// This code is licensed under the Microsoft Public License.
-// See the file License.txt for the license details.
-// More info on: http://dotnetzip.codeplex.com
-//
-// ------------------------------------------------------------------
-//
-// last saved (in emacs):
-// Time-stamp: <2011-July-31 14:53:33>
-//
-// ------------------------------------------------------------------
-//
-// This module defines the ZlibStream class, which is similar in idea to
-// the System.IO.Compression.DeflateStream and
-// System.IO.Compression.GZipStream classes in the .NET BCL.
-//
-// ------------------------------------------------------------------
-
-using System;
-using System.IO;
-
-namespace OfficeOpenXml.Packaging.Ionic.Zlib
-{
-
-    /// <summary>
-    /// Represents a Zlib stream for compression or decompression.
-    /// </summary>
-    /// <remarks>
-    ///
-    /// <para>
-    /// The ZlibStream is a <see
-    /// href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
-    /// cref="System.IO.Stream"/>.  It adds ZLIB compression or decompression to any
-    /// stream.
-    /// </para>
-    ///
-    /// <para> Using this stream, applications can compress or decompress data via
-    /// stream <c>Read()</c> and <c>Write()</c> operations.  Either compresssion or
-    /// decompression can occur through either reading or writing. The compression
-    /// format used is ZLIB, which is documented in <see
-    /// href="http://www.ietf.org/rfc/rfc1950.txt">IETF RFC 1950</see>, "ZLIB Compressed
-    /// Data Format Specification version 3.3". This implementation of ZLIB always uses
-    /// DEFLATE as the compression method.  (see <see
-    /// href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
-    /// Compressed Data Format Specification version 1.3.") </para>
-    ///
-    /// <para>
-    /// The ZLIB format allows for varying compression methods, window sizes, and dictionaries.
-    /// This implementation always uses the DEFLATE compression method, a preset dictionary,
-    /// and 15 window bits by default.
-    /// </para>
-    ///
-    /// <para>
-    /// This class is similar to <see cref="DeflateStream"/>, except that it adds the
-    /// RFC1950 header and trailer bytes to a compressed stream when compressing, or expects
-    /// the RFC1950 header and trailer bytes when decompressing.  It is also similar to the
-    /// <see cref="GZipStream"/>.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="DeflateStream" />
-    /// <seealso cref="GZipStream" />
-    public class ZlibStream : System.IO.Stream
-    {
-        internal ZlibBaseStream _baseStream;
-        bool _disposed;
-
-        /// <summary>
-        /// Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>.
-        /// </summary>
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c>
-        ///   will use the default compression level. The "captive" stream will be
-        ///   closed when the <c>ZlibStream</c> is closed.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        /// This example uses a <c>ZlibStream</c> to compress a file, and writes the
-        /// compressed data to another file.
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
-        ///     {
-        ///         using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
-        ///     Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)
-        ///         Dim buffer As Byte() = New Byte(4096) {}
-        ///         Dim n As Integer = -1
-        ///         Do While (n &lt;&gt; 0)
-        ///             If (n &gt; 0) Then
-        ///                 compressor.Write(buffer, 0, n)
-        ///             End If
-        ///             n = input.Read(buffer, 0, buffer.Length)
-        ///         Loop
-        ///     End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="stream">The stream which will be read or written.</param>
-        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
-        public ZlibStream(System.IO.Stream stream, CompressionMode mode)
-            : this(stream, mode, CompressionLevel.Default, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c> and
-        ///   the specified <c>CompressionLevel</c>.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
-        ///   The "captive" stream will be closed when the <c>ZlibStream</c> is closed.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///   This example uses a <c>ZlibStream</c> to compress data from a file, and writes the
-        ///   compressed data to another file.
-        ///
-        /// <code>
-        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        /// {
-        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
-        ///     {
-        ///         using (Stream compressor = new ZlibStream(raw,
-        ///                                                   CompressionMode.Compress,
-        ///                                                   CompressionLevel.BestCompression))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        /// }
-        /// </code>
-        ///
-        /// <code lang="VB">
-        /// Using input As Stream = File.OpenRead(fileToCompress)
-        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
-        ///         Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
-        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
-        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
-        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
-            : this(stream, mode, level, false)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>, and
-        ///   explicitly specify whether the captive stream should be left open after
-        ///   Deflation or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c> will use
-        ///   the default compression level.
-        /// </para>
-        ///
-        /// <para>
-        ///   This constructor allows the application to request that the captive stream
-        ///   remain open after the deflation or inflation occurs.  By default, after
-        ///   <c>Close()</c> is called on the stream, the captive stream is also
-        ///   closed. In some cases this is not desired, for example if the stream is a
-        ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
-        ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream
-        ///   open.
-        /// </para>
-        ///
-        /// <para>
-        /// See the other overloads of this constructor for example code.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="stream">The stream which will be read or written. This is called the
-        /// "captive" stream in other places in this documentation.</param>
-        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
-        /// <param name="leaveOpen">true if the application would like the stream to remain
-        /// open after inflation/deflation.</param>
-        public ZlibStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
-            : this(stream, mode, CompressionLevel.Default, leaveOpen)
-        {
-        }
-
-        /// <summary>
-        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>
-        ///   and the specified <c>CompressionLevel</c>, and explicitly specify
-        ///   whether the stream should be left open after Deflation or Inflation.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   This constructor allows the application to request that the captive
-        ///   stream remain open after the deflation or inflation occurs.  By
-        ///   default, after <c>Close()</c> is called on the stream, the captive
-        ///   stream is also closed. In some cases this is not desired, for example
-        ///   if the stream is a <see cref="System.IO.MemoryStream"/> that will be
-        ///   re-read after compression.  Specify true for the <paramref
-        ///   name="leaveOpen"/> parameter to leave the stream open.
-        /// </para>
-        ///
-        /// <para>
-        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
-        ///   ignored.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <example>
-        ///
-        /// This example shows how to use a ZlibStream to compress the data from a file,
-        /// and store the result into another file. The filestream remains open to allow
-        /// additional data to be written to it.
-        ///
-        /// <code>
-        /// using (var output = System.IO.File.Create(fileToCompress + ".zlib"))
-        /// {
-        ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
-        ///     {
-        ///         using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
-        ///         {
-        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
-        ///             int n;
-        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
-        ///             {
-        ///                 compressor.Write(buffer, 0, n);
-        ///             }
-        ///         }
-        ///     }
-        ///     // can write additional data to the output stream here
-        /// }
-        /// </code>
-        /// <code lang="VB">
-        /// Using output As FileStream = File.Create(fileToCompress &amp; ".zlib")
-        ///     Using input As Stream = File.OpenRead(fileToCompress)
-        ///         Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
-        ///             Dim buffer As Byte() = New Byte(4096) {}
-        ///             Dim n As Integer = -1
-        ///             Do While (n &lt;&gt; 0)
-        ///                 If (n &gt; 0) Then
-        ///                     compressor.Write(buffer, 0, n)
-        ///                 End If
-        ///                 n = input.Read(buffer, 0, buffer.Length)
-        ///             Loop
-        ///         End Using
-        ///     End Using
-        ///     ' can write additional data to the output stream here.
-        /// End Using
-        /// </code>
-        /// </example>
-        ///
-        /// <param name="stream">The stream which will be read or written.</param>
-        ///
-        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
-        ///
-        /// <param name="leaveOpen">
-        /// true if the application would like the stream to remain open after
-        /// inflation/deflation.
-        /// </param>
-        ///
-        /// <param name="level">
-        /// A tuning knob to trade speed for effectiveness. This parameter is
-        /// effective only when mode is <c>CompressionMode.Compress</c>.
-        /// </param>
-        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
-        {
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
-        }
-
-        #region Zlib properties
-
-        /// <summary>
-        /// This property sets the flush behavior on the stream.
-        /// Sorry, though, not sure exactly how to describe all the various settings.
-        /// </summary>
-        virtual public FlushType FlushMode
-        {
-            get { return (this._baseStream._flushMode); }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-                this._baseStream._flushMode = value;
-            }
-        }
-
-        /// <summary>
-        ///   The size of the working buffer for the compression codec.
-        /// </summary>
-        ///
-        /// <remarks>
-        /// <para>
-        ///   The working buffer is used for all stream operations.  The default size is
-        ///   1024 bytes. The minimum size is 128 bytes. You may get better performance
-        ///   with a larger buffer.  Then again, you might not.  You would have to test
-        ///   it.
-        /// </para>
-        ///
-        /// <para>
-        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
-        ///   stream. If you try to set it afterwards, it will throw.
-        /// </para>
-        /// </remarks>
-        public int BufferSize
-        {
-            get
-            {
-                return this._baseStream._bufferSize;
-            }
-            set
-            {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-                if (this._baseStream._workingBuffer != null)
-                    throw new ZlibException("The working buffer is already set.");
-                if (value < ZlibConstants.WorkingBufferSizeMin)
-                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
-                this._baseStream._bufferSize = value;
-            }
-        }
-
-        /// <summary> Returns the total number of bytes input so far.</summary>
-        virtual public long TotalIn
-        {
-            get { return this._baseStream._z.TotalBytesIn; }
-        }
-
-        /// <summary> Returns the total number of bytes output so far.</summary>
-        virtual public long TotalOut
-        {
-            get { return this._baseStream._z.TotalBytesOut; }
-        }
-
-        #endregion
-
-        #region System.IO.Stream methods
-
-        /// <summary>
-        ///   Dispose the stream.
-        /// </summary>
-        /// <remarks>
-        ///   <para>
-        ///     This may or may not result in a <c>Close()</c> call on the captive
-        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
-        ///     for more information.
-        ///   </para>
-        ///   <para>
-        ///     This method may be invoked in two distinct scenarios.  If disposing
-        ///     == true, the method has been called directly or indirectly by a
-        ///     user's code, for example via the public Dispose() method. In this
-        ///     case, both managed and unmanaged resources can be referenced and
-        ///     disposed.  If disposing == false, the method has been called by the
-        ///     runtime from inside the object finalizer and this method should not
-        ///     reference other objects; in that case only unmanaged resources must
-        ///     be referenced or disposed.
-        ///   </para>
-        /// </remarks>
-        /// <param name="disposing">
-        ///   indicates whether the Dispose method was invoked by user code.
-        /// </param>
-        protected override void Dispose(bool disposing)
-        {
-            try
-            {
-                if (!_disposed)
-                {
-                    if (disposing && (this._baseStream != null))
-                        this._baseStream.Close();
-                    _disposed = true;
-                }
-            }
-            finally
-            {
-                base.Dispose(disposing);
-            }
-        }
-
-
-        /// <summary>
-        /// Indicates whether the stream can be read.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports reading.
-        /// </remarks>
-        public override bool CanRead
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-                return _baseStream._stream.CanRead;
-            }
-        }
-
-        /// <summary>
-        /// Indicates whether the stream supports Seek operations.
-        /// </summary>
-        /// <remarks>
-        /// Always returns false.
-        /// </remarks>
-        public override bool CanSeek
-        {
-            get { return false; }
-        }
-
-        /// <summary>
-        /// Indicates whether the stream can be written.
-        /// </summary>
-        /// <remarks>
-        /// The return value depends on whether the captive stream supports writing.
-        /// </remarks>
-        public override bool CanWrite
-        {
-            get
-            {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-                return _baseStream._stream.CanWrite;
-            }
-        }
-
-        /// <summary>
-        /// Flush the stream.
-        /// </summary>
-        public override void Flush()
-        {
-            if (_disposed) throw new ObjectDisposedException("ZlibStream");
-            _baseStream.Flush();
-        }
-
-        /// <summary>
-        /// Reading this property always throws a <see cref="NotSupportedException"/>.
-        /// </summary>
-        public override long Length
-        {
-            get { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        ///   The position of the stream pointer.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Setting this property always throws a <see
-        ///   cref="NotSupportedException"/>. Reading will return the total bytes
-        ///   written out, if used in writing, or the total bytes read in, if used in
-        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
-        ///   depending on how you've used the stream.
-        /// </remarks>
-        public override long Position
-        {
-            get
-            {
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Writer)
-                    return this._baseStream._z.TotalBytesOut;
-                if (this._baseStream._streamMode == Ionic.Zlib.ZlibBaseStream.StreamMode.Reader)
-                    return this._baseStream._z.TotalBytesIn;
-                return 0;
-            }
-
-            set { throw new NotSupportedException(); }
-        }
-
-        /// <summary>
-        /// Read data from the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If you wish to use the <c>ZlibStream</c> to compress data while reading,
-        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
-        ///   providing an uncompressed data stream.  Then call <c>Read()</c> on that
-        ///   <c>ZlibStream</c>, and the data read will be compressed.  If you wish to
-        ///   use the <c>ZlibStream</c> to decompress data while reading, you can create
-        ///   a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, providing a
-        ///   readable compressed data stream.  Then call <c>Read()</c> on that
-        ///   <c>ZlibStream</c>, and the data will be decompressed as it is read.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but
-        ///   not both.
-        /// </para>
-        ///
-        /// </remarks>
-        ///
-        /// <param name="buffer">
-        /// The buffer into which the read data should be placed.</param>
-        ///
-        /// <param name="offset">
-        /// the offset within that data array to put the first byte read.</param>
-        ///
-        /// <param name="count">the number of bytes to read.</param>
-        ///
-        /// <returns>the number of bytes read</returns>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-            return _baseStream.Read(buffer, offset, count);
-        }
-
-        /// <summary>
-        /// Calling this method always throws a <see cref="NotSupportedException"/>.
-        /// </summary>
-        /// <param name="offset">
-        ///   The offset to seek to....
-        ///   IF THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        /// <param name="origin">
-        ///   The reference specifying how to apply the offset....  IF
-        ///   THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        ///
-        /// <returns>nothing. This method always throws.</returns>
-        public override long Seek(long offset, System.IO.SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// Calling this method always throws a <see cref="NotSupportedException"/>.
-        /// </summary>
-        /// <param name="value">
-        ///   The new value for the stream length....  IF
-        ///   THIS METHOD ACTUALLY DID ANYTHING.
-        /// </param>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// Write data to the stream.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///
-        /// <para>
-        ///   If you wish to use the <c>ZlibStream</c> to compress data while writing,
-        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
-        ///   and a writable output stream.  Then call <c>Write()</c> on that
-        ///   <c>ZlibStream</c>, providing uncompressed data as input.  The data sent to
-        ///   the output stream will be the compressed form of the data written.  If you
-        ///   wish to use the <c>ZlibStream</c> to decompress data while writing, you
-        ///   can create a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, and a
-        ///   writable output stream.  Then call <c>Write()</c> on that stream,
-        ///   providing previously compressed data. The data sent to the output stream
-        ///   will be the decompressed form of the data written.
-        /// </para>
-        ///
-        /// <para>
-        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
-        /// </para>
-        /// </remarks>
-        /// <param name="buffer">The buffer holding data to write to the stream.</param>
-        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
-        /// <param name="count">the number of bytes to write.</param>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-                if (_disposed) throw new ObjectDisposedException("ZlibStream");
-            _baseStream.Write(buffer, offset, count);
-        }
-        #endregion
-
-
-        /// <summary>
-        ///   Compress a string into a byte array using ZLIB.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="ZlibStream.UncompressString(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
-        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
-        /// <seealso cref="GZipStream.CompressString(string)"/>
-        ///
-        /// <param name="s">
-        ///   A string to compress.  The string will first be encoded
-        ///   using UTF8, then compressed.
-        /// </param>
-        ///
-        /// <returns>The string in compressed form</returns>
-        public static byte[] CompressString(String s)
-        {
-            using (var ms = new MemoryStream())
-            {
-                Stream compressor =
-                    new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
-                ZlibBaseStream.CompressString(s, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Compress a byte array into a new byte array using ZLIB.
-        /// </summary>
-        ///
-        /// <remarks>
-        ///   Uncompress it with <see cref="ZlibStream.UncompressBuffer(byte[])"/>.
-        /// </remarks>
-        ///
-        /// <seealso cref="ZlibStream.CompressString(string)"/>
-        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
-        ///
-        /// <param name="b">
-        /// A buffer to compress.
-        /// </param>
-        ///
-        /// <returns>The data in compressed form</returns>
-        public static byte[] CompressBuffer(byte[] b)
-        {
-            using (var ms = new MemoryStream())
-            {
-                Stream compressor =
-                    new ZlibStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
-
-                ZlibBaseStream.CompressBuffer(b, compressor);
-                return ms.ToArray();
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a ZLIB-compressed byte array into a single string.
-        /// </summary>
-        ///
-        /// <seealso cref="ZlibStream.CompressString(String)"/>
-        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing ZLIB-compressed data.
-        /// </param>
-        ///
-        /// <returns>The uncompressed string</returns>
-        public static String UncompressString(byte[] compressed)
-        {
-            using (var input = new MemoryStream(compressed))
-            {
-                Stream decompressor =
-                    new ZlibStream(input, CompressionMode.Decompress);
-
-                return ZlibBaseStream.UncompressString(compressed, decompressor);
-            }
-        }
-
-
-        /// <summary>
-        ///   Uncompress a ZLIB-compressed byte array into a byte array.
-        /// </summary>
-        ///
-        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
-        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
-        ///
-        /// <param name="compressed">
-        ///   A buffer containing ZLIB-compressed data.
-        /// </param>
-        ///
-        /// <returns>The data in uncompressed form</returns>
-        public static byte[] UncompressBuffer(byte[] compressed)
-        {
-            using (var input = new MemoryStream(compressed))
-            {
-                Stream decompressor =
-                    new ZlibStream( input, CompressionMode.Decompress );
-
-                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
-            }
-        }
-
-    }
-
-
-}
\ No newline at end of file
diff --git a/EPPlus/Packaging/ZipPackage.cs b/EPPlus/Packaging/ZipPackage.cs
index 9c6c8b4..c47d5ea 100644
--- a/EPPlus/Packaging/ZipPackage.cs
+++ b/EPPlus/Packaging/ZipPackage.cs
@@ -34,10 +34,9 @@
 using System.Linq;
 using System.Text;
 using System.IO;
+using System.IO.Compression;
 using System.Xml;
 using OfficeOpenXml.Utils;
-using OfficeOpenXml.Packaging.Ionic.Zip;
-using Ionic.Zip;
 namespace OfficeOpenXml.Packaging
 {
     /// <summary>
@@ -93,82 +92,75 @@
             }
             else
             {
-                var rels = new Dictionary<string, string>();
-                stream.Seek(0, SeekOrigin.Begin);                
-                using (ZipInputStream zip = new ZipInputStream(stream))
+                var rels = new Dictionary<string, ZipArchiveEntry>();
+                stream.Seek(0, SeekOrigin.Begin);
+                using var zip = new ZipArchive(stream);
+                foreach (var e in zip.Entries)
                 {
-                    var e = zip.GetNextEntry();
-                    while (e != null)
+                    if (e.Length > 0)
                     {
-                        if (e.UncompressedSize > 0)
+                        if (e.FullName .Equals("[content_types].xml", StringComparison.InvariantCultureIgnoreCase))
                         {
-                            var b = new byte[e.UncompressedSize];
-                            var size = zip.Read(b, 0, (int)e.UncompressedSize);
-                            if (e.FileName.Equals("[content_types].xml", StringComparison.InvariantCultureIgnoreCase))
-                            {
-                                AddContentTypes(Encoding.UTF8.GetString(b));
-                                hasContentTypeXml = true;
-                            }
-                            else if (e.FileName.Equals("_rels/.rels", StringComparison.InvariantCultureIgnoreCase)) 
-                            {
-                                ReadRelation(Encoding.UTF8.GetString(b), "");
-                            }
-                            else
-                            {
-                                if (e.FileName.EndsWith(".rels", StringComparison.InvariantCultureIgnoreCase))
-                                {
-                                    rels.Add(GetUriKey(e.FileName), Encoding.UTF8.GetString(b));
-                                }
-                                else
-                                {
-                                    var part = new ZipPackagePart(this, e);
-                                    part.Stream = new MemoryStream();
-                                    part.Stream.Write(b, 0, b.Length);
-                                    Parts.Add(GetUriKey(e.FileName), part);
-                                }
-                            }
+                            using var inputStream = e.Open();
+                            AddContentTypes(inputStream);
+                            hasContentTypeXml = true;
+                        }
+                        else if (e.FullName .Equals("_rels/.rels", StringComparison.InvariantCultureIgnoreCase)) 
+                        {
+                            using var inputStream = e.Open();
+                            ReadRelation(inputStream, "");
                         }
                         else
                         {
+                            if (e.FullName.EndsWith(".rels", StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                rels.Add(GetUriKey(e.FullName), e);
+                            }
+                            else
+                            {
+                                using var inputStream = e.Open();
+                                var part = new ZipPackagePart(this, e);
+                                part.Stream = new MemoryStream();
+                                inputStream.CopyTo(part.Stream);
+                                Parts.Add(GetUriKey(e.FullName), part);
+                            }
                         }
-                        e = zip.GetNextEntry();
                     }
-
-                    foreach (var p in Parts)
+                }
+                foreach (var p in Parts)
+                {
+                    string name = Path.GetFileName(p.Key);
+                    string extension = Path.GetExtension(p.Key);
+                    string relFile = string.Format("{0}_rels/{1}.rels", p.Key.Substring(0, p.Key.Length - name.Length), name);
+                    if (rels.TryGetValue(relFile, out var zipArchiveEntry))
                     {
-                        string name = Path.GetFileName(p.Key);
-                        string extension = Path.GetExtension(p.Key);
-                        string relFile = string.Format("{0}_rels/{1}.rels", p.Key.Substring(0, p.Key.Length - name.Length), name);
-                        if (rels.ContainsKey(relFile))
-                        {
-                            p.Value.ReadRelation(rels[relFile], p.Value.Uri.OriginalString);
-                        }
-                        if (_contentTypes.ContainsKey(p.Key))
-                        {
-                            p.Value.ContentType = _contentTypes[p.Key].Name;
-                        }
-                        else if (extension.Length > 1 && _contentTypes.ContainsKey(extension.Substring(1)))
-                        {
-                            p.Value.ContentType = _contentTypes[extension.Substring(1)].Name;
-                        }
+                        using var inputStream = zipArchiveEntry.Open();
+                        p.Value.ReadRelation(inputStream, p.Value.Uri.OriginalString);
                     }
-                    if (!hasContentTypeXml)
+                    if (_contentTypes.TryGetValue(p.Key, out var type))
                     {
-                        throw (new InvalidDataException("The file is not an valid Package file. If the file is encrypted, please supply the password in the constructor."));
+                        p.Value.ContentType = type.Name;
                     }
-                    if (!hasContentTypeXml)
+                    else if (extension.Length > 1 && _contentTypes.ContainsKey(extension.Substring(1)))
                     {
-                        throw (new InvalidDataException("The file is not an valid Package file. If the file is encrypted, please supply the password in the constructor."));
+                        p.Value.ContentType = _contentTypes[extension.Substring(1)].Name;
                     }
-                    zip.Close();
+                }
+                if (!hasContentTypeXml)
+                {
+                    throw (new InvalidDataException("The file is not an valid Package file. If the file is encrypted, please supply the password in the constructor."));
+                }
+                if (!hasContentTypeXml)
+                {
+                    throw (new InvalidDataException("The file is not an valid Package file. If the file is encrypted, please supply the password in the constructor."));
                 }
             }
         }
 
-        private void AddContentTypes(string xml)
+        private void AddContentTypes(Stream inputStream)
         {
             var doc = new XmlDocument();
-            XmlHelper.LoadXmlSafe(doc, xml, Encoding.UTF8);
+            XmlHelper.LoadXmlSafe(doc, inputStream);
 
             foreach (XmlElement c in doc.DocumentElement.ChildNodes)
             {
@@ -260,21 +252,21 @@
         }
         internal void Save(Stream stream)
         {
-            var enc = Encoding.UTF8;
-            ZipOutputStream os = new ZipOutputStream(stream, true);
-            os.CompressionLevel = (OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel)_compression;            
+            using var zipArchive = new ZipArchive(stream, ZipArchiveMode.Create);
             /**** ContentType****/
-            var entry = os.PutNextEntry("[Content_Types].xml");
-            byte[] b = enc.GetBytes(GetContentTypeXml());
-            os.Write(b, 0, b.Length);
+            var contentTypesEntry = zipArchive.CreateEntry("[Content_Types].xml");
+            using (var contentTypesWriter = new StreamWriter(contentTypesEntry.Open()))
+            {
+                contentTypesWriter.Write(GetContentTypeXml());
+            }
             /**** Top Rels ****/
-            _rels.WriteZip(os, "_rels\\.rels");
+            _rels.WriteZip(zipArchive, "_rels\\.rels");
             ZipPackagePart ssPart=null;
             foreach(var part in Parts.Values)
             {
                 if (part.ContentType != ExcelPackage.contentTypeSharedString)
                 {
-                    part.WriteZip(os);
+                    part.WriteZip(zipArchive);
                 }
                 else
                 {
@@ -284,12 +276,8 @@
             //Shared strings must be saved after all worksheets. The ss dictionary is populated when that workheets are saved (to get the best performance).
             if (ssPart != null)
             {
-                ssPart.WriteZip(os);
+                ssPart.WriteZip(zipArchive);
             }
-            os.Flush();
-            os.Close();
-            os.Dispose();  
-            
             //return ms;
         }
 
diff --git a/EPPlus/Packaging/ZipPackagePart.cs b/EPPlus/Packaging/ZipPackagePart.cs
index 5d45c35..06ca810 100644
--- a/EPPlus/Packaging/ZipPackagePart.cs
+++ b/EPPlus/Packaging/ZipPackagePart.cs
@@ -29,24 +29,20 @@
  * Jan Källman		Added		25-Oct-2012
  *******************************************************************************/
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.IO;
-using OfficeOpenXml.Packaging.Ionic.Zip;
+using System.IO.Compression;
 
 namespace OfficeOpenXml.Packaging
 {
     internal class ZipPackagePart : ZipPackageRelationshipBase, IDisposable
     {
-        internal delegate void SaveHandlerDelegate(ZipOutputStream stream, CompressionLevel compressionLevel, string fileName);
+        internal delegate void SaveHandlerDelegate(StreamWriter streamWriter);
 
-        internal ZipPackagePart(ZipPackage package, ZipEntry entry)
+        internal ZipPackagePart(ZipPackage package, ZipArchiveEntry entry)
         {
             Package = package;
-            Entry = entry;
             SaveHandler = null;
-            Uri = new Uri(package.GetUriKey(entry.FileName), UriKind.Relative);
+            Uri = new Uri(package.GetUriKey(entry.FullName), UriKind.Relative);
         }
         internal ZipPackagePart(ZipPackage package, Uri partUri, string contentType, CompressionLevel compressionLevel)
         {
@@ -58,7 +54,6 @@
             CompressionLevel = compressionLevel;
         }
         internal ZipPackage Package { get; set; }
-        internal ZipEntry Entry { get; set; }
         internal CompressionLevel CompressionLevel;
         MemoryStream _stream = null;
         internal MemoryStream Stream
@@ -121,18 +116,12 @@
             }
         }
         public Uri Uri { get; private set; }
-        public Stream GetZipStream()
-        {
-            MemoryStream ms = new MemoryStream();
-            ZipOutputStream os = new ZipOutputStream(ms);
-            return os;
-        }
         internal SaveHandlerDelegate SaveHandler
         {
             get;
             set;
         }
-        internal void WriteZip(ZipOutputStream os)
+        internal void WriteZip(ZipArchive zipArchive)
         {
             byte[] b;
             if (SaveHandler == null)
@@ -142,20 +131,22 @@
                 {
                     return;
                 }
-                os.CompressionLevel = (OfficeOpenXml.Packaging.Ionic.Zlib.CompressionLevel)CompressionLevel;
-                os.PutNextEntry(Uri.OriginalString);
-                os.Write(b, 0, b.Length);
+                var zipEntry = zipArchive.CreateEntry(Uri.OriginalString);
+                using var os = zipEntry.Open();
+                os.Write(b);
             }
             else
             {
-                SaveHandler(os, (CompressionLevel)CompressionLevel, Uri.OriginalString);
+                var zipEntry = zipArchive.CreateEntry(Uri.OriginalString);
+                using var streamWriter = new StreamWriter(zipEntry.Open());
+                SaveHandler(streamWriter);
             }
 
             if (_rels.Count > 0)
             {
                 string f = Uri.OriginalString;
                 var name = Path.GetFileName(f);
-                _rels.WriteZip(os, (string.Format("{0}_rels/{1}.rels", f.Substring(0, f.Length - name.Length), name)));
+                _rels.WriteZip(zipArchive, $"{f.Substring(0, f.Length - name.Length)}_rels/{name}.rels");
             }
             b = null;
         }
diff --git a/EPPlus/Packaging/ZipPackageRelationship.cs b/EPPlus/Packaging/ZipPackageRelationship.cs
index 2c04a28..7bb7a50 100644
--- a/EPPlus/Packaging/ZipPackageRelationship.cs
+++ b/EPPlus/Packaging/ZipPackageRelationship.cs
@@ -29,9 +29,6 @@
  * Jan Källman		Added		25-Oct-2012
  *******************************************************************************/
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace OfficeOpenXml.Packaging
 {
diff --git a/EPPlus/Packaging/ZipPackageRelationshipBase.cs b/EPPlus/Packaging/ZipPackageRelationshipBase.cs
index 60b6948..b0bd124 100644
--- a/EPPlus/Packaging/ZipPackageRelationshipBase.cs
+++ b/EPPlus/Packaging/ZipPackageRelationshipBase.cs
@@ -29,21 +29,15 @@
  * Jan Källman		Added		25-Oct-2012
  *******************************************************************************/
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Ionic.Zip;
 using System.IO;
 using System.Xml;
-using OfficeOpenXml.Packaging.Ionic.Zlib;
-using System.Web;
+
 namespace OfficeOpenXml.Packaging
 {
     public abstract class ZipPackageRelationshipBase
     {
         protected ZipPackageRelationshipCollection _rels = new ZipPackageRelationshipCollection();
-        protected internal 
-        int maxRId = 1;
+        protected internal int maxRId = 1;
         internal void DeleteRelationship(string id)
         {
             _rels.Remove(id);
@@ -89,10 +83,10 @@
         {
             return _rels[id];
         }
-        internal void ReadRelation(string xml, string source)
+        internal void ReadRelation(Stream inputStream, string source)
         {
             var doc = new XmlDocument();
-            XmlHelper.LoadXmlSafe(doc, xml, Encoding.UTF8);
+            XmlHelper.LoadXmlSafe(doc, inputStream);
 
             foreach (XmlElement c in doc.DocumentElement.ChildNodes)
             {
diff --git a/EPPlus/Packaging/ZipPackageRelationshipCollection.cs b/EPPlus/Packaging/ZipPackageRelationshipCollection.cs
index df1ce86..0820322 100644
--- a/EPPlus/Packaging/ZipPackageRelationshipCollection.cs
+++ b/EPPlus/Packaging/ZipPackageRelationshipCollection.cs
@@ -30,12 +30,9 @@
  *******************************************************************************/
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Ionic.Zip;
 using System.IO;
+using System.IO.Compression;
 using System.Security;
-using OfficeOpenXml.Packaging.Ionic.Zip;
 
 namespace OfficeOpenXml.Packaging
 {
@@ -84,18 +81,17 @@
             return ret;
         }
 
-        internal void WriteZip(ZipOutputStream os, string fileName)
+        internal void WriteZip(ZipArchive zipArchive, string filename)
         {
-            StringBuilder xml = new StringBuilder("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
+            var entry = zipArchive.CreateEntry(filename);
+            using var writer = new StreamWriter(entry.Open());
+                
+            writer.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
             foreach (var rel in _rels.Values)
             {
-                xml.AppendFormat("<Relationship Id=\"{0}\" Type=\"{1}\" Target=\"{2}\"{3}/>", SecurityElement.Escape(rel.Id), rel.RelationshipType, SecurityElement.Escape(rel.TargetUri.OriginalString), rel.TargetMode == TargetMode.External ? " TargetMode=\"External\"" : "");
+                writer.Write("<Relationship Id=\"{0}\" Type=\"{1}\" Target=\"{2}\"{3}/>", SecurityElement.Escape(rel.Id), rel.RelationshipType, SecurityElement.Escape(rel.TargetUri.OriginalString), rel.TargetMode == TargetMode.External ? " TargetMode=\"External\"" : "");
             }
-            xml.Append("</Relationships>");
-
-            os.PutNextEntry(fileName);
-            byte[] b = Encoding.UTF8.GetBytes(xml.ToString());
-            os.Write(b, 0, b.Length);
+            writer.Write("</Relationships>");
         }
 
         public int Count