Third Assets Part01

Assets/ThirdAssets/Best HTTP (Pro).meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9eaf2c79c5e1be6469b1249965b5ae47
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1fe8980d891271c4598595fa0c3ec70a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c3ac3a7a67299e1429d02e0796bc0329
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/Credentials.cs

@@ -0,0 +1,63 @@
+namespace BestHTTP.Authentication
+{
+    /// <summary>
+    /// Authentication types that supported by BestHTTP.
+    /// The authentication is defined by the server, so the Basic and Digest are not interchangeable. If you don't know what to use, the preferred way is to choose Unknow.
+    /// </summary>
+    public enum AuthenticationTypes
+    {
+        /// <summary>
+        /// If the authentication type is not known this will do a challenge turn to receive what methode should be choosen.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// The most basic authentication type. It's easy to do, and easy to crack. ;)
+        /// </summary>
+        Basic,
+
+        /// <summary>
+        /// 
+        /// </summary>
+        Digest
+    }
+
+    /// <summary>
+    /// Hold all information that required to authenticate to a remote server.
+    /// </summary>
+    public sealed class Credentials
+    {
+        /// <summary>
+        /// The type of the Authentication. If you don't know what to use, the preferred way is to choose Unknow.
+        /// </summary>
+        public AuthenticationTypes Type { get; private set; }
+
+        /// <summary>
+        /// The username to authenticate on the remote server.
+        /// </summary>
+        public string UserName { get; private set; }
+
+        /// <summary>
+        /// The password to use in the authentication process. The password will be stored only in this class.
+        /// </summary>
+        public string Password { get; private set; }
+
+        /// <summary>
+        /// Set up the authentication credentials with the username and password. The Type will be set to Unknown.
+        /// </summary>
+        public Credentials(string userName, string password)
+            :this(AuthenticationTypes.Unknown, userName, password)
+        {
+        }
+
+        /// <summary>
+        /// Set up the authentication credentials with the given authentication type, username and password.
+        /// </summary>
+        public Credentials(AuthenticationTypes type, string userName, string password)
+        {
+            this.Type = type;
+            this.UserName = userName;
+            this.Password = password;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/Credentials.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: a6a6217993b733a4e8555355d5d62776
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/Digest.cs

@@ -0,0 +1,280 @@
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Authentication
+{
+    using BestHTTP.Extensions;
+    using System.Text;
+
+    /// <summary>
+    /// Internal class that stores all information that received from a server in a WWW-Authenticate and need to construct a valid Authorization header. Based on rfc 2617 (http://tools.ietf.org/html/rfc2617).
+    /// Used only internally by the plugin.
+    /// </summary>
+    public sealed class Digest
+    {
+        #region Public Properties
+
+        /// <summary>
+        /// The Uri that this Digest is bound to.
+        /// </summary>
+        public Uri Uri { get; private set; }
+
+        public AuthenticationTypes Type { get; private set; }
+
+        /// <summary>
+        /// A string to be displayed to users so they know which username and password to use.
+        /// This string should contain at least the name of the host performing the authentication and might additionally indicate the collection of users who might have access.
+        /// </summary>
+        public string Realm { get; private set; }
+
+        /// <summary>
+        /// A flag, indicating that the previous request from the client was rejected because the nonce value was stale.
+        /// If stale is TRUE (case-insensitive), the client may wish to simply retry the request with a new encrypted response, without  the user for a new username and password.
+        /// The server should only set stale to TRUE if it receives a request for which the nonce is invalid but with a valid digest for that nonce
+        /// (indicating that the client knows the correct username/password).
+        /// If stale is FALSE, or anything other than TRUE, or the stale directive is not present, the username and/or password are invalid, and new values must be obtained.
+        /// </summary>
+        public bool Stale { get; private set; }
+
+        #endregion
+
+        #region Private Properties
+
+        /// <summary>
+        /// A server-specified data string which should be uniquely generated each time a 401 response is made.
+        /// Specifically, since the string is passed in the header lines as a quoted string, the double-quote character is not allowed.
+        /// </summary>
+        private string Nonce { get; set; }
+
+        /// <summary>
+        /// A string of data, specified by the server, which should be returned by the client unchanged in the Authorization header of subsequent requests with URIs in the same protection space.
+        /// It is recommended that this string be base64 or data.
+        /// </summary>
+        private string Opaque { get; set; }
+
+        /// <summary>
+        /// A string indicating a pair of algorithms used to produce the digest and a checksum. If this is not present it is assumed to be "MD5".
+        /// If the algorithm is not understood, the challenge should be ignored (and a different one used, if there is more than one).
+        /// </summary>
+        private string Algorithm { get; set; }
+
+        /// <summary>
+        /// List of URIs, as specified in RFC XURI, that define the protection space.
+        /// If a URI is an abs_path, it is relative to the canonical root URL (see section 1.2 above) of the server being accessed.
+        /// An absoluteURI in this list may refer to a different server than the one being accessed.
+        /// The client can use this list to determine the set of URIs for which the same authentication information may be sent:
+        /// any URI that has a URI in this list as a prefix (after both have been made absolute) may be assumed to be in the same protection space.
+        /// If this directive is omitted or its value is empty, the client should assume that the protection space consists of all URIs on the responding server.
+        /// </summary>
+        public List<string> ProtectedUris { get; private set; }
+
+        /// <summary>
+        /// If present, it is a quoted string of one or more tokens indicating the "quality of protection" values supported by the server.
+        /// The value "auth" indicates authentication. The value "auth-int" indicates authentication with integrity protection.
+        /// </summary>
+        private string QualityOfProtections { get; set; }
+
+        /// <summary>
+        /// his MUST be specified if a qop directive is sent (see above), and MUST NOT be specified if the server did not send a qop directive in the WWW-Authenticate header field.
+        /// The nc-value is the hexadecimal count of the number of requests (including the current request) that the client has sent with the nonce value in this request.
+        /// </summary>
+        private int NonceCount { get; set; }
+
+        /// <summary>
+        /// Used to store the last HA1 that can be used in the next header generation when Algorithm is set to "md5-sess".
+        /// </summary>
+        private string HA1Sess { get; set; }
+
+        #endregion
+
+        internal Digest(Uri uri)
+        {
+            this.Uri = uri;
+            this.Algorithm = "md5";
+        }
+
+        /// <summary>
+        /// Parses a WWW-Authenticate header's value to retrive all information.
+        /// </summary>
+        public void ParseChallange(string header)
+        {
+            // Reset some values to its defaults.
+            this.Type = AuthenticationTypes.Unknown;
+            this.Stale = false;
+            this.Opaque = null;
+            this.HA1Sess = null;
+            this.NonceCount = 0;
+            this.QualityOfProtections = null;
+
+            if (this.ProtectedUris != null)
+                this.ProtectedUris.Clear();
+
+            // Parse the header
+            WWWAuthenticateHeaderParser qpl = new WWWAuthenticateHeaderParser(header);
+
+            // Then process
+            foreach (var qp in qpl.Values)
+                switch (qp.Key)
+                {
+                    case "basic": this.Type = AuthenticationTypes.Basic; break;
+                    case "digest": this.Type = AuthenticationTypes.Digest; break;
+                    case "realm": this.Realm = qp.Value; break;
+                    case "domain":
+                    {
+                        if (string.IsNullOrEmpty(qp.Value) || qp.Value.Length == 0)
+                            break;
+
+                        if (this.ProtectedUris == null)
+                            this.ProtectedUris = new List<string>();
+
+                        int idx = 0;
+                        string val = qp.Value.Read(ref idx, ' ');
+                        do
+                        {
+                            this.ProtectedUris.Add(val);
+                            val = qp.Value.Read(ref idx, ' ');
+                        } while (idx < qp.Value.Length);
+
+                        break;
+                    }
+                    case "nonce": this.Nonce = qp.Value; break;
+                    case "qop": this.QualityOfProtections = qp.Value; break;
+                    case "stale": this.Stale = bool.Parse(qp.Value); break;
+                    case "opaque": this.Opaque = qp.Value; break;
+                    case "algorithm": this.Algorithm = qp.Value; break;
+                }
+        }
+
+        /// <summary>
+        /// Generates a string that can be set to an Authorization header.
+        /// </summary>
+        public string GenerateResponseHeader(HTTPRequest request, Credentials credentials, bool isProxy = false)
+        {
+            try
+            {
+                switch (Type)
+                {
+                    case AuthenticationTypes.Basic:
+                        return string.Concat("Basic ", Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", credentials.UserName, credentials.Password))));
+
+                    case AuthenticationTypes.Digest:
+                    {
+                        NonceCount++;
+
+                        string HA1 = string.Empty;
+
+                        // The cnonce-value is an opaque quoted string value provided by the client and used by both client and server to avoid chosen plaintext attacks, to provide mutual
+                        //  authentication, and to provide some message integrity protection.
+                        string cnonce = new System.Random(request.GetHashCode()).Next(int.MinValue, int.MaxValue).ToString("X8");
+
+                        string ncvalue = NonceCount.ToString("X8");
+                        switch (Algorithm.TrimAndLower())
+                        {
+                            case "md5":
+                                HA1 = string.Format("{0}:{1}:{2}", credentials.UserName, Realm, credentials.Password).CalculateMD5Hash();
+                                break;
+
+                            case "md5-sess":
+                                if (string.IsNullOrEmpty(this.HA1Sess))
+                                    this.HA1Sess = string.Format("{0}:{1}:{2}:{3}:{4}", credentials.UserName, Realm, credentials.Password, Nonce, ncvalue).CalculateMD5Hash();
+                                HA1 = this.HA1Sess;
+                                break;
+
+                            default: //throw new NotSupportedException("Not supported hash algorithm found in Web Authentication: " + Algorithm);
+                                return string.Empty;
+                        }
+
+                        // A string of 32 hex digits, which proves that the user knows a password. Set according to the qop value.
+                        string response = string.Empty;
+
+                        // The server sent QoP-value can be a list of supported methodes(if sent at all - in this case it's null).
+                        // The rfc is not specify that this is a space or comma separeted list. So it can be "auth, auth-int" or "auth auth-int".
+                        // We will first check the longer value("auth-int") then the short one ("auth"). If one matches we will reset the qop to the exact value.
+                        string qop = this.QualityOfProtections != null ? this.QualityOfProtections.TrimAndLower() : null;
+
+                        // When we authenticate with a proxy and we want to tunnel the request, we have to use the CONNECT method instead of the 
+                        //  request's, as the proxy will not know about the request itself.
+                        string method = isProxy ? "CONNECT" : request.MethodType.ToString().ToUpper();
+
+                        // When we authenticate with a proxy and we want to tunnel the request, the uri must match what we are sending in the CONNECT request's
+                        //  Host header.
+                        string uri = isProxy ? request.CurrentUri.Host + ":" + request.CurrentUri.Port : request.CurrentUri.GetRequestPathAndQueryURL();
+
+                        if (qop == null)
+                        {
+                            string HA2 = string.Concat(request.MethodType.ToString().ToUpper(), ":", request.CurrentUri.GetRequestPathAndQueryURL()).CalculateMD5Hash();
+                            response = string.Format("{0}:{1}:{2}", HA1, Nonce, HA2).CalculateMD5Hash();
+                        }
+                        else if (qop.Contains("auth-int"))
+                        {
+                            qop = "auth-int";
+
+                            byte[] entityBody = request.GetEntityBody();
+
+                            if (entityBody == null)
+                                entityBody = VariableSizedBufferPool.NoData; //string.Empty.GetASCIIBytes();
+
+                            string HA2 = string.Format("{0}:{1}:{2}", method, uri, entityBody.CalculateMD5Hash()).CalculateMD5Hash();
+
+                            response = string.Format("{0}:{1}:{2}:{3}:{4}:{5}", HA1, Nonce, ncvalue, cnonce, qop, HA2).CalculateMD5Hash();
+                        }
+                        else if (qop.Contains("auth"))
+                        {
+                            qop = "auth";
+                            string HA2 = string.Concat(method, ":", uri).CalculateMD5Hash();
+
+                            response = string.Format("{0}:{1}:{2}:{3}:{4}:{5}", HA1, Nonce, ncvalue, cnonce, qop, HA2).CalculateMD5Hash();
+                        }
+                        else //throw new NotSupportedException("Unrecognized Quality of Protection value found: " + this.QualityOfProtections);
+                            return string.Empty;
+
+                        string result = string.Format("Digest username=\"{0}\", realm=\"{1}\", nonce=\"{2}\", uri=\"{3}\", cnonce=\"{4}\", response=\"{5}\"",
+                                                                credentials.UserName, Realm, Nonce, uri, cnonce, response);
+
+                        if (qop != null)
+                            result += String.Concat(", qop=\"", qop, "\", nc=", ncvalue);
+
+                        if (!string.IsNullOrEmpty(Opaque))
+                            result = String.Concat(result, ", opaque=\"", Opaque, "\"");
+
+                        return result;
+                    }// end of case "digest":
+
+                    default:
+                        break;
+                }
+            }
+            catch
+            {
+            }
+
+            return string.Empty;
+        }
+
+        public bool IsUriProtected(Uri uri)
+        {
+            // http://tools.ietf.org/html/rfc2617#section-3.2.1
+            // An absoluteURI in this list may refer to
+            // a different server than the one being accessed. The client can use
+            // this list to determine the set of URIs for which the same
+            // authentication information may be sent: any URI that has a URI in
+            // this list as a prefix (after both have been made absolute) may be
+            // assumed to be in the same protection space. If this directive is
+            // omitted or its value is empty, the client should assume that the
+            // protection space consists of all URIs on the responding server.
+
+            if (string.CompareOrdinal(uri.Host, this.Uri.Host) != 0)
+                return false;
+
+            string uriStr = uri.ToString();
+
+            if (ProtectedUris != null && ProtectedUris.Count > 0)
+                for (int i = 0; i < ProtectedUris.Count; ++i)
+                    if (uriStr.Contains(ProtectedUris[i]))
+                        return true;
+
+
+            return true;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/Digest.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 424d976119ee3fc438fe98095013859f
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/DigestStore.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Authentication
+{
+    /// <summary>
+    /// Stores and manages already received digest infos.
+    /// </summary>
+    public static class DigestStore
+    {
+        private static Dictionary<string, Digest> Digests = new Dictionary<string, Digest>();
+
+        private static object Locker = new object();
+
+        /// <summary>
+        /// Array of algorithms that the plugin supports. It's in the order of priority(first has the highest priority).
+        /// </summary>
+        private static string[] SupportedAlgorithms = new string[] { "digest", "basic" };
+
+        public static Digest Get(Uri uri)
+        {
+            lock (Locker)
+            {
+                Digest digest = null;
+                if (Digests.TryGetValue(uri.Host, out digest))
+                    if (!digest.IsUriProtected(uri))
+                        return null;
+                return digest;
+            }
+        }
+
+        /// <summary>
+        /// It will retrive or create a new Digest for the given Uri.
+        /// </summary>
+        /// <param name="uri"></param>
+        /// <returns></returns>
+        public static Digest GetOrCreate(Uri uri)
+        {
+            lock (Locker)
+            {
+                Digest digest = null;
+                if (!Digests.TryGetValue(uri.Host, out digest))
+                    Digests.Add(uri.Host, digest = new Digest(uri));
+                return digest;
+            }
+        }
+
+        public static void Remove(Uri uri)
+        {
+            lock(Locker)
+                Digests.Remove(uri.Host);
+        }
+
+        public static string FindBest(List<string> authHeaders)
+        {
+            if (authHeaders == null || authHeaders.Count == 0)
+                return string.Empty;
+
+            List<string> headers = new List<string>(authHeaders.Count);
+            for (int i = 0; i < authHeaders.Count; ++i)
+                headers.Add(authHeaders[i].ToLower());
+
+            for (int i = 0; i < SupportedAlgorithms.Length; ++i)
+            {
+                int idx = headers.FindIndex((header) => header.StartsWith(SupportedAlgorithms[i]));
+                if (idx != -1)
+                    return authHeaders[idx];
+            }
+
+            return string.Empty;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Authentication/DigestStore.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 0f808b023553ee2419249f92eb8ac31f
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fad485e45460c824a95a63ebeef18509
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheFileInfo.cs

@@ -0,0 +1,394 @@
+#if !BESTHTTP_DISABLE_CACHING
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace BestHTTP.Caching
+{
+    using BestHTTP.Extensions;
+    using BestHTTP.PlatformSupport.FileSystem;
+
+    /// <summary>
+    /// Holds all metadata that need for efficient caching, so we don't need to touch the disk to load headers.
+    /// </summary>
+    public class HTTPCacheFileInfo : IComparable<HTTPCacheFileInfo>
+    {
+        #region Properties
+
+        /// <summary>
+        /// The uri that this HTTPCacheFileInfo belongs to.
+        /// </summary>
+        internal Uri Uri { get; set; }
+
+        /// <summary>
+        /// The last access time to this cache entity. The date is in UTC.
+        /// </summary>
+        internal DateTime LastAccess { get; set; }
+
+        /// <summary>
+        /// The length of the cache entity's body.
+        /// </summary>
+        public int BodyLength { get; set; }
+
+        /// <summary>
+        /// ETag of the entity.
+        /// </summary>
+        private string ETag { get; set; }
+
+        /// <summary>
+        /// LastModified date of the entity.
+        /// </summary>
+        private string LastModified { get; set; }
+
+        /// <summary>
+        /// When the cache will expire.
+        /// </summary>
+        private DateTime Expires { get; set; }
+
+        /// <summary>
+        /// The age that came with the response
+        /// </summary>
+        private long Age { get; set; }
+
+        /// <summary>
+        /// Maximum how long the entry should served from the cache without revalidation.
+        /// </summary>
+        private long MaxAge { get; set; }
+
+        /// <summary>
+        /// The Date that came with the response.
+        /// </summary>
+        private DateTime Date { get; set; }
+
+        /// <summary>
+        /// Indicates whether the entity must be revalidated with the server or can be serverd directly from the cache without touching the server.
+        /// </summary>
+        private bool MustRevalidate { get; set; }
+
+        /// <summary>
+        /// The date and time when the HTTPResponse received.
+        /// </summary>
+        private DateTime Received { get; set; }
+
+        /// <summary>
+        /// Cached path.
+        /// </summary>
+        private string ConstructedPath { get; set; }
+
+        /// <summary>
+        /// This is the index of the entity. Filenames are generated from this value.
+        /// </summary>
+        internal UInt64 MappedNameIDX { get; set; }
+
+        #endregion
+
+        #region Constructors
+
+        internal HTTPCacheFileInfo(Uri uri)
+            :this(uri, DateTime.UtcNow, -1)
+        {
+        }
+
+        internal HTTPCacheFileInfo(Uri uri, DateTime lastAcces, int bodyLength)
+        {
+            this.Uri = uri;
+            this.LastAccess = lastAcces;
+            this.BodyLength = bodyLength;
+            this.MaxAge = -1;
+
+            this.MappedNameIDX = HTTPCacheService.GetNameIdx();
+        }
+
+        internal HTTPCacheFileInfo(Uri uri, System.IO.BinaryReader reader, int version)
+        {
+            this.Uri = uri;
+            this.LastAccess = DateTime.FromBinary(reader.ReadInt64());
+            this.BodyLength = reader.ReadInt32();
+
+            switch(version)
+            {
+                case 2:
+                    this.MappedNameIDX = reader.ReadUInt64();
+                    goto case 1;
+
+                case 1:
+                {
+                    this.ETag = reader.ReadString();
+                    this.LastModified = reader.ReadString();
+                    this.Expires = DateTime.FromBinary(reader.ReadInt64());
+                    this.Age = reader.ReadInt64();
+                    this.MaxAge = reader.ReadInt64();
+                    this.Date = DateTime.FromBinary(reader.ReadInt64());
+                    this.MustRevalidate = reader.ReadBoolean();
+                    this.Received = DateTime.FromBinary(reader.ReadInt64());
+                    break;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Helper Functions
+
+        internal void SaveTo(System.IO.BinaryWriter writer)
+        {
+            writer.Write(LastAccess.ToBinary());
+            writer.Write(BodyLength);
+            writer.Write(MappedNameIDX);
+            writer.Write(ETag);
+            writer.Write(LastModified);
+            writer.Write(Expires.ToBinary());
+            writer.Write(Age);
+            writer.Write(MaxAge);
+            writer.Write(Date.ToBinary());
+            writer.Write(MustRevalidate);
+            writer.Write(Received.ToBinary());
+        }
+
+        public string GetPath()
+        {
+            if (ConstructedPath != null)
+                return ConstructedPath;
+
+            return ConstructedPath = System.IO.Path.Combine(HTTPCacheService.CacheFolder, MappedNameIDX.ToString("X"));
+        }
+
+        public bool IsExists()
+        {
+            if (!HTTPCacheService.IsSupported)
+                return false;
+
+            return HTTPManager.IOService.FileExists(GetPath());
+        }
+
+        internal void Delete()
+        {
+            if (!HTTPCacheService.IsSupported)
+                return;
+
+            string path = GetPath();
+            try
+            {
+                HTTPManager.IOService.FileDelete(path);
+            }
+            catch
+            { }
+            finally
+            {
+                Reset();
+            }
+        }
+
+        private void Reset()
+        {
+            // MappedNameIDX will remain the same. When we re-save an entity, it will not reset the MappedNameIDX.
+            this.BodyLength = -1;
+            this.ETag = string.Empty;
+            this.Expires = DateTime.FromBinary(0);
+            this.LastModified = string.Empty;
+            this.Age = 0;
+            this.MaxAge = -1;
+            this.Date = DateTime.FromBinary(0);
+            this.MustRevalidate = false;
+            this.Received = DateTime.FromBinary(0);
+        }
+
+        #endregion
+
+        #region Caching
+
+        private void SetUpCachingValues(HTTPResponse response)
+        {
+            response.CacheFileInfo = this;
+
+            this.ETag = response.GetFirstHeaderValue("ETag").ToStrOrEmpty();
+            this.Expires = response.GetFirstHeaderValue("Expires").ToDateTime(DateTime.FromBinary(0));
+            this.LastModified = response.GetFirstHeaderValue("Last-Modified").ToStrOrEmpty();
+
+            this.Age = response.GetFirstHeaderValue("Age").ToInt64(0);
+
+            this.Date = response.GetFirstHeaderValue("Date").ToDateTime(DateTime.FromBinary(0));
+
+            string cacheControl = response.GetFirstHeaderValue("cache-control");
+            if (!string.IsNullOrEmpty(cacheControl))
+            {
+                string[] kvp = cacheControl.FindOption("max-age");
+                if (kvp != null)
+                {
+                    // Some cache proxies will return float values
+                    double maxAge;
+                    if (double.TryParse(kvp[1], out maxAge))
+                        this.MaxAge = (int)maxAge;
+                }
+
+                this.MustRevalidate = cacheControl.ToLower().Contains("must-revalidate");
+            }
+
+            this.Received = DateTime.UtcNow;
+        }
+
+        internal bool WillExpireInTheFuture()
+        {
+            if (!IsExists())
+                return false;
+
+            if (MustRevalidate)
+                return false;
+
+            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.2.4 :
+            //  The max-age directive takes priority over Expires
+            if (MaxAge != -1)
+            {
+                // Age calculation:
+                // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.2.3
+
+                long apparent_age = Math.Max(0, (long)(Received - Date).TotalSeconds);
+                long corrected_received_age = Math.Max(apparent_age, Age);
+                long resident_time = (long)(DateTime.UtcNow - Date).TotalSeconds;
+                long current_age = corrected_received_age + resident_time;
+
+                return current_age < MaxAge;
+            }
+
+            return Expires > DateTime.UtcNow;
+        }
+
+        internal void SetUpRevalidationHeaders(HTTPRequest request)
+        {
+            if (!IsExists())
+                return;
+
+            // -If an entity tag has been provided by the origin server, MUST use that entity tag in any cache-conditional request (using If-Match or If-None-Match).
+            // -If only a Last-Modified value has been provided by the origin server, SHOULD use that value in non-subrange cache-conditional requests (using If-Modified-Since).
+            // -If both an entity tag and a Last-Modified value have been provided by the origin server, SHOULD use both validators in cache-conditional requests. This allows both HTTP/1.0 and HTTP/1.1 caches to respond appropriately.
+
+            if (!string.IsNullOrEmpty(ETag))
+                request.SetHeader("If-None-Match", ETag);
+
+            if (!string.IsNullOrEmpty(LastModified))
+                request.SetHeader("If-Modified-Since", LastModified);
+        }
+
+        public System.IO.Stream GetBodyStream(out int length)
+        {
+            if (!IsExists())
+            {
+                length = 0;
+                return null;
+            }
+
+            length = BodyLength;
+
+            LastAccess = DateTime.UtcNow;
+
+            //FileStream stream = new FileStream(GetPath(), FileMode.Open, FileAccess.Read, FileShare.Read);
+            Stream stream = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Open);
+            stream.Seek(-length, System.IO.SeekOrigin.End);
+
+            return stream;
+        }
+
+        internal HTTPResponse ReadResponseTo(HTTPRequest request)
+        {
+            if (!IsExists())
+                return null;
+
+            LastAccess = DateTime.UtcNow;
+
+            using (Stream stream = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Open)/*new FileStream(GetPath(), FileMode.Open, FileAccess.Read, FileShare.Read)*/)
+            {
+                var response = new HTTPResponse(request, stream, request.UseStreaming, true);
+                response.CacheFileInfo = this;
+                response.Receive(BodyLength);
+                return response;
+            }
+        }
+
+        internal void Store(HTTPResponse response)
+        {
+            if (!HTTPCacheService.IsSupported)
+                return;
+
+            string path = GetPath();
+
+            // Path name too long, we don't want to get exceptions
+            if (path.Length > HTTPManager.MaxPathLength)
+                return;
+
+            if (HTTPManager.IOService.FileExists(path))
+                Delete();
+
+            using (Stream writer = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Create) /*new FileStream(path, FileMode.Create)*/)
+            {
+                writer.WriteLine("HTTP/1.1 {0} {1}", response.StatusCode, response.Message);
+                foreach (var kvp in response.Headers)
+                {
+                    for (int i = 0; i < kvp.Value.Count; ++i)
+                        writer.WriteLine("{0}: {1}", kvp.Key, kvp.Value[i]);
+                }
+
+                writer.WriteLine();
+
+                writer.Write(response.Data, 0, response.Data.Length);
+            }
+
+            BodyLength = response.Data.Length;
+            LastAccess = DateTime.UtcNow;
+
+            SetUpCachingValues(response);
+        }
+
+        internal System.IO.Stream GetSaveStream(HTTPResponse response)
+        {
+            if (!HTTPCacheService.IsSupported)
+                return null;
+
+            LastAccess = DateTime.UtcNow;
+
+            string path = GetPath();
+
+            if (HTTPManager.IOService.FileExists(path))
+                Delete();
+
+            // Path name too long, we don't want to get exceptions
+            if (path.Length > HTTPManager.MaxPathLength)
+                return null;
+
+            // First write out the headers
+            using (Stream writer = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Create) /*new FileStream(path, FileMode.Create)*/)
+            {
+                writer.WriteLine("HTTP/1.1 {0} {1}", response.StatusCode, response.Message);
+                foreach (var kvp in response.Headers)
+                {
+                    for (int i = 0; i < kvp.Value.Count; ++i)
+                        writer.WriteLine("{0}: {1}", kvp.Key, kvp.Value[i]);
+                }
+
+                writer.WriteLine();
+            }
+
+            // If caching is enabled and the response is from cache, and no content-length header set, then we set one to the response.
+            if (response.IsFromCache && !response.Headers.ContainsKey("content-length"))
+                response.Headers.Add("content-length", new List<string> { BodyLength.ToString() });
+
+            SetUpCachingValues(response);
+
+            // then create the stream with Append FileMode
+            return HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Append); //new FileStream(GetPath(), FileMode.Append);
+        }
+
+        #endregion
+
+        #region IComparable<HTTPCacheFileInfo>
+
+        public int CompareTo(HTTPCacheFileInfo other)
+        {
+            return this.LastAccess.CompareTo(other.LastAccess);
+        }
+
+        #endregion
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheFileInfo.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 1f50da5c22225384fbe271e0453fe545
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheFileLock.cs

@@ -0,0 +1,44 @@
+#if !BESTHTTP_DISABLE_CACHING
+
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Caching
+{
+    sealed class HTTPCacheFileLock
+    {
+        private static Dictionary<Uri, object> FileLocks = new Dictionary<Uri, object>();
+        private static object SyncRoot = new object();
+
+        internal static object Acquire(Uri uri)
+        {
+            lock (SyncRoot)
+            {
+                object fileLock;
+                if (!FileLocks.TryGetValue(uri, out fileLock))
+                    FileLocks.Add(uri, fileLock = new object());
+
+                return fileLock;
+            }
+        }
+
+        internal static void Remove(Uri uri)
+        {
+            lock (SyncRoot)
+            {
+                if (FileLocks.ContainsKey(uri))
+                    FileLocks.Remove(uri);
+            }
+        }
+
+        internal static void Clear()
+        {
+            lock (SyncRoot)
+            {
+                FileLocks.Clear();
+            }
+        }
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheFileLock.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7b141dab023cd9d438e0585b93cf2826
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheMaintananceParams.cs

@@ -0,0 +1,27 @@
+#if !BESTHTTP_DISABLE_CACHING
+
+using System;
+
+namespace BestHTTP.Caching
+{
+    public sealed class HTTPCacheMaintananceParams
+    {
+        /// <summary>
+        /// Delete cache entries that accessed older then this value. If TimeSpan.FromSeconds(0) is used then all cache entries will be deleted. With TimeSpan.FromDays(2) entries that older then two days will be deleted.
+        /// </summary>
+        public TimeSpan DeleteOlder { get; private set; }
+
+        /// <summary>
+        /// If the cache is larger then the MaxCacheSize after the first maintanance step, then the maintanance job will forcedelete cache entries starting with the oldest last accessed one.
+        /// </summary>
+        public ulong MaxCacheSize { get; private set; }
+
+        public HTTPCacheMaintananceParams(TimeSpan deleteOlder, ulong maxCacheSize)
+        {
+            this.DeleteOlder = deleteOlder;
+            this.MaxCacheSize = maxCacheSize;
+        }
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheMaintananceParams.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3ce5552e539e38647a8f37ab36951bf7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheService.cs

@@ -0,0 +1,716 @@
+#if !BESTHTTP_DISABLE_CACHING
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+//
+// Version 1: Initial release
+// Version 2: Filenames are generated from an index.
+//
+
+namespace BestHTTP.Caching
+{
+    using BestHTTP.Extensions;
+    using BestHTTP.PlatformSupport.FileSystem;
+
+    public sealed class UriComparer : IEqualityComparer<Uri>
+    {
+        public bool Equals(Uri x, Uri y)
+        {
+            return Uri.Compare(x, y, UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped, StringComparison.Ordinal) == 0;
+        }
+
+        public int GetHashCode(Uri uri)
+        {
+            return uri.ToString().GetHashCode();
+        }
+    }
+
+
+    public static class HTTPCacheService
+    {
+        #region Properties & Fields
+
+        /// <summary>
+        /// Library file-format versioning support
+        /// </summary>
+        private const int LibraryVersion = 2;
+
+        public static bool IsSupported
+        {
+            get
+            {
+                if (IsSupportCheckDone)
+                    return isSupported;
+
+                try
+                {
+                    // If DirectoryExists throws an exception we will set IsSupprted to false
+
+                    HTTPManager.IOService.DirectoryExists(HTTPManager.GetRootCacheFolder());
+                    isSupported = true;
+                }
+                catch
+                {
+                    isSupported = false;
+
+                    HTTPManager.Logger.Warning("HTTPCacheService", "Cache Service Disabled!");
+                }
+                finally
+                {
+                    IsSupportCheckDone = true;
+                }
+
+                return isSupported;
+            }
+        }
+        private static bool isSupported;
+        private static bool IsSupportCheckDone;
+
+        private static Dictionary<Uri, HTTPCacheFileInfo> library;
+        private static Dictionary<Uri, HTTPCacheFileInfo> Library { get { LoadLibrary(); return library; } }
+
+        private static Dictionary<UInt64, HTTPCacheFileInfo> UsedIndexes = new Dictionary<ulong, HTTPCacheFileInfo>();
+
+        internal static string CacheFolder { get; private set; }
+        private static string LibraryPath { get; set; }
+
+        private static bool InClearThread;
+        private static bool InMaintainenceThread;
+
+        /// <summary>
+        /// Stores the index of the next stored entity. The entity's file name is generated from this index.
+        /// </summary>
+        private static UInt64 NextNameIDX;
+
+        #endregion
+
+        static HTTPCacheService()
+        {
+            NextNameIDX = 0x0001;
+        }
+
+        #region Common Functions
+
+        internal static void CheckSetup()
+        {
+            if (!HTTPCacheService.IsSupported)
+                return;
+
+            try
+            {
+                SetupCacheFolder();
+                LoadLibrary();
+            }
+            catch
+            { }
+        }
+
+        internal static void SetupCacheFolder()
+        {
+            if (!HTTPCacheService.IsSupported)
+                return;
+
+            try
+            {
+                if (string.IsNullOrEmpty(CacheFolder) || string.IsNullOrEmpty(LibraryPath))
+                {
+                    CacheFolder = System.IO.Path.Combine(HTTPManager.GetRootCacheFolder(), "HTTPCache");
+                    if (!HTTPManager.IOService.DirectoryExists(CacheFolder))
+                        HTTPManager.IOService.DirectoryCreate(CacheFolder);
+
+                    LibraryPath = System.IO.Path.Combine(HTTPManager.GetRootCacheFolder(), "Library");
+                }
+            }
+            catch
+            {
+                isSupported = false;
+
+                HTTPManager.Logger.Warning("HTTPCacheService", "Cache Service Disabled!");
+            }
+        }
+
+        internal static UInt64 GetNameIdx()
+        {
+            lock(Library)
+            {
+                UInt64 result = NextNameIDX;
+
+                do
+                {
+                    NextNameIDX = ++NextNameIDX % UInt64.MaxValue;
+                } while (UsedIndexes.ContainsKey(NextNameIDX));
+
+                return result;
+            }
+        }
+
+        internal static bool HasEntity(Uri uri)
+        {
+            if (!IsSupported)
+                return false;
+
+            lock (Library)
+                return Library.ContainsKey(uri);
+        }
+
+        public static bool DeleteEntity(Uri uri, bool removeFromLibrary = true)
+        {
+            if (!IsSupported)
+                return false;
+
+            object uriLocker = HTTPCacheFileLock.Acquire(uri);
+
+            // Just use lock now: http://forum.unity3d.com/threads/4-6-ios-64-bit-beta.290551/page-6#post-1937033
+
+            // To avoid a dead-lock we try acquire the lock on this uri only for a little time.
+            // If we can't acquire it, its better to just return without risking a deadlock.
+            //if (Monitor.TryEnter(uriLocker, TimeSpan.FromSeconds(0.5f)))
+            lock(uriLocker)
+            {
+                try
+                {
+                    lock (Library)
+                    {
+                        HTTPCacheFileInfo info;
+                        bool inStats = Library.TryGetValue(uri, out info);
+                        if (inStats)
+                            info.Delete();
+
+                        if (inStats && removeFromLibrary)
+                        {
+                            Library.Remove(uri);
+                            UsedIndexes.Remove(info.MappedNameIDX);
+                        }
+
+                        return true;
+                    }
+                }
+                finally
+                {
+                    //Monitor.Exit(uriLocker);
+                }
+            }
+
+            //return false;
+        }
+
+        internal static bool IsCachedEntityExpiresInTheFuture(HTTPRequest request)
+        {
+            if (!IsSupported)
+                return false;
+
+            HTTPCacheFileInfo info;
+            lock (Library)
+                if (Library.TryGetValue(request.CurrentUri, out info))
+                    return info.WillExpireInTheFuture();
+
+            return false;
+        }
+
+        /// <summary>
+        /// Utility function to set the cache control headers according to the spec.: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.4
+        /// </summary>
+        /// <param name="request"></param>
+        internal static void SetHeaders(HTTPRequest request)
+        {
+            if (!IsSupported)
+                return;
+
+            request.RemoveHeader("If-None-Match");
+            request.RemoveHeader("If-Modified-Since");
+
+            HTTPCacheFileInfo info;
+            lock (Library)
+                if (Library.TryGetValue(request.CurrentUri, out info))
+                    info.SetUpRevalidationHeaders(request);
+        }
+
+        #endregion
+
+        #region Get Functions
+
+        internal static HTTPCacheFileInfo GetEntity(Uri uri)
+        {
+            if (!IsSupported)
+                return null;
+            HTTPCacheFileInfo info = null;
+            lock (Library)
+                Library.TryGetValue(uri, out info);
+            return info;
+        }
+
+        internal static HTTPResponse GetFullResponse(HTTPRequest request)
+        {
+            if (!IsSupported)
+                return null;
+
+            HTTPCacheFileInfo info;
+            lock (Library)
+                if (Library.TryGetValue(request.CurrentUri, out info))
+                    return info.ReadResponseTo(request);
+
+            return null;
+        }
+
+        #endregion
+
+        #region Storing
+
+        /// <summary>
+        /// Checks if the given response can be cached. http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.4
+        /// </summary>
+        /// <returns>Returns true if cacheable, false otherwise.</returns>
+        internal static bool IsCacheble(Uri uri, HTTPMethods method, HTTPResponse response)
+        {
+            if (!IsSupported)
+                return false;
+
+            if (method != HTTPMethods.Get)
+                return false;
+
+            if (response == null)
+                return false;
+
+            // https://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.12 - Cache Replacement
+            // It MAY insert it into cache storage and MAY, if it meets all other requirements, use it to respond to any future requests that would previously have caused the old response to be returned.
+            //if (response.StatusCode == 304)
+            //    return false;
+
+            if (response.StatusCode < 200 || response.StatusCode >= 400)
+                return false;
+
+            //http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.2
+            var cacheControls = response.GetHeaderValues("cache-control");
+            if (cacheControls != null)
+            {
+                if (cacheControls.Exists(headerValue => {
+                                                            string value = headerValue.ToLower();
+                                                            return value.Contains("no-store") || value.Contains("no-cache");
+                                                        }))
+                    return false;
+            }
+
+            var pragmas = response.GetHeaderValues("pragma");
+            if (pragmas != null)
+            {
+                if (pragmas.Exists(headerValue => {
+                                                      string value = headerValue.ToLower();
+                                                      return value.Contains("no-store") || value.Contains("no-cache");
+                                                  }))
+                    return false;
+            }
+
+            // Responses with byte ranges not supported yet.
+            var byteRanges = response.GetHeaderValues("content-range");
+            if (byteRanges != null)
+                return false;
+
+            return true;
+        }
+
+        internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response)
+        {
+            if (response == null || response.Data == null || response.Data.Length == 0)
+                return null;
+
+            if (!IsSupported)
+                return null;
+
+            HTTPCacheFileInfo info = null;
+
+            lock (Library)
+            {
+                if (!Library.TryGetValue(uri, out info))
+                {
+                    Library.Add(uri, info = new HTTPCacheFileInfo(uri));
+                    UsedIndexes.Add(info.MappedNameIDX, info);
+                }
+
+                try
+                {
+                    info.Store(response);
+                    if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                        HTTPManager.Logger.Verbose("HTTPCacheService", string.Format("{0} - Saved to cache", uri.ToString()));
+                }
+                catch
+                {
+                    // If something happens while we write out the response, than we will delete it because it might be in an invalid state.
+                    DeleteEntity(uri);
+
+                    throw;
+                }
+            }
+
+            return info;
+        }
+
+        internal static System.IO.Stream PrepareStreamed(Uri uri, HTTPResponse response)
+        {
+            if (!IsSupported)
+                return null;
+
+            HTTPCacheFileInfo info;
+
+            lock (Library)
+            {
+                if (!Library.TryGetValue(uri, out info))
+                {
+                    Library.Add(uri, info = new HTTPCacheFileInfo(uri));
+                    UsedIndexes.Add(info.MappedNameIDX, info);
+                }
+
+                try
+                {
+                    return info.GetSaveStream(response);
+                }
+                catch
+                {
+                    // If something happens while we write out the response, than we will delete it because it might be in an invalid state.
+                    DeleteEntity(uri);
+
+                    throw;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Public Maintenance Functions
+
+        /// <summary>
+        /// Deletes all cache entity. Non blocking.
+        /// <remarks>Call it only if there no requests currently processed, because cache entries can be deleted while a server sends back a 304 result, so there will be no data to read from the cache!</remarks>
+        /// </summary>
+        public static void BeginClear()
+        {
+            if (!IsSupported)
+                return;
+
+            if (InClearThread)
+                return;
+            InClearThread = true;
+
+            SetupCacheFolder();
+
+    #if !NETFX_CORE
+            ThreadPool.QueueUserWorkItem(new WaitCallback((param) => ClearImpl(param)));
+            //new Thread(ClearImpl).Start();
+#else
+#pragma warning disable 4014
+            Windows.System.Threading.ThreadPool.RunAsync(ClearImpl);
+#pragma warning restore 4014
+#endif
+        }
+
+        private static void ClearImpl(object param)
+        {
+            if (!IsSupported)
+                return;
+
+            try
+            {
+                // GetFiles will return a string array that contains the files in the folder with the full path
+                string[] cacheEntries = HTTPManager.IOService.GetFiles(CacheFolder);
+
+                for (int i = 0; i < cacheEntries.Length; ++i)
+                {
+                    // We need a try-catch block because between the Directory.GetFiles call and the File.Delete calls a maintenance job, or other file operations can delete any file from the cache folder.
+                    // So while there might be some problem with any file, we don't want to abort the whole for loop
+                    try
+                    {
+                        HTTPManager.IOService.FileDelete(cacheEntries[i]);
+                    }
+                    catch
+                    { }
+                }
+            }
+            finally
+            {
+                UsedIndexes.Clear();
+                library.Clear();
+                NextNameIDX = 0x0001;
+
+                SaveLibrary();
+                InClearThread = false;
+            }
+        }
+
+        /// <summary>
+        /// Deletes all expired cache entity.
+        /// <remarks>Call it only if there no requests currently processed, because cache entries can be deleted while a server sends back a 304 result, so there will be no data to read from the cache!</remarks>
+        /// </summary>
+        public static void BeginMaintainence(HTTPCacheMaintananceParams maintananceParam)
+        {
+            if (maintananceParam == null)
+                throw new ArgumentNullException("maintananceParams == null");
+
+            if (!HTTPCacheService.IsSupported)
+                return;
+
+            if (InMaintainenceThread)
+                return;
+
+            InMaintainenceThread = true;
+
+            SetupCacheFolder();
+
+#if !NETFX_CORE
+            ThreadPool.QueueUserWorkItem(new WaitCallback((param) =>
+            //new Thread((param) =>
+#else
+#pragma warning disable 4014
+            Windows.System.Threading.ThreadPool.RunAsync((param) =>
+#pragma warning restore 4014
+#endif
+            {
+                try
+                    {
+                        lock (Library)
+                        {
+                            // Delete cache entries older than the given time.
+                            DateTime deleteOlderAccessed = DateTime.UtcNow - maintananceParam.DeleteOlder;
+                            List<HTTPCacheFileInfo> removedEntities = new List<HTTPCacheFileInfo>();
+                            foreach (var kvp in Library)
+                                if (kvp.Value.LastAccess < deleteOlderAccessed)
+                                {
+                                    if (DeleteEntity(kvp.Key, false))
+                                        removedEntities.Add(kvp.Value);
+                                }
+
+                            for (int i = 0; i < removedEntities.Count; ++i)
+                            {
+                                Library.Remove(removedEntities[i].Uri);
+                                UsedIndexes.Remove(removedEntities[i].MappedNameIDX);
+                            }
+                            removedEntities.Clear();
+
+                            ulong cacheSize = GetCacheSize();
+
+                            // This step will delete all entries starting with the oldest LastAccess property while the cache size greater then the MaxCacheSize in the given param.
+                            if (cacheSize > maintananceParam.MaxCacheSize)
+                            {
+                                List<HTTPCacheFileInfo> fileInfos = new List<HTTPCacheFileInfo>(library.Count);
+
+                                foreach(var kvp in library)
+                                    fileInfos.Add(kvp.Value);
+
+                                fileInfos.Sort();
+
+                                int idx = 0;
+                                while (cacheSize >= maintananceParam.MaxCacheSize && idx < fileInfos.Count)
+                                {
+                                    try
+                                    {
+                                        var fi = fileInfos[idx];
+                                        ulong length = (ulong)fi.BodyLength;
+
+                                        DeleteEntity(fi.Uri);
+
+                                        cacheSize -= length;
+                                    }
+                                    catch
+                                    {}
+                                    finally
+                                    {
+                                        ++idx;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        SaveLibrary();
+                        InMaintainenceThread = false;
+                    }
+                }
+    #if !NETFX_CORE
+                ));
+    #else
+                );
+    #endif
+        }
+
+        public static int GetCacheEntityCount()
+        {
+            if (!HTTPCacheService.IsSupported)
+                return 0;
+
+            CheckSetup();
+
+            lock(Library)
+                return Library.Count;
+        }
+
+        public static ulong GetCacheSize()
+        {
+            ulong size = 0;
+
+            if (!IsSupported)
+                return size;
+
+            CheckSetup();
+
+            lock (Library)
+                foreach (var kvp in Library)
+                    if (kvp.Value.BodyLength > 0)
+                        size += (ulong)kvp.Value.BodyLength;
+            return size;
+        }
+
+        #endregion
+
+        #region Cache Library Management
+
+        private static void LoadLibrary()
+        {
+            // Already loaded?
+            if (library != null)
+                return;
+
+            if (!IsSupported)
+                return;
+
+            library = new Dictionary<Uri, HTTPCacheFileInfo>(new UriComparer());
+
+            if (!HTTPManager.IOService.FileExists(LibraryPath))
+            {
+                DeleteUnusedFiles();
+                return;
+            }
+
+            try
+            {
+                int version;
+
+                lock (library)
+                {
+                    using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Open))
+                    using (var br = new System.IO.BinaryReader(fs))
+                    {
+                        version = br.ReadInt32();
+
+                        if (version > 1)
+                            NextNameIDX = br.ReadUInt64();
+
+                        int statCount = br.ReadInt32();
+
+                        for (int i = 0; i < statCount; ++i)
+                        {
+                            Uri uri = new Uri(br.ReadString());
+
+                            var entity = new HTTPCacheFileInfo(uri, br, version);
+                            if (entity.IsExists())
+                            {
+                                library.Add(uri, entity);
+
+                                if (version > 1)
+                                    UsedIndexes.Add(entity.MappedNameIDX, entity);
+                            }
+                        }
+                    }
+                }
+
+                if (version == 1)
+                    BeginClear();
+                else
+                    DeleteUnusedFiles();
+            }
+            catch
+            {}
+        }
+
+        internal static void SaveLibrary()
+        {
+            if (library == null)
+                return;
+
+            if (!IsSupported)
+                return;
+
+            try
+            {
+                lock (Library)
+                {
+                    using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Create))
+                    using (var bw = new System.IO.BinaryWriter(fs))
+                    {
+                        bw.Write(LibraryVersion);
+                        bw.Write(NextNameIDX);
+
+                        bw.Write(Library.Count);
+                        foreach (var kvp in Library)
+                        {
+                            bw.Write(kvp.Key.ToString());
+
+                            kvp.Value.SaveTo(bw);
+                        }
+                    }
+                }
+            }
+            catch
+            {}
+        }
+
+
+        internal static void SetBodyLength(Uri uri, int bodyLength)
+        {
+            if (!IsSupported)
+                return;
+
+            lock (Library)
+            {
+                HTTPCacheFileInfo fileInfo;
+                if (Library.TryGetValue(uri, out fileInfo))
+                    fileInfo.BodyLength = bodyLength;
+                else
+                {
+                    Library.Add(uri, fileInfo = new HTTPCacheFileInfo(uri, DateTime.UtcNow, bodyLength));
+                    UsedIndexes.Add(fileInfo.MappedNameIDX, fileInfo);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Deletes all files from the cache folder that isn't in the Library.
+        /// </summary>
+        private static void DeleteUnusedFiles()
+        {
+            if (!IsSupported)
+                return;
+
+            CheckSetup();
+
+            // GetFiles will return a string array that contains the files in the folder with the full path
+            string[] cacheEntries = HTTPManager.IOService.GetFiles(CacheFolder);
+
+            for (int i = 0; i < cacheEntries.Length; ++i)
+            {
+                // We need a try-catch block because between the Directory.GetFiles call and the File.Delete calls a maintenance job, or other file operations can delete any file from the cache folder.
+                // So while there might be some problem with any file, we don't want to abort the whole for loop
+                try
+                {
+                    string filename = System.IO.Path.GetFileName(cacheEntries[i]);
+                    UInt64 idx = 0;
+                    bool deleteFile = false;
+                    if (UInt64.TryParse(filename, System.Globalization.NumberStyles.AllowHexSpecifier, null, out idx))
+                        lock (Library)
+                            deleteFile = !UsedIndexes.ContainsKey(idx);
+                    else
+                        deleteFile = true;
+
+                    if (deleteFile)
+                        HTTPManager.IOService.FileDelete(cacheEntries[i]);
+                }
+                catch
+                {}
+            }
+        }
+
+        #endregion
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Caching/HTTPCacheService.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: d29e8551599393f4193bc4daa6968607
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b9e675acca8d22468dbbe1fd43ecac1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/ConnectionBase.cs

@@ -0,0 +1,226 @@
+using System;
+using System.Threading;
+
+#if NETFX_CORE
+    using System.Threading.Tasks;
+
+    //Disable CD4014: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.
+    #pragma warning disable 4014
+
+    //Disable warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+    #pragma warning disable 1998
+#endif
+
+namespace BestHTTP
+{
+    internal delegate void HTTPConnectionRecycledDelegate(ConnectionBase conn);
+
+    internal abstract class ConnectionBase : IDisposable
+    {
+        #region Public Properties
+
+        /// <summary>
+        /// The address of the server that this connection is bound to.
+        /// </summary>
+        public string ServerAddress { get; protected set; }
+
+        /// <summary>
+        /// The state of this connection.
+        /// </summary>
+        public HTTPConnectionStates State { get; protected set; }
+
+        /// <summary>
+        /// It's true if this connection is available to process a HTTPRequest.
+        /// </summary>
+        public bool IsFree { get { return State == HTTPConnectionStates.Initial || State == HTTPConnectionStates.Free; } }
+
+        /// <summary>
+        /// Returns true if it's an active connection.
+        /// </summary>
+        public bool IsActive { get { return State > HTTPConnectionStates.Initial && State < HTTPConnectionStates.Free; } }
+
+        /// <summary>
+        /// If the State is HTTPConnectionStates.Processing, then it holds a HTTPRequest instance. Otherwise it's null.
+        /// </summary>
+        public HTTPRequest CurrentRequest { get; protected set; }
+
+        public virtual bool IsRemovable { get { return IsFree && (DateTime.UtcNow - LastProcessTime) > HTTPManager.MaxConnectionIdleTime; } }
+
+        /// <summary>
+        /// When we start to process the current request. It's set after the connection is established.
+        /// </summary>
+        public DateTime StartTime { get; protected set; }
+
+        /// <summary>
+        /// When this connection timed out.
+        /// </summary>
+        public DateTime TimedOutStart { get; protected set; }
+
+#if !BESTHTTP_DISABLE_PROXY
+        public bool HasProxy { get { return this.CurrentRequest != null && this.CurrentRequest.Proxy != null; } }
+#endif
+
+        public Uri LastProcessedUri { get; protected set; }
+
+        #endregion
+
+        #region Protected Fields
+
+        protected DateTime LastProcessTime;
+        protected HTTPConnectionRecycledDelegate OnConnectionRecycled = null;
+
+        #endregion
+
+        #region Privates
+
+        private bool IsThreaded;
+
+        #endregion
+
+        public ConnectionBase(string serverAddress)
+            :this(serverAddress, true)
+        {}
+
+        public ConnectionBase(string serverAddress, bool threaded)
+        {
+            this.ServerAddress = serverAddress;
+            this.State = HTTPConnectionStates.Initial;
+            this.LastProcessTime = DateTime.UtcNow;
+            this.IsThreaded = threaded;
+        }
+
+        internal abstract void Abort(HTTPConnectionStates hTTPConnectionStates);
+
+        internal void Process(HTTPRequest request)
+        {
+            if (State == HTTPConnectionStates.Processing)
+                throw new Exception("Connection already processing a request!");
+
+            StartTime = DateTime.MaxValue;
+            State = HTTPConnectionStates.Processing;
+
+            CurrentRequest = request;
+
+            if (IsThreaded)
+            {
+#if NETFX_CORE
+#pragma warning disable 4014
+                Windows.System.Threading.ThreadPool.RunAsync(ThreadFunc);
+#pragma warning restore 4014
+#else
+                ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadFunc));
+                //new Thread(ThreadFunc)
+                //    .Start();
+#endif
+            }
+            else
+                ThreadFunc(null);
+        }
+
+        protected virtual
+#if NETFX_CORE
+            async
+#endif
+            void ThreadFunc(object param)
+        {
+
+        }
+
+        internal void HandleProgressCallback()
+        {
+            if (CurrentRequest.OnProgress != null && CurrentRequest.DownloadProgressChanged)
+            {
+                try
+                {
+                    CurrentRequest.OnProgress(CurrentRequest, CurrentRequest.Downloaded, CurrentRequest.DownloadLength);
+                }
+                catch (Exception ex)
+                {
+                    HTTPManager.Logger.Exception("ConnectionBase", "HandleProgressCallback - OnProgress", ex);
+                }
+
+                CurrentRequest.DownloadProgressChanged = false;
+            }
+
+            if (CurrentRequest.OnUploadProgress != null && CurrentRequest.UploadProgressChanged)
+            {
+                try
+                {
+                    CurrentRequest.OnUploadProgress(CurrentRequest, CurrentRequest.Uploaded, CurrentRequest.UploadLength);
+                }
+                catch (Exception ex)
+                {
+                    HTTPManager.Logger.Exception("ConnectionBase", "HandleProgressCallback - OnUploadProgress", ex);
+                }
+                CurrentRequest.UploadProgressChanged = false;
+            }
+        }
+
+        internal void HandleCallback()
+        {
+            try
+            {
+                HandleProgressCallback();
+
+                if (State == HTTPConnectionStates.Upgraded)
+                {
+                    if (CurrentRequest != null && CurrentRequest.Response != null && CurrentRequest.Response.IsUpgraded)
+                        CurrentRequest.UpgradeCallback();
+                    State = HTTPConnectionStates.WaitForProtocolShutdown;
+                }
+                else
+                    CurrentRequest.CallCallback();
+            }
+            catch (Exception ex)
+            {
+                HTTPManager.Logger.Exception("ConnectionBase", "HandleCallback", ex);
+            }
+        }
+
+        internal void Recycle(HTTPConnectionRecycledDelegate onConnectionRecycled)
+        {
+            OnConnectionRecycled = onConnectionRecycled;
+            if (!(State > HTTPConnectionStates.Initial && State < HTTPConnectionStates.WaitForProtocolShutdown) || State == HTTPConnectionStates.Redirected)
+                RecycleNow();
+        }
+
+        protected void RecycleNow()
+        {
+            if (State == HTTPConnectionStates.TimedOut ||
+                State == HTTPConnectionStates.Closed)
+                LastProcessTime = DateTime.MinValue;
+
+            State = HTTPConnectionStates.Free;
+            if (CurrentRequest != null)
+                CurrentRequest.Dispose();
+            CurrentRequest = null;
+
+            if (OnConnectionRecycled != null)
+            {
+                OnConnectionRecycled(this);
+                OnConnectionRecycled = null;
+            }
+        }
+
+        #region Dispose Pattern
+
+        protected bool IsDisposed { get; private set; }
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            IsDisposed = true;
+        }
+
+        ~ConnectionBase()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/ConnectionBase.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f59e4337e77f0be4d8f6649beaca8362
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/FileConnection.cs

@@ -0,0 +1,300 @@
+using System;
+using System.Collections.Generic;
+
+using BestHTTP.Extensions;
+using BestHTTP.PlatformSupport.FileSystem;
+
+namespace BestHTTP
+{
+    public sealed class StreamList : System.IO.Stream
+    {
+        private System.IO.Stream[] Streams;
+        private int CurrentIdx;
+
+        public StreamList(params System.IO.Stream[] streams)
+        {
+            this.Streams = streams;
+            this.CurrentIdx = 0;
+        }
+
+        public override bool CanRead
+        {
+            get {
+                if (CurrentIdx >= Streams.Length)
+                    return false;
+                return Streams[CurrentIdx].CanRead;
+            }
+        }
+
+        public override bool CanSeek { get { return false; } }
+
+        public override bool CanWrite
+        {
+            get {
+                if (CurrentIdx >= Streams.Length)
+                    return false;
+                return Streams[CurrentIdx].CanWrite;
+            }
+        }
+
+        public override void Flush()
+        {
+            if (CurrentIdx >= Streams.Length)
+                return;
+
+            // We have to call the flush to all previous streams, as we may advanced the CurrentIdx
+            for (int i = 0; i <= CurrentIdx; ++i)
+                Streams[i].Flush();
+        }
+
+        public override long Length
+        {
+            get {
+                if (CurrentIdx >= Streams.Length)
+                    return 0;
+
+                long length = 0;
+                for (int i = 0; i < Streams.Length; ++i)
+                    length += Streams[i].Length;
+
+                return length;
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (CurrentIdx >= Streams.Length)
+                return -1;
+
+            int readCount = Streams[CurrentIdx].Read(buffer, offset, count);
+
+            while (readCount < count && CurrentIdx++ < Streams.Length)
+            {
+                readCount += Streams[CurrentIdx].Read(buffer, offset + readCount, count - readCount);
+            }
+
+            return readCount;
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (CurrentIdx >= Streams.Length)
+                return;
+
+            Streams[CurrentIdx].Write(buffer, offset, count);
+        }
+
+        public void Write(string str)
+        {
+            byte[] bytes = str.GetASCIIBytes();
+
+            this.Write(bytes, 0, bytes.Length);
+            VariableSizedBufferPool.Release(bytes);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            for (int i = 0; i < Streams.Length; ++i)
+            {
+                try
+                {
+                    Streams[i].Dispose();
+                }
+                catch(Exception ex)
+                {
+                    HTTPManager.Logger.Exception("StreamList", "Dispose", ex);
+                }
+            }
+        }
+
+        public override long Position
+        {
+            get
+            {
+                throw new NotImplementedException("Position get");
+            }
+            set
+            {
+                throw new NotImplementedException("Position set");
+            }
+        }
+
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            if (CurrentIdx >= Streams.Length)
+                return 0;
+
+            return Streams[CurrentIdx].Seek(offset, origin);
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException("SetLength");
+        }
+    }
+
+    /*public static class AndroidFileHelper
+    {
+        // AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
+        // AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("currentActivity");
+
+        public static Stream GetAPKFileStream(string path)
+        {
+            UnityEngine.AndroidJavaClass up = new UnityEngine.AndroidJavaClass("com.unity3d.player.UnityPlayer");
+            UnityEngine.AndroidJavaObject cActivity = up.GetStatic<UnityEngine.AndroidJavaObject>("currentActivity");
+
+            UnityEngine.AndroidJavaObject assetManager = cActivity.GetStatic<UnityEngine.AndroidJavaObject>("getAssets");
+
+            return new AndroidInputStream(assetManager.Call<UnityEngine.AndroidJavaObject>("open", path));
+        }
+    }
+
+    public sealed class AndroidInputStream : Stream
+    {
+        private UnityEngine.AndroidJavaObject baseStream;
+
+        public override bool CanRead
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override bool CanSeek
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override bool CanWrite
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override void Flush()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override long Position
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+            set
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public AndroidInputStream(UnityEngine.AndroidJavaObject inputStream)
+        {
+            this.baseStream = inputStream;
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return this.baseStream.Call<int>("read", buffer, offset, count);
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+    }*/
+
+    internal sealed class FileConnection : ConnectionBase
+    {
+        public FileConnection(string serverAddress)
+            :base(serverAddress)
+        { }
+
+        internal override void Abort(HTTPConnectionStates newState)
+        {
+            State = newState;
+
+            switch (State)
+            {
+                case HTTPConnectionStates.TimedOut: TimedOutStart = DateTime.UtcNow; break;
+            }
+
+            throw new NotImplementedException();
+        }
+
+        protected override void ThreadFunc(object param)
+        {
+            try
+            {
+                // Step 1 : create a stream with header information
+                // Step 2 : create a stream from the file
+                // Step 3 : create a StreamList
+                // Step 4 : create a HTTPResponse object
+                // Step 5 : call the Receive function of the response object
+
+                using (System.IO.Stream fs = HTTPManager.IOService.CreateFileStream(this.CurrentRequest.CurrentUri.LocalPath, FileStreamModes.Open))
+                //using (Stream fs = AndroidFileHelper.GetAPKFileStream(this.CurrentRequest.CurrentUri.LocalPath))
+                    using (StreamList stream = new StreamList(new System.IO.MemoryStream(), fs))
+                    {
+                        // This will write to the MemoryStream
+                        stream.Write("HTTP/1.1 200 Ok\r\n");
+                        stream.Write("Content-Type: application/octet-stream\r\n");
+                        stream.Write("Content-Length: " + fs.Length.ToString() + "\r\n");
+                        stream.Write("\r\n");
+
+                        stream.Seek(0, System.IO.SeekOrigin.Begin);
+
+                        base.CurrentRequest.Response = new HTTPResponse(base.CurrentRequest, stream, base.CurrentRequest.UseStreaming, false);
+
+                        if (!CurrentRequest.Response.Receive())
+                            CurrentRequest.Response = null;
+                    }
+            }
+            catch(Exception ex)
+            {
+                if (CurrentRequest != null)
+                {
+                    // Something gone bad, Response must be null!
+                    CurrentRequest.Response = null;
+
+                    switch (State)
+                    {
+                        case HTTPConnectionStates.AbortRequested:
+                            CurrentRequest.State = HTTPRequestStates.Aborted;
+                            break;
+                        case HTTPConnectionStates.TimedOut:
+                            CurrentRequest.State = HTTPRequestStates.TimedOut;
+                            break;
+                        default:
+                            CurrentRequest.Exception = ex;
+                            CurrentRequest.State = HTTPRequestStates.Error;
+                            break;
+                    }
+                }
+            }
+            finally
+            {
+                State = HTTPConnectionStates.Closed;
+                if (CurrentRequest.State == HTTPRequestStates.Processing)
+                {
+                    if (CurrentRequest.Response != null)
+                        CurrentRequest.State = HTTPRequestStates.Finished;
+                    else
+                        CurrentRequest.State = HTTPRequestStates.Error;
+                }
+            }
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/FileConnection.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 24106f78264881a419f83ef4b760ded7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/WebGLConnection.cs

@@ -0,0 +1,411 @@
+#if UNITY_WEBGL && !UNITY_EDITOR
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+
+using BestHTTP.Authentication;
+using BestHTTP.Extensions;
+
+namespace BestHTTP
+{
+    delegate void OnWebGLRequestHandlerDelegate(int nativeId, int httpStatus, IntPtr pBuffer, int length, int zero);
+    delegate void OnWebGLBufferDelegate(int nativeId, IntPtr pBuffer, int length);
+    delegate void OnWebGLProgressDelegate(int nativeId, int downloaded, int total);
+    delegate void OnWebGLErrorDelegate(int nativeId, string error);
+    delegate void OnWebGLTimeoutDelegate(int nativeId);
+    delegate void OnWebGLAbortedDelegate(int nativeId);
+
+    internal sealed class WebGLConnection : ConnectionBase
+    {
+        static Dictionary<int, WebGLConnection> Connections = new Dictionary<int, WebGLConnection>(4);
+
+        int NativeId;
+        BufferPoolMemoryStream Stream;
+
+        public WebGLConnection(string serverAddress)
+            : base(serverAddress, false)
+        {
+            XHR_SetLoglevel((byte)HTTPManager.Logger.Level);
+        }
+
+        internal override void Abort(HTTPConnectionStates newState)
+        {
+            State = newState;
+
+            switch (State)
+            {
+                case HTTPConnectionStates.TimedOut: TimedOutStart = DateTime.UtcNow; break;
+            }
+
+            XHR_Abort(this.NativeId);
+        }
+
+        protected override void ThreadFunc(object param /*null*/)
+        {
+            // XmlHttpRequest setup
+
+            this.NativeId = XHR_Create(HTTPRequest.MethodNames[(byte)CurrentRequest.MethodType],
+                                       CurrentRequest.CurrentUri.OriginalString,
+                                       CurrentRequest.Credentials != null ? CurrentRequest.Credentials.UserName : null,
+                                       CurrentRequest.Credentials != null ? CurrentRequest.Credentials.Password : null,
+                                       CurrentRequest.WithCredentials ? 1 : 0);
+            Connections.Add(NativeId, this);
+
+            CurrentRequest.EnumerateHeaders((header, values) =>
+                {
+                    if (header != "Content-Length")
+                        for (int i = 0; i < values.Count; ++i)
+                            XHR_SetRequestHeader(NativeId, header, values[i]);
+                }, /*callBeforeSendCallback:*/ true);
+
+            byte[] body = CurrentRequest.GetEntityBody();
+
+            XHR_SetResponseHandler(NativeId, WebGLConnection.OnResponse, WebGLConnection.OnError, WebGLConnection.OnTimeout, WebGLConnection.OnAborted);
+            // Setting OnUploadProgress result in an addEventListener("progress", ...) call making the request non-simple.
+            // https://forum.unity.com/threads/best-http-released.200006/page-49#post-3696220
+            XHR_SetProgressHandler(NativeId, WebGLConnection.OnDownloadProgress, CurrentRequest.OnUploadProgress == null ? (OnWebGLProgressDelegate)null : WebGLConnection.OnUploadProgress);
+
+            XHR_SetTimeout(NativeId, (uint)(CurrentRequest.ConnectTimeout.TotalMilliseconds + CurrentRequest.Timeout.TotalMilliseconds));
+
+            XHR_Send(NativeId, body, body != null ? body.Length : 0);
+        }
+
+#region Callback Implementations
+
+        void OnResponse(int httpStatus, byte[] buffer, int bufferLength)
+        {
+            try
+            {
+                using (var ms = new BufferPoolMemoryStream())
+                {
+                    Stream = ms;
+
+                    XHR_GetStatusLine(NativeId, OnBufferCallback);
+                    XHR_GetResponseHeaders(NativeId, OnBufferCallback);
+
+                    if (buffer != null && bufferLength > 0)
+                        ms.Write(buffer, 0, bufferLength);
+
+                    ms.Seek(0L, SeekOrigin.Begin);
+
+                    var internalBuffer = ms.GetBuffer();
+                    string tmp = System.Text.Encoding.UTF8.GetString(internalBuffer);
+                    HTTPManager.Logger.Information(this.NativeId + " OnResponse - full response ", tmp);
+
+                    SupportedProtocols protocol = CurrentRequest.ProtocolHandler == SupportedProtocols.Unknown ? HTTPProtocolFactory.GetProtocolFromUri(CurrentRequest.CurrentUri) : CurrentRequest.ProtocolHandler;
+                    CurrentRequest.Response = HTTPProtocolFactory.Get(protocol, CurrentRequest, ms, CurrentRequest.UseStreaming, false);
+
+                    CurrentRequest.Response.Receive(buffer != null && bufferLength > 0 ? (int)bufferLength : -1, true);
+
+                    if (CurrentRequest.IsCookiesEnabled)
+                        BestHTTP.Cookies.CookieJar.Set(CurrentRequest.Response);
+                }
+            }
+            catch (Exception e)
+            {
+                HTTPManager.Logger.Exception(this.NativeId + " WebGLConnection", "OnResponse", e);
+
+                if (CurrentRequest != null)
+                {
+                    // Something gone bad, Response must be null!
+                    CurrentRequest.Response = null;
+
+                    switch (State)
+                    {
+                        case HTTPConnectionStates.AbortRequested:
+                            CurrentRequest.State = HTTPRequestStates.Aborted;
+                            break;
+                        case HTTPConnectionStates.TimedOut:
+                            CurrentRequest.State = HTTPRequestStates.TimedOut;
+                            break;
+                        default:
+                            CurrentRequest.Exception = e;
+                            CurrentRequest.State = HTTPRequestStates.Error;
+                            break;
+                    }
+                }
+            }
+            finally
+            {
+                Connections.Remove(NativeId);
+
+                Stream = null;
+
+                if (CurrentRequest != null)
+                    lock (HTTPManager.Locker)
+                    {
+                        State = HTTPConnectionStates.Closed;
+                        if (CurrentRequest.State == HTTPRequestStates.Processing)
+                        {
+                            if (CurrentRequest.Response != null)
+                                CurrentRequest.State = HTTPRequestStates.Finished;
+                            else
+                                CurrentRequest.State = HTTPRequestStates.Error;
+                        }
+                    }
+
+                LastProcessTime = DateTime.UtcNow;
+
+                if (OnConnectionRecycled != null)
+                    RecycleNow();
+
+                XHR_Release(NativeId);
+            }
+        }
+
+        void OnBuffer(byte[] buffer, int bufferLength)
+        {
+            if (Stream != null)
+            {
+                Stream.Write(buffer, 0, bufferLength);
+                //Stream.Write(new byte[2] { HTTPResponse.CR, HTTPResponse.LF }, 0, 2);
+                Stream.Write(HTTPRequest.EOL, 0, HTTPRequest.EOL.Length);
+            }
+        }
+
+        void OnDownloadProgress(int down, int total)
+        {
+            CurrentRequest.Downloaded = down;
+            CurrentRequest.DownloadLength = total;
+            CurrentRequest.DownloadProgressChanged = true;
+        }
+
+        void OnUploadProgress(int up, int total)
+        {
+            CurrentRequest.Uploaded = up;
+            CurrentRequest.UploadLength = total;
+            CurrentRequest.UploadProgressChanged = true;
+        }
+
+        void OnError(string error)
+        {
+            HTTPManager.Logger.Information(this.NativeId + " WebGLConnection - OnError", error);
+
+            Connections.Remove(NativeId);
+
+            Stream = null;
+
+            if (CurrentRequest != null)
+                lock (HTTPManager.Locker)
+                {
+                    State = HTTPConnectionStates.Closed;
+                    CurrentRequest.State = HTTPRequestStates.Error;
+                    CurrentRequest.Exception = new Exception(error);
+                }
+
+            LastProcessTime = DateTime.UtcNow;
+
+            if (OnConnectionRecycled != null)
+                RecycleNow();
+
+            XHR_Release(NativeId);
+        }
+
+        void OnTimeout()
+        {
+            HTTPManager.Logger.Information(this.NativeId + " WebGLConnection - OnResponse", string.Empty);
+
+            Connections.Remove(NativeId);
+
+            Stream = null;
+
+            if (CurrentRequest != null)
+                lock (HTTPManager.Locker)
+                {
+                    State = HTTPConnectionStates.Closed;
+                    CurrentRequest.State = HTTPRequestStates.TimedOut;
+                }
+
+            LastProcessTime = DateTime.UtcNow;
+
+            if (OnConnectionRecycled != null)
+                RecycleNow();
+
+            XHR_Release(NativeId);
+        }
+
+        void OnAborted()
+        {
+            HTTPManager.Logger.Information(this.NativeId + " WebGLConnection - OnAborted", string.Empty);
+
+            Connections.Remove(NativeId);
+
+            Stream = null;
+
+            if (CurrentRequest != null)
+                lock (HTTPManager.Locker)
+                {
+                    State = HTTPConnectionStates.Closed;
+                    CurrentRequest.State = HTTPRequestStates.Aborted;
+                }
+
+            LastProcessTime = DateTime.UtcNow;
+
+            if (OnConnectionRecycled != null)
+                RecycleNow();
+
+            XHR_Release(NativeId);
+        }
+
+#endregion
+
+#region WebGL Static Callbacks
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLRequestHandlerDelegate))]
+        static void OnResponse(int nativeId, int httpStatus, IntPtr pBuffer, int length, int err)
+        {
+            HTTPManager.Logger.Information("WebGLConnection - OnResponse", string.Format("{0} {1} {2} {3}", nativeId, httpStatus, length, err));
+
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnResponse", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            byte[] buffer = VariableSizedBufferPool.Get(length, true);
+
+            // Copy data from the 'unmanaged' memory to managed memory. Buffer will be reclaimed by the GC.
+            Marshal.Copy(pBuffer, buffer, 0, length);
+
+            conn.OnResponse(httpStatus, buffer, length);
+
+            VariableSizedBufferPool.Release(buffer);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLBufferDelegate))]
+        static void OnBufferCallback(int nativeId, IntPtr pBuffer, int length)
+        {
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnBufferCallback", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            byte[] buffer = VariableSizedBufferPool.Get(length, true);
+
+            // Copy data from the 'unmanaged' memory to managed memory. Buffer will be reclaimed by the GC.
+            Marshal.Copy(pBuffer, buffer, 0, length);
+
+            conn.OnBuffer(buffer, length);
+
+            VariableSizedBufferPool.Release(buffer);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLProgressDelegate))]
+        static void OnDownloadProgress(int nativeId, int downloaded, int total)
+        {
+            HTTPManager.Logger.Information(nativeId + " OnDownloadProgress", downloaded.ToString() + " / " + total.ToString());
+
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnDownloadProgress", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            conn.OnDownloadProgress(downloaded, total);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLProgressDelegate))]
+        static void OnUploadProgress(int nativeId, int uploaded, int total)
+        {
+            HTTPManager.Logger.Information(nativeId + " OnUploadProgress", uploaded.ToString() + " / " + total.ToString());
+
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnUploadProgress", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            conn.OnUploadProgress(uploaded, total);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLErrorDelegate))]
+        static void OnError(int nativeId, string error)
+        {
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnError", "No WebGL connection found for nativeId: " + nativeId.ToString() + " Error: " + error);
+                return;
+            }
+
+            conn.OnError(error);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLTimeoutDelegate))]
+        static void OnTimeout(int nativeId)
+        {
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnTimeout", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            conn.OnTimeout();
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(OnWebGLAbortedDelegate))]
+        static void OnAborted(int nativeId)
+        {
+            WebGLConnection conn = null;
+            if (!Connections.TryGetValue(nativeId, out conn))
+            {
+                HTTPManager.Logger.Error("WebGLConnection - OnAborted", "No WebGL connection found for nativeId: " + nativeId.ToString());
+                return;
+            }
+
+            conn.OnAborted();
+        }
+
+#endregion
+
+#region WebGL Interface
+
+        [DllImport("__Internal")]
+        private static extern int XHR_Create(string method, string url, string userName, string passwd, int withCredentials);
+
+        /// <summary>
+        /// Is an unsigned long representing the number of milliseconds a request can take before automatically being terminated. A value of 0 (which is the default) means there is no timeout.
+        /// </summary>
+        [DllImport("__Internal")]
+        private static extern void XHR_SetTimeout(int nativeId, uint timeout);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_SetRequestHeader(int nativeId, string header, string value);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_SetResponseHandler(int nativeId, OnWebGLRequestHandlerDelegate onresponse, OnWebGLErrorDelegate onerror, OnWebGLTimeoutDelegate ontimeout, OnWebGLAbortedDelegate onabort);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_SetProgressHandler(int nativeId, OnWebGLProgressDelegate onDownloadProgress, OnWebGLProgressDelegate onUploadProgress);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_Send(int nativeId, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.U1, SizeParamIndex = 2)] byte[] body, int length);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_GetResponseHeaders(int nativeId, OnWebGLBufferDelegate callback);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_GetStatusLine(int nativeId, OnWebGLBufferDelegate callback);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_Abort(int nativeId);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_Release(int nativeId);
+
+        [DllImport("__Internal")]
+        private static extern void XHR_SetLoglevel(int logLevel);
+
+#endregion
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Connections/WebGLConnection.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: cca5a5d266418134dbb9c0b87c68e62a
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Cookies.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d5f4e603c9763e64791a9934acb71d6b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Cookies/Cookie.cs

@@ -0,0 +1,359 @@
+#if !BESTHTTP_DISABLE_COOKIES
+
+using System;
+using System.Collections.Generic;
+using BestHTTP.Extensions;
+using System.IO;
+
+namespace BestHTTP.Cookies
+{
+    /// <summary>
+    /// The Cookie implementation based on RFC 6265(http://tools.ietf.org/html/rfc6265).
+    /// </summary>
+    public sealed class Cookie : IComparable<Cookie>, IEquatable<Cookie>
+    {
+        private const int Version = 1;
+
+        #region Public Properties
+
+        /// <summary>
+        /// The name of the cookie.
+        /// </summary>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// The value of the cookie.
+        /// </summary>
+        public string Value { get; private set; }
+
+        /// <summary>
+        /// The Date when the Cookie is registered.
+        /// </summary>
+        public DateTime Date { get; internal set; }
+
+        /// <summary>
+        /// When this Cookie last used in a request.
+        /// </summary>
+        public DateTime LastAccess { get; set; }
+
+        /// <summary>
+        /// The Expires attribute indicates the maximum lifetime of the cookie, represented as the date and time at which the cookie expires.
+        /// The user agent is not required to retain the cookie until the specified date has passed.
+        /// In fact, user agents often evict cookies due to memory pressure or privacy concerns.
+        /// </summary>
+        public DateTime Expires { get; private set; }
+
+        /// <summary>
+        /// The Max-Age attribute indicates the maximum lifetime of the cookie, represented as the number of seconds until the cookie expires.
+        /// The user agent is not required to retain the cookie for the specified duration.
+        /// In fact, user agents often evict cookies due to memory pressure or privacy concerns.
+        /// </summary>
+        public long MaxAge { get; private set; }
+
+        /// <summary>
+        /// If a cookie has neither the Max-Age nor the Expires attribute, the user agent will retain the cookie until "the current session is over".
+        /// </summary>
+        public bool IsSession { get; private set; }
+
+        /// <summary>
+        /// The Domain attribute specifies those hosts to which the cookie will be sent.
+        /// For example, if the value of the Domain attribute is "example.com", the user agent will include the cookie
+        /// in the Cookie header when making HTTP requests to example.com, www.example.com, and www.corp.example.com.
+        /// If the server omits the Domain attribute, the user agent will return the cookie only to the origin server.
+        /// </summary>
+        public string Domain { get; private set; }
+
+        /// <summary>
+        /// The scope of each cookie is limited to a set of paths, controlled by the Path attribute.
+        /// If the server omits the Path attribute, the user agent will use the "directory" of the request-uri's path component as the default value.
+        /// </summary>
+        public string Path { get; private set; }
+
+        /// <summary>
+        /// The Secure attribute limits the scope of the cookie to "secure" channels (where "secure" is defined by the user agent).
+        /// When a cookie has the Secure attribute, the user agent will include the cookie in an HTTP request only if the request is
+        /// transmitted over a secure channel (typically HTTP over Transport Layer Security (TLS)).
+        /// </summary>
+        public bool IsSecure { get; private set; }
+
+        /// <summary>
+        /// The HttpOnly attribute limits the scope of the cookie to HTTP requests.
+        /// In particular, the attribute instructs the user agent to omit the cookie when providing access to
+        /// cookies via "non-HTTP" APIs (such as a web browser API that exposes cookies to scripts).
+        /// </summary>
+        public bool IsHttpOnly { get; private set; }
+
+        #endregion
+
+        #region Public Constructors
+
+        public Cookie(string name, string value)
+            :this(name, value, "/", string.Empty)
+        {}
+
+        public Cookie(string name, string value, string path)
+            : this(name, value, path, string.Empty)
+        {}
+
+        public Cookie(string name, string value, string path, string domain)
+            :this() // call the parameter-less constructor to set default values
+        {
+            this.Name = name;
+            this.Value = value;
+            this.Path = path;
+            this.Domain = domain;
+        }
+
+        public Cookie(Uri uri, string name, string value, DateTime expires, bool isSession = true)
+            :this(name, value, uri.AbsolutePath, uri.Host)
+        {
+            this.Expires = expires;
+            this.IsSession = isSession;
+            this.Date = DateTime.UtcNow;
+        }
+
+        public Cookie(Uri uri, string name, string value, long maxAge = -1, bool isSession = true)
+            :this(name, value, uri.AbsolutePath, uri.Host)
+        {
+            this.MaxAge = maxAge;
+            this.IsSession = isSession;
+            this.Date = DateTime.UtcNow;
+        }
+
+        #endregion
+
+        internal Cookie()
+        {
+            // If a cookie has neither the Max-Age nor the Expires attribute, the user agent will retain the cookie
+            //  until "the current session is over" (as defined by the user agent).
+            IsSession = true;
+            MaxAge = -1;
+            LastAccess = DateTime.UtcNow;
+        }
+
+        public bool WillExpireInTheFuture()
+        {
+            // No Expires or Max-Age value sent from the server, we will fake the return value so we will not delete the newly came Cookie
+            if (IsSession)
+                return true;
+
+            // If a cookie has both the Max-Age and the Expires attribute, the Max-Age attribute has precedence and controls the expiration date of the cookie.
+            return MaxAge != -1 ?
+                    Math.Max(0, (long)(DateTime.UtcNow - Date).TotalSeconds) < MaxAge :
+                    Expires > DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Guess the storage size of the cookie.
+        /// </summary>
+        /// <returns></returns>
+        public uint GuessSize()
+        {
+            return (uint)((Name != null ? Name.Length * sizeof(char) : 0) +
+                          (Value != null ? Value.Length * sizeof(char) : 0) +
+                          (Domain != null ? Domain.Length * sizeof(char) : 0) +
+                          (Path != null ? Path.Length * sizeof(char) : 0) +
+                          (sizeof(long) * 4) +
+                          (sizeof(bool) * 3));
+        }
+
+        public static Cookie Parse(string header, Uri defaultDomain)
+        {
+            Cookie cookie = new Cookie();
+            try
+            {
+                var kvps = ParseCookieHeader(header);
+
+                foreach (var kvp in kvps)
+                {
+                    switch (kvp.Key.ToLowerInvariant())
+                    {
+                        case "path":
+                            // If the attribute-value is empty or if the first character of the attribute-value is not %x2F ("/"):
+                            //  Let cookie-path be the default-path.
+                            cookie.Path = string.IsNullOrEmpty(kvp.Value) || !kvp.Value.StartsWith("/") ? "/" : cookie.Path = kvp.Value;
+                            break;
+
+                        case "domain":
+                            // If the attribute-value is empty, the behavior is undefined. However, the user agent SHOULD ignore the cookie-av entirely.
+                            if (string.IsNullOrEmpty(kvp.Value))
+                                return null;
+
+                            // If the first character of the attribute-value string is %x2E ("."):
+                            //  Let cookie-domain be the attribute-value without the leading %x2E (".") character.
+                            cookie.Domain = kvp.Value.StartsWith(".") ? kvp.Value.Substring(1) : kvp.Value;
+                            break;
+
+                        case "expires":
+                            cookie.Expires = kvp.Value.ToDateTime(DateTime.FromBinary(0));
+                            cookie.IsSession = false;
+                            break;
+
+                        case "max-age":
+                            cookie.MaxAge = kvp.Value.ToInt64(-1);
+                            cookie.IsSession = false;
+                            break;
+
+                        case "secure":
+                            cookie.IsSecure = true;
+                            break;
+
+                        case "httponly":
+                            cookie.IsHttpOnly = true;
+                            break;
+
+                        default:
+                            cookie.Name = kvp.Key;
+                            cookie.Value = kvp.Value;
+                            break;
+                    }
+                }
+
+                // Some user agents provide users the option of preventing persistent storage of cookies across sessions.
+                // When configured thusly, user agents MUST treat all received cookies as if the persistent-flag were set to false.
+                if (HTTPManager.EnablePrivateBrowsing)
+                    cookie.IsSession = true;
+
+                // http://tools.ietf.org/html/rfc6265#section-4.1.2.3
+                // WARNING: Some existing user agents treat an absent Domain attribute as if the Domain attribute were present and contained the current host name.
+                // For example, if example.com returns a Set-Cookie header without a Domain attribute, these user agents will erroneously send the cookie to www.example.com as well.
+                if (string.IsNullOrEmpty(cookie.Domain))
+                    cookie.Domain = defaultDomain.Host;
+
+                // http://tools.ietf.org/html/rfc6265#section-5.3 section 7:
+                // If the cookie-attribute-list contains an attribute with an attribute-name of "Path",
+                // set the cookie's path to attribute-value of the last attribute in the cookie-attribute-list with an attribute-name of "Path".
+                // __Otherwise, set the cookie's path to the default-path of the request-uri.__
+                if (string.IsNullOrEmpty(cookie.Path))
+                    cookie.Path = defaultDomain.AbsolutePath;
+
+                cookie.Date = cookie.LastAccess = DateTime.UtcNow;
+            }
+            catch (Exception ex)
+            {
+                HTTPManager.Logger.Warning("Cookie", "Parse - Couldn't parse header: " + header + " exception: " + ex.ToString() + " " + ex.StackTrace);
+            }
+            return cookie;
+        }
+
+        #region Save & Load
+
+        internal void SaveTo(BinaryWriter stream)
+        {
+            stream.Write(Version);
+            stream.Write(Name ?? string.Empty);
+            stream.Write(Value ?? string.Empty);
+            stream.Write(Date.ToBinary());
+            stream.Write(LastAccess.ToBinary());
+            stream.Write(Expires.ToBinary());
+            stream.Write(MaxAge);
+            stream.Write(IsSession);
+            stream.Write(Domain ?? string.Empty);
+            stream.Write(Path ?? string.Empty);
+            stream.Write(IsSecure);
+            stream.Write(IsHttpOnly);
+        }
+
+        internal void LoadFrom(BinaryReader stream)
+        {
+            /*int version = */stream.ReadInt32();
+            this.Name = stream.ReadString();
+            this.Value = stream.ReadString();
+            this.Date = DateTime.FromBinary(stream.ReadInt64());
+            this.LastAccess = DateTime.FromBinary(stream.ReadInt64());
+            this.Expires = DateTime.FromBinary(stream.ReadInt64());
+            this.MaxAge = stream.ReadInt64();
+            this.IsSession = stream.ReadBoolean();
+            this.Domain = stream.ReadString();
+            this.Path = stream.ReadString();
+            this.IsSecure = stream.ReadBoolean();
+            this.IsHttpOnly = stream.ReadBoolean();
+        }
+
+        #endregion
+
+        #region Overrides and new Equals function
+
+        public override string ToString()
+        {
+            return string.Concat(this.Name, "=", this.Value);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+                return false;
+
+            return this.Equals(obj as Cookie);
+        }
+
+        public bool Equals(Cookie cookie)
+        {
+            if (cookie == null)
+                return false;
+
+            if (Object.ReferenceEquals(this, cookie))
+                return true;
+
+            return this.Name.Equals(cookie.Name, StringComparison.Ordinal) &&
+                ((this.Domain == null && cookie.Domain == null) || this.Domain.Equals(cookie.Domain, StringComparison.Ordinal)) &&
+                ((this.Path == null && cookie.Path == null) || this.Path.Equals(cookie.Path, StringComparison.Ordinal));
+        }
+
+        public override int GetHashCode()
+        {
+            return this.ToString().GetHashCode();
+        }
+
+        #endregion
+
+        #region Private Helper Functions
+
+        private static string ReadValue(string str, ref int pos)
+        {
+            string result = string.Empty;
+            if (str == null)
+                return result;
+
+            return str.Read(ref pos, ';');
+        }
+
+        private static List<HeaderValue> ParseCookieHeader(string str)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            if (str == null)
+                return result;
+
+            int idx = 0;
+
+            // process the rest of the text
+            while (idx < str.Length)
+            {
+                // Read key
+                string key = str.Read(ref idx, (ch) => ch != '=' && ch != ';').Trim();
+                HeaderValue qp = new HeaderValue(key);
+
+                if (idx < str.Length && str[idx - 1] == '=')
+                    qp.Value = ReadValue(str, ref idx);
+
+                result.Add(qp);
+            }
+
+            return result;
+        }
+
+        #endregion
+
+        #region IComparable<Cookie> implementation
+
+        public int CompareTo(Cookie other)
+        {
+            return this.LastAccess.CompareTo(other.LastAccess);
+        }
+
+        #endregion
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Cookies/Cookie.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3c89f8c2ca77c56448d03216927e0546
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Cookies/CookieJar.cs

@@ -0,0 +1,489 @@
+#if !BESTHTTP_DISABLE_COOKIES
+
+using BestHTTP.PlatformSupport.FileSystem;
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Cookies
+{
+    /// <summary>
+    /// The Cookie Jar implementation based on RFC 6265(http://tools.ietf.org/html/rfc6265).
+    /// </summary>
+    public static class CookieJar
+    {
+        // Version of the cookie store. It may be used in a future version for maintaining compatibility.
+        private const int Version = 1;
+
+        /// <summary>
+        /// Returns true if File apis are supported.
+        /// </summary>
+        public static bool IsSavingSupported
+        {
+            get
+            {
+#if !BESTHTTP_DISABLE_COOKIE_SAVE
+                if (IsSupportCheckDone)
+                    return _isSavingSupported;
+
+                try
+                {
+                    HTTPManager.IOService.DirectoryExists(HTTPManager.GetRootCacheFolder());
+                    _isSavingSupported = true;
+                }
+                catch
+                {
+                    _isSavingSupported = false;
+
+                    HTTPManager.Logger.Warning("CookieJar", "Cookie saving and loading disabled!");
+                }
+                finally
+                {
+                    IsSupportCheckDone = true;
+                }
+
+                return _isSavingSupported;
+#else
+                return false;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// The plugin will delete cookies that are accessed this threshold ago. Its default value is 7 days.
+        /// </summary>
+        public static TimeSpan AccessThreshold = TimeSpan.FromDays(7);
+
+#region Privates
+
+        /// <summary>
+        /// List of the Cookies
+        /// </summary>
+        private static List<Cookie> Cookies = new List<Cookie>();
+        private static string CookieFolder { get; set; }
+        private static string LibraryPath { get; set; }
+
+        /// <summary>
+        /// Synchronization object for thread safety.
+        /// </summary>
+        private static object Locker = new object();
+
+#if !BESTHTTP_DISABLE_COOKIE_SAVE
+        private static bool _isSavingSupported;
+        private static bool IsSupportCheckDone;
+#endif
+
+        private static bool Loaded;
+#endregion
+
+#region Internal Functions
+
+        internal static void SetupFolder()
+        {
+#if !BESTHTTP_DISABLE_COOKIE_SAVE
+            if (!CookieJar.IsSavingSupported)
+                return;
+
+            try
+            {
+                if (string.IsNullOrEmpty(CookieFolder) || string.IsNullOrEmpty(LibraryPath))
+                {
+                    CookieFolder = System.IO.Path.Combine(HTTPManager.GetRootCacheFolder(), "Cookies");
+                    LibraryPath = System.IO.Path.Combine(CookieFolder, "Library");
+                }
+            }
+            catch
+            { }
+#endif
+        }
+
+        /// <summary>
+        /// Will set or update all cookies from the response object.
+        /// </summary>
+        internal static void Set(HTTPResponse response)
+        {
+            if (response == null)
+                return;
+
+            lock(Locker)
+            {
+                try
+                {
+                    Maintain();
+
+                    List<Cookie> newCookies = new List<Cookie>();
+                    var setCookieHeaders = response.GetHeaderValues("set-cookie");
+
+                    // No cookies. :'(
+                    if (setCookieHeaders == null)
+                        return;
+
+                    foreach (var cookieHeader in setCookieHeaders)
+                    {
+                        try
+                        {
+                            Cookie cookie = Cookie.Parse(cookieHeader, response.baseRequest.CurrentUri);
+
+                            if (cookie != null)
+                            {
+                                int idx;
+                                var old = Find(cookie, out idx);
+
+                                // if no value for the cookie or already expired then the server asked us to delete the cookie
+                                bool expired = string.IsNullOrEmpty(cookie.Value) || !cookie.WillExpireInTheFuture();
+
+                                if (!expired)
+                                {
+                                    // no old cookie, add it straight to the list
+                                    if (old == null)
+                                    {
+                                        Cookies.Add(cookie);
+
+                                        newCookies.Add(cookie);
+                                    }
+                                    else
+                                    {
+                                        // Update the creation-time of the newly created cookie to match the creation-time of the old-cookie.
+                                        cookie.Date = old.Date;
+                                        Cookies[idx] = cookie;
+
+                                        newCookies.Add(cookie);
+                                    }
+                                }
+                                else if (idx != -1) // delete the cookie
+                                    Cookies.RemoveAt(idx);
+                            }
+                        }
+                        catch
+                        {
+                            // Ignore cookie on error
+                        }
+                    }
+
+                    response.Cookies = newCookies;
+                }
+                catch
+                {}
+            }
+        }
+
+        /// <summary>
+        /// Deletes all expired or 'old' cookies, and will keep the sum size of cookies under the given size.
+        /// </summary>
+        internal static void Maintain()
+        {
+            // It's not the same as in the rfc:
+            //  http://tools.ietf.org/html/rfc6265#section-5.3
+
+            lock (Locker)
+            {
+                try
+                {
+                    uint size = 0;
+
+                    for (int i = 0; i < Cookies.Count; )
+                    {
+                        var cookie = Cookies[i];
+
+                        // Remove expired or not used cookies
+                        if (!cookie.WillExpireInTheFuture() || (cookie.LastAccess + AccessThreshold) < DateTime.UtcNow)
+                            Cookies.RemoveAt(i);
+                        else
+                        {
+                            if (!cookie.IsSession)
+                                size += cookie.GuessSize();
+                            i++;
+                        }
+                    }
+
+                    if (size > HTTPManager.CookieJarSize)
+                    {
+                        Cookies.Sort();
+
+                        while (size > HTTPManager.CookieJarSize && Cookies.Count > 0)
+                        {
+                            var cookie = Cookies[0];
+                            Cookies.RemoveAt(0);
+
+                            size -= cookie.GuessSize();
+                        }
+                    }
+                }
+                catch
+                { }
+            }
+        }
+
+        /// <summary>
+        /// Saves the Cookie Jar to a file.
+        /// </summary>
+        /// <remarks>Not implemented under Unity WebPlayer</remarks>
+        internal static void Persist()
+        {
+#if !BESTHTTP_DISABLE_COOKIE_SAVE
+            if (!IsSavingSupported)
+                return;
+
+            lock (Locker)
+            {
+                if (!Loaded)
+                    return;
+
+                try
+                {
+                    // Delete any expired cookie
+                    Maintain();
+
+                    if (!HTTPManager.IOService.DirectoryExists(CookieFolder))
+                        HTTPManager.IOService.DirectoryCreate(CookieFolder);
+
+                    using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Create))
+                    using (var bw = new System.IO.BinaryWriter(fs))
+                    {
+                        bw.Write(Version);
+
+                        // Count how many non-session cookies we have
+                        int count = 0;
+                        foreach (var cookie in Cookies)
+                            if (!cookie.IsSession)
+                                count++;
+
+                        bw.Write(count);
+
+                        // Save only the persistable cookies
+                        foreach (var cookie in Cookies)
+                            if (!cookie.IsSession)
+                                cookie.SaveTo(bw);
+                    }
+                }
+                catch
+                { }
+            }
+#endif
+        }
+
+        /// <summary>
+        /// Load previously persisted cookie library from the file.
+        /// </summary>
+        internal static void Load()
+        {
+#if !BESTHTTP_DISABLE_COOKIE_SAVE
+            if (!IsSavingSupported)
+                return;
+
+            lock (Locker)
+            {
+                if (Loaded)
+                    return;
+
+                SetupFolder();
+
+                try
+                {
+                    Cookies.Clear();
+
+                    if (!HTTPManager.IOService.DirectoryExists(CookieFolder))
+                        HTTPManager.IOService.DirectoryCreate(CookieFolder);
+
+                    if (!HTTPManager.IOService.FileExists(LibraryPath))
+                        return;
+
+                    using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Open))
+                    using (var br = new System.IO.BinaryReader(fs))
+                    {
+                        /*int version = */br.ReadInt32();
+                        int cookieCount = br.ReadInt32();
+
+                        for (int i = 0; i < cookieCount; ++i)
+                        {
+                            Cookie cookie = new Cookie();
+                            cookie.LoadFrom(br);
+
+                            if (cookie.WillExpireInTheFuture())
+                                Cookies.Add(cookie);
+                        }
+                    }
+                }
+                catch
+                {
+                    Cookies.Clear();
+                }
+                finally
+                {
+                    Loaded = true;
+                }
+            }
+#endif
+        }
+
+#endregion
+
+#region Public Functions
+
+        /// <summary>
+        /// Returns all Cookies that corresponds to the given Uri.
+        /// </summary>
+        public static List<Cookie> Get(Uri uri)
+        {
+            lock (Locker)
+            {
+                Load();
+
+                List<Cookie> result = null;
+
+                for (int i = 0; i < Cookies.Count; ++i)
+                {
+                    Cookie cookie = Cookies[i];
+                    if (cookie.WillExpireInTheFuture() && uri.Host.IndexOf(cookie.Domain) != -1 && uri.AbsolutePath.StartsWith(cookie.Path))
+                    {
+                        if (result == null)
+                            result = new List<Cookie>();
+
+                        result.Add(cookie);
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Will add a new, or overwrite an old cookie if already exists.
+        /// </summary>
+        public static void Set(Uri uri, Cookie cookie)
+        {
+            Set(cookie);
+        }
+
+        /// <summary>
+        /// Will add a new, or overwrite an old cookie if already exists.
+        /// </summary>
+        public static void Set(Cookie cookie)
+        {
+            lock (Locker)
+            {
+                Load();
+
+                int idx;
+                Find(cookie, out idx);
+
+                if (idx >= 0)
+                    Cookies[idx] = cookie;
+                else
+                    Cookies.Add(cookie);
+            }
+        }
+
+        public static List<Cookie> GetAll()
+        {
+            lock (Locker)
+            {
+                Load();
+
+                return Cookies;
+            }
+        }
+
+        /// <summary>
+        /// Deletes all cookies from the Jar.
+        /// </summary>
+        public static void Clear()
+        {
+            lock (Locker)
+            {
+                Load();
+
+                Cookies.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Removes cookies that older than the given parameter.
+        /// </summary>
+        public static void Clear(TimeSpan olderThan)
+        {
+            lock (Locker)
+            {
+                Load();
+
+                for (int i = 0; i < Cookies.Count; )
+                {
+                    var cookie = Cookies[i];
+
+                    // Remove expired or not used cookies
+                    if (!cookie.WillExpireInTheFuture() || (cookie.Date + olderThan) < DateTime.UtcNow)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes cookies that matches to the given domain.
+        /// </summary>
+        public static void Clear(string domain)
+        {
+            lock (Locker)
+            {
+                Load();
+
+                for (int i = 0; i < Cookies.Count; )
+                {
+                    var cookie = Cookies[i];
+
+                    // Remove expired or not used cookies
+                    if (!cookie.WillExpireInTheFuture() || cookie.Domain.IndexOf(domain) != -1)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+        }
+
+        public static void Remove(Uri uri, string name)
+        {
+            lock(Locker)
+            {
+                Load();
+
+                for (int i = 0; i < Cookies.Count; )
+                {
+                    var cookie = Cookies[i];
+
+                    if (cookie.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && uri.Host.IndexOf(cookie.Domain) != -1)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+        }
+
+#endregion
+
+#region Private Helper Functions
+
+        /// <summary>
+        /// Find and return a Cookie and his index in the list.
+        /// </summary>
+        private static Cookie Find(Cookie cookie, out int idx)
+        {
+            for (int i = 0; i < Cookies.Count; ++i)
+            {
+                Cookie c = Cookies[i];
+
+                if (c.Equals(cookie))
+                {
+                    idx = i;
+                    return c;
+                }
+            }
+
+            idx = -1;
+            return null;
+        }
+
+#endregion
+    }
+}
+
+#endif

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Cookies/CookieJar.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b6b22cd983735ee46908eac3f37eb798
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f315cc9a9215ad948a7b75c25e4c5e65
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/CRC32.cs

@@ -0,0 +1,473 @@
+// 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 BestHTTP.Decompression.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>
+
+    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;
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/CRC32.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 16fc99dd9503b7046bed4bfdbbfec3c0
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Deflate.cs

@@ -0,0 +1,1883 @@
+// 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;
+
+#pragma warning disable 0675
+
+namespace BestHTTP.Decompression.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 ZTree treeLiterals = new ZTree();  // desc for literal tree
+        internal ZTree treeDistances = new ZTree();  // desc for distance tree
+        internal ZTree treeBitLengths = new ZTree(); // 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[ZTree.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[ZTree.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[(ZTree.LengthCode[lc] + InternalConstants.LITERALS + 1) * 2]++;
+                dyn_dtree[ZTree.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 + ZTree.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 = ZTree.LengthCode[lc];
+
+                        // send the length code
+                        send_code(code + InternalConstants.LITERALS + 1, ltree);
+                        extra = ZTree.ExtraLengthBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra length bits
+                            lc -= ZTree.LengthBase[code];
+                            send_bits(lc, extra);
+                        }
+                        distance--; // dist is now the match distance - 1
+                        code = ZTree.DistanceCode(distance);
+
+                        // send the distance code
+                        send_code(code, dtree);
+
+                        extra = ZTree.ExtraDistanceBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra distance bits
+                            distance -= ZTree.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 = Extensions.VariableSizedBufferPool.Get(w_size * 2, false);
+            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 = Extensions.VariableSizedBufferPool.Get(lit_bufsize * 4, false);
+            _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:
+            Extensions.VariableSizedBufferPool.Release(pending);
+            pending = null;
+            head = null;
+            prev = null;
+            Extensions.VariableSizedBufferPool.Release(window);
+            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;
+        }
+
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Deflate.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ad45ad0b3a07a2f4181d9f4243b82395
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/DeflateStream.cs

@@ -0,0 +1,692 @@
+// 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 BestHTTP.Decompression.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>
+    ///
+    /// </remarks>
+    ///
+    /// <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);
+        }
+
+        /// <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>
+        /// <param name="windowBits">Desired window bits.</param>
+        public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, int windowBits)
+        {
+            _innerStream = stream;
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen, windowBits);
+        }
+
+        #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 == BestHTTP.Decompression.Zlib.ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut;
+                if (this._baseStream._streamMode == BestHTTP.Decompression.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>
+        /// Will call the base stream's SetLength method.
+        /// </summary>
+        public override void SetLength(long value)
+        {
+            _baseStream.SetLength(value);
+        }
+
+        /// <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
+    }
+
+}
+

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/DeflateStream.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8b7a3b80f9aa82941a62c619c263ff5e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/GZipStream.cs

@@ -0,0 +1,919 @@
+// 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-July-11 21:42:34>
+//
+// ------------------------------------------------------------------
+//
+// 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 BestHTTP.Decompression.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>
+    ///
+    /// </remarks>
+    ///
+    /// <seealso cref="DeflateStream" />
+    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 entity.
+        ///   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 == BestHTTP.Decompression.Zlib.ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut + _headerByteCount;
+                if (this._baseStream._streamMode == BestHTTP.Decompression.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();
+            _baseStream.SetLength(value);
+        }
+
+        /// <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 == BestHTTP.Decompression.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);
+        internal static readonly System.Text.Encoding iso8859dash1 = System.Text.Encoding.GetEncoding("iso-8859-1");
+
+
+        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 = Extensions.VariableSizedBufferPool.Get(bufferLength, false);
+            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);
+            int headerLength = header.Length;
+
+            Extensions.VariableSizedBufferPool.Release(header);
+
+            return headerLength; // bytes written
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/GZipStream.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: be79ee53ca164d04cbbb654f7de657f5
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/InfTree.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f2541c75abb466b4fb55a2335fe858c2
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Inflate.cs

@@ -0,0 +1,1797 @@
+// 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 BestHTTP.Decompression.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 = Extensions.VariableSizedBufferPool.Get(w, true);
+            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();
+            Extensions.VariableSizedBufferPool.Release(window);
+            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();
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Inflate.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 01ece23e3663e424ba8672d6d3d50f19
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZTree.cs

@@ -0,0 +1,423 @@
+// 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 BestHTTP.Decompression.Zlib
+{
+    sealed class ZTree
+    {
+        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;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZTree.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 567080ac494bf3b47acca3e05bf46e84
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Zlib.cs

@@ -0,0 +1,546 @@
+// 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 BestHTTP.Decompression.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")]
+    internal 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, ZTree.ExtraLengthBits, InternalConstants.LITERALS + 1, InternalConstants.L_CODES, InternalConstants.MAX_BITS);
+            Distances = new StaticTree(distTreeCodes, ZTree.ExtraDistanceBits, 0, InternalConstants.D_CODES, InternalConstants.MAX_BITS);
+            BitLengths = new StaticTree(null, ZTree.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
+
+    }
+
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/Zlib.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7d946fbf5f38d4049a7b50fe52bd8b0e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibBaseStream.cs

@@ -0,0 +1,606 @@
+// 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 System;
+using System.IO;
+
+namespace BestHTTP.Decompression.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 int windowBitsMax;
+        protected internal byte[] _buf1 = new byte[1];
+
+        protected internal System.IO.Stream _stream;
+        protected internal CompressionStrategy Strategy = CompressionStrategy.Default;
+
+        // workitem 7159
+        BestHTTP.Decompression.Crc.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)
+            :this(stream, compressionMode, level, flavor,leaveOpen, ZlibConstants.WindowBitsDefault)
+        { }
+
+        public ZlibBaseStream(System.IO.Stream stream,
+                              CompressionMode compressionMode,
+                              CompressionLevel level,
+                              ZlibStreamFlavor flavor,
+                              bool leaveOpen,
+                              int windowBits)
+            : 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;
+            this.windowBitsMax = windowBits;
+            // workitem 7159
+            if (flavor == ZlibStreamFlavor.GZIP)
+            {
+                this.crc = new BestHTTP.Decompression.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(this.windowBitsMax, wantRfc1950Header);
+                    }
+                    else
+                    {
+                        _z.Strategy = Strategy;
+                        _z.InitializeDeflate(this._level, this.windowBitsMax, wantRfc1950Header);
+                    }
+                }
+                return _z;
+            }
+        }
+
+
+
+        private byte[] workingBuffer
+        {
+            get
+            {
+                if (_workingBuffer == null)
+                    _workingBuffer = Extensions.VariableSizedBufferPool.Get(_bufferSize, true);
+                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 = Extensions.VariableSizedBufferPool.Get(8, true);
+
+                        // 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)
+                            {
+                                Extensions.VariableSizedBufferPool.Release(trailer);
+                                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, 8);
+                        }
+
+                        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)
+                        {
+                            Extensions.VariableSizedBufferPool.Release(trailer);
+                            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)
+                        {
+                            Extensions.VariableSizedBufferPool.Release(trailer);
+                            throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));
+                        }
+                        Extensions.VariableSizedBufferPool.Release(trailer);
+                    }
+                    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;
+            Extensions.VariableSizedBufferPool.Release(_workingBuffer);
+            _workingBuffer = null;
+        }
+
+
+        public
+#if !NETFX_CORE
+            override
+#endif
+            void Close()
+        {
+            if (_stream == null) return;
+            try
+            {
+                finish();
+            }
+            finally
+            {
+                end();
+                if (!_leaveOpen) _stream.Dispose();
+                _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);
+            nomoreinput = false;
+        }
+
+
+#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 = Extensions.VariableSizedBufferPool.Get(10, true);
+            int n = _stream.Read(header, 0, 10);
+
+            // workitem 8501: handle edge case (decompress empty stream)
+            if (n == 0)
+            {
+                Extensions.VariableSizedBufferPool.Release(header);
+                return 0;
+            }
+
+            if (n != 10)
+            {
+                Extensions.VariableSizedBufferPool.Release(header);
+                throw new ZlibException("Not a valid GZIP stream.");
+            }
+
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
+                Extensions.VariableSizedBufferPool.Release(header);
+                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 = Extensions.VariableSizedBufferPool.Get(extraLength, true);
+                n = _stream.Read(extra, 0, extraLength);
+                if (n != extraLength)
+                {
+                    Extensions.VariableSizedBufferPool.Release(extra);
+                    Extensions.VariableSizedBufferPool.Release(header);
+                    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
+
+            Extensions.VariableSizedBufferPool.Release(header);
+            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,
+        }
+
+    }
+
+
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibBaseStream.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b34dd239e486b474aad68fb4080797c8
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibCodec.cs

@@ -0,0 +1,712 @@
+// 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 BestHTTP.Decompression.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>
+    sealed internal 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;
+        }
+
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibCodec.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bc104cfa5b2ba31408766b86b9977226
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibConstants.cs

@@ -0,0 +1,128 @@
+// 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 BestHTTP.Decompression.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;
+    }
+
+}
+

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Decompression/ZlibConstants.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4cd9445fbeecd0642955b4ea35e211c8
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dbb33ec1f5c925045b32ae3d6744daa0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/BufferPoolMemoryStream.cs

@@ -0,0 +1,447 @@
+//
+// System.IO.MemoryStream.cs
+//
+// Authors:	Marcin Szczepanski (marcins@zipworld.com.au)
+//		Patrik Torstensson
+//		Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// (c) 2001,2002 Marcin Szczepanski, Patrik Torstensson
+// (c) 2003 Ximian, Inc. (http://www.ximian.com)
+// Copyright (C) 2004 Novell (http://www.novell.com)
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.IO;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// This is a modified MemoryStream class to use VariableSizedBufferPool
+    /// </summary>
+    public sealed class BufferPoolMemoryStream : System.IO.Stream
+    {
+        bool canWrite;
+        bool allowGetBuffer;
+        int capacity;
+        int length;
+        byte[] internalBuffer;
+        int initialIndex;
+        bool expandable;
+        bool streamClosed;
+        int position;
+        int dirty_bytes;
+
+        public BufferPoolMemoryStream() : this(0)
+        {
+        }
+
+        public BufferPoolMemoryStream(int capacity)
+        {
+            if (capacity < 0)
+                throw new ArgumentOutOfRangeException("capacity");
+
+            canWrite = true;
+
+            internalBuffer = capacity > 0 ? VariableSizedBufferPool.Get(capacity, true) : VariableSizedBufferPool.NoData;
+            this.capacity = internalBuffer.Length;
+
+            expandable = true;
+            allowGetBuffer = true;
+        }
+
+        public BufferPoolMemoryStream(byte[] buffer)
+        {
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+
+            InternalConstructor(buffer, 0, buffer.Length, true, false);
+        }
+
+        public BufferPoolMemoryStream(byte[] buffer, bool writable)
+        {
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+
+            InternalConstructor(buffer, 0, buffer.Length, writable, false);
+        }
+
+        public BufferPoolMemoryStream(byte[] buffer, int index, int count)
+        {
+            InternalConstructor(buffer, index, count, true, false);
+        }
+
+        public BufferPoolMemoryStream(byte[] buffer, int index, int count, bool writable)
+        {
+            InternalConstructor(buffer, index, count, writable, false);
+        }
+
+        public BufferPoolMemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible)
+        {
+            InternalConstructor(buffer, index, count, writable, publiclyVisible);
+        }
+
+        void InternalConstructor(byte[] buffer, int index, int count, bool writable, bool publicallyVisible)
+        {
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+
+            if (index < 0 || count < 0)
+                throw new ArgumentOutOfRangeException("index or count is less than 0.");
+
+            if (buffer.Length - index < count)
+                throw new ArgumentException("index+count",
+                                 "The size of the buffer is less than index + count.");
+
+            canWrite = writable;
+
+            internalBuffer = buffer;
+            capacity = count + index;
+            length = capacity;
+            position = index;
+            initialIndex = index;
+
+            allowGetBuffer = publicallyVisible;
+            expandable = false;
+        }
+
+        void CheckIfClosedThrowDisposed()
+        {
+            if (streamClosed)
+                throw new ObjectDisposedException("MemoryStream");
+        }
+
+        public override bool CanRead
+        {
+            get { return !streamClosed; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return !streamClosed; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return (!streamClosed && canWrite); }
+        }
+
+        public int Capacity
+        {
+            get
+            {
+                CheckIfClosedThrowDisposed();
+                return capacity - initialIndex;
+            }
+
+            set
+            {
+                CheckIfClosedThrowDisposed();
+                if (value == capacity)
+                    return; // LAMENESS: see MemoryStreamTest.ConstructorFive
+
+                if (!expandable)
+                    throw new NotSupportedException("Cannot expand this MemoryStream");
+
+                if (value < 0 || value < length)
+                    throw new ArgumentOutOfRangeException("value",
+                    "New capacity cannot be negative or less than the current capacity " + value + " " + capacity);
+
+                byte[] newBuffer = null;
+                if (value != 0)
+                {
+                    newBuffer = VariableSizedBufferPool.Get(value, true);
+                    Buffer.BlockCopy(internalBuffer, 0, newBuffer, 0, length);
+                }
+
+                dirty_bytes = 0; // discard any dirty area beyond previous length
+                VariableSizedBufferPool.Release(internalBuffer);
+                internalBuffer = newBuffer; // It's null when capacity is set to 0
+                capacity = internalBuffer != null ? internalBuffer.Length : 0;
+            }
+        }
+
+        public override long Length
+        {
+            get
+            {
+                // LAMESPEC: The spec says to throw an IOException if the
+                // stream is closed and an ObjectDisposedException if
+                // "methods were called after the stream was closed".  What
+                // is the difference?
+
+                CheckIfClosedThrowDisposed();
+
+                // This is ok for MemoryStreamTest.ConstructorFive
+                return length - initialIndex;
+            }
+        }
+
+        public override long Position
+        {
+            get
+            {
+                CheckIfClosedThrowDisposed();
+                return position - initialIndex;
+            }
+
+            set
+            {
+                CheckIfClosedThrowDisposed();
+                if (value < 0)
+                    throw new ArgumentOutOfRangeException("value",
+                                "Position cannot be negative");
+
+                if (value > Int32.MaxValue)
+                    throw new ArgumentOutOfRangeException("value",
+                    "Position must be non-negative and less than 2^31 - 1 - origin");
+
+                position = initialIndex + (int)value;
+            }
+        }
+
+        protected override void Dispose (bool disposing)
+        {
+            streamClosed = true;
+            expandable = false;
+            if (internalBuffer != null)
+                VariableSizedBufferPool.Release(internalBuffer);
+            internalBuffer = null;
+        }
+
+        public override void Flush()
+        {
+            // Do nothing
+        }
+
+        public byte[] GetBuffer()
+        {
+            if (!allowGetBuffer)
+                throw new UnauthorizedAccessException();
+
+            return internalBuffer;
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            CheckIfClosedThrowDisposed();
+
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+
+            if (offset < 0 || count < 0)
+                throw new ArgumentOutOfRangeException("offset or count less than zero.");
+
+            if (buffer.Length - offset < count)
+                throw new ArgumentException("offset+count",
+                                  "The size of the buffer is less than offset + count.");
+
+            if (position >= length || count == 0)
+                return 0;
+
+            if (position > length - count)
+                count = length - position;
+
+            Buffer.BlockCopy(internalBuffer, position, buffer, offset, count);
+            position += count;
+            return count;
+        }
+
+        public override int ReadByte()
+        {
+            CheckIfClosedThrowDisposed();
+            if (position >= length)
+                return -1;
+
+            return internalBuffer[position++];
+        }
+
+        public override long Seek(long offset, SeekOrigin loc)
+        {
+            CheckIfClosedThrowDisposed();
+
+            // It's funny that they don't throw this exception for < Int32.MinValue
+            if (offset > (long)Int32.MaxValue)
+                throw new ArgumentOutOfRangeException("Offset out of range. " + offset);
+
+            int refPoint;
+            switch (loc)
+            {
+                case SeekOrigin.Begin:
+                    if (offset < 0)
+                        throw new IOException("Attempted to seek before start of MemoryStream.");
+                    refPoint = initialIndex;
+                    break;
+                case SeekOrigin.Current:
+                    refPoint = position;
+                    break;
+                case SeekOrigin.End:
+                    refPoint = length;
+                    break;
+                default:
+                    throw new ArgumentException("loc", "Invalid SeekOrigin");
+            }
+
+            // LAMESPEC: My goodness, how may LAMESPECs are there in this
+            // class! :)  In the spec for the Position property it's stated
+            // "The position must not be more than one byte beyond the end of the stream."
+            // In the spec for seek it says "Seeking to any location beyond the length of the 
+            // stream is supported."  That's a contradiction i'd say.
+            // I guess seek can go anywhere but if you use position it may get moved back.
+
+            refPoint += (int)offset;
+            if (refPoint < initialIndex)
+                throw new IOException("Attempted to seek before start of MemoryStream.");
+
+            position = refPoint;
+            return position;
+        }
+
+        int CalculateNewCapacity(int minimum)
+        {
+            if (minimum < 256)
+                minimum = 256; // See GetBufferTwo test
+
+            if (minimum < capacity * 2)
+                minimum = capacity * 2;
+
+            if (!UnityEngine.Mathf.IsPowerOfTwo(minimum))
+                minimum = UnityEngine.Mathf.NextPowerOfTwo(minimum);
+
+            return minimum;
+        }
+
+        void Expand(int newSize)
+        {
+            // We don't need to take into account the dirty bytes when incrementing the
+            // Capacity, as changing it will only preserve the valid clear region.
+            if (newSize > capacity)
+                Capacity = CalculateNewCapacity(newSize);
+            else if (dirty_bytes > 0)
+            {
+                Array.Clear(internalBuffer, length, dirty_bytes);
+                dirty_bytes = 0;
+            }
+        }
+
+        public override void SetLength(long value)
+        {
+            if (!expandable && value > capacity)
+                throw new NotSupportedException("Expanding this MemoryStream is not supported");
+
+            CheckIfClosedThrowDisposed();
+
+            if (!canWrite)
+            {
+                throw new NotSupportedException("Cannot write to this MemoryStream");
+            }
+
+            // LAMESPEC: AGAIN! It says to throw this exception if value is
+            // greater than "the maximum length of the MemoryStream".  I haven't
+            // seen anywhere mention what the maximum length of a MemoryStream is and
+            // since we're this far this memory stream is expandable.
+            if (value < 0 || (value + initialIndex) > (long)Int32.MaxValue)
+                throw new ArgumentOutOfRangeException();
+
+            int newSize = (int)value + initialIndex;
+
+            if (newSize > length)
+                Expand(newSize);
+            else if (newSize < length) // Postpone the call to Array.Clear till expand time
+                dirty_bytes += length - newSize;
+
+            length = newSize;
+            if (position > length)
+                position = length;
+        }
+
+        public byte[] ToArray()
+        {
+            return ToArray(false);
+        }
+
+        public byte[] ToArray(bool canBeLarger)
+        {
+            int l = length - initialIndex;
+            byte[] outBuffer = l > 0 ? VariableSizedBufferPool.Get(l, canBeLarger) : VariableSizedBufferPool.NoData;
+
+            if (internalBuffer != null)
+                Buffer.BlockCopy(internalBuffer, initialIndex, outBuffer, 0, l);
+            return outBuffer;
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            CheckIfClosedThrowDisposed();
+
+            if (!canWrite)
+                throw new NotSupportedException("Cannot write to this stream.");
+
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+
+            if (offset < 0 || count < 0)
+                throw new ArgumentOutOfRangeException();
+
+            if (buffer.Length - offset < count)
+                throw new ArgumentException("offset+count",
+                                 "The size of the buffer is less than offset + count.");
+
+            // reordered to avoid possible integer overflow
+            if (position > length - count)
+                Expand(position + count);
+
+            Buffer.BlockCopy(buffer, offset, internalBuffer, position, count);
+            position += count;
+            if (position >= length)
+                length = position;
+        }
+
+        public override void WriteByte(byte value)
+        {
+            CheckIfClosedThrowDisposed();
+            if (!canWrite)
+                throw new NotSupportedException("Cannot write to this stream.");
+
+            if (position >= length)
+            {
+                Expand(position + 1);
+                length = position + 1;
+            }
+
+            internalBuffer[position++] = value;
+        }
+
+        public void WriteTo(Stream stream)
+        {
+            CheckIfClosedThrowDisposed();
+
+            if (stream == null)
+                throw new ArgumentNullException("stream");
+
+            stream.Write(internalBuffer, initialIndex, length - initialIndex);
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/BufferPoolMemoryStream.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ce34f1f3b5c30794b9e26c0922185261
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/CircularBuffer.cs

@@ -0,0 +1,55 @@
+using System;
+
+namespace BestHTTP.Extensions
+{
+    public sealed class CircularBuffer<T>
+    {
+        public int Capacity { get; private set; }
+        public int Count { get; private set; }
+
+        public T this[int idx]
+        {
+            get
+            {
+                int realIdx = (this.startIdx + idx) % this.Capacity;
+
+                return this.buffer[realIdx];
+            }
+
+            set
+            {
+                int realIdx = (this.startIdx + idx) % this.Capacity;
+
+                this.buffer[realIdx] = value;
+            }
+        }
+
+        private T[] buffer;
+        private int startIdx;
+        private int endIdx;
+
+        public CircularBuffer(int capacity)
+        {
+            this.Capacity = capacity;
+        }
+
+        public void Add(T element)
+        {
+            if (this.buffer == null)
+                this.buffer = new T[this.Capacity];
+
+            this.buffer[this.endIdx] = element;
+
+            this.endIdx = (this.endIdx + 1) % this.Capacity;
+            if (this.endIdx == this.startIdx)
+                this.startIdx = (this.startIdx + 1) % this.Capacity;
+
+            this.Count = Math.Min(this.Count + 1, this.Capacity);
+        }
+
+        public void Clear()
+        {
+            this.startIdx = this.endIdx = 0;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/CircularBuffer.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d3e42ed97af74b54fba27235416b1191
+timeCreated: 1508423928
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/Extensions.cs

@@ -0,0 +1,465 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+#if NETFX_CORE
+    using Windows.Security.Cryptography;
+    using Windows.Security.Cryptography.Core;
+    using Windows.Storage.Streams;
+#else
+    using Cryptography = System.Security.Cryptography;
+    using FileStream = System.IO.FileStream;
+#endif
+
+namespace BestHTTP.Extensions
+{
+    public static class Extensions
+    {
+        #region ASCII Encoding (These are required because Windows Phone doesn't supports the Encoding.ASCII class.)
+
+        /// <summary>
+        /// On WP8 platform there are no ASCII encoding.
+        /// </summary>
+        public static string AsciiToString(this byte[] bytes)
+        {
+            StringBuilder sb = new StringBuilder(bytes.Length);
+            foreach (byte b in bytes)
+                sb.Append(b <= 0x7f ? (char)b : '?');
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// On WP8 platform there are no ASCII encoding.
+        /// </summary>
+        public static byte[] GetASCIIBytes(this string str)
+        {
+            byte[] result = VariableSizedBufferPool.Get(str.Length, false);
+            for (int i = 0; i < str.Length; ++i)
+            {
+                char ch = str[i];
+                result[i] = (byte)((ch < (char)0x80) ? ch : '?');
+            }
+
+            return result;
+        }
+
+        public static void SendAsASCII(this BinaryWriter stream, string str)
+        {
+            for (int i = 0; i < str.Length; ++i)
+            {
+                char ch = str[i];
+
+                stream.Write((byte)((ch < (char)0x80) ? ch : '?'));
+            }
+        }
+
+        #endregion
+
+        #region FileSystem WriteLine function support
+
+        public static void WriteLine(this Stream fs)
+        {
+            fs.Write(HTTPRequest.EOL, 0, 2);
+        }
+
+        public static void WriteLine(this Stream fs, string line)
+        {
+            var buff = line.GetASCIIBytes();
+            fs.Write(buff, 0, buff.Length);
+            fs.WriteLine();
+            VariableSizedBufferPool.Release(buff);
+        }
+
+        public static void WriteLine(this Stream fs, string format, params object[] values)
+        {
+            var buff = string.Format(format, values).GetASCIIBytes();
+            fs.Write(buff, 0, buff.Length);
+            fs.WriteLine();
+            VariableSizedBufferPool.Release(buff);
+        }
+
+        #endregion
+
+        #region Other Extensions
+
+        public static string GetRequestPathAndQueryURL(this Uri uri)
+        {
+            string requestPathAndQuery = uri.GetComponents(UriComponents.PathAndQuery, UriFormat.UriEscaped);
+
+            // http://forum.unity3d.com/threads/best-http-released.200006/page-26#post-2723250
+            if (string.IsNullOrEmpty(requestPathAndQuery))
+                requestPathAndQuery = "/";
+
+            return requestPathAndQuery;
+        }
+
+        public static string[] FindOption(this string str, string option)
+        {
+            //s-maxage=2678400, must-revalidate, max-age=0
+            string[] options = str.ToLower().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            option = option.ToLower();
+
+            for (int i = 0; i < options.Length; ++i)
+                if (options[i].Contains(option))
+                    return options[i].Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
+
+            return null;
+        }
+
+        public static void WriteArray(this Stream stream, byte[] array)
+        {
+            stream.Write(array, 0, array.Length);
+        }
+
+        /// <summary>
+        /// Returns true if the Uri's host is a valid IPv4 or IPv6 address.
+        /// </summary>
+        public static bool IsHostIsAnIPAddress(this Uri uri)
+        {
+            if (uri == null)
+                return false;
+
+            return IsIpV4AddressValid(uri.Host) || IsIpV6AddressValid(uri.Host);
+        }
+
+        // Original idea from: https://www.code4copy.com/csharp/c-validate-ip-address-string/
+        // Working regex: https://www.regular-expressions.info/ip.html
+        private static readonly System.Text.RegularExpressions.Regex validIpV4AddressRegex = new System.Text.RegularExpressions.Regex("\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
+
+        /// <summary>
+        /// Validates an IPv4 address.
+        /// </summary>
+        public static bool IsIpV4AddressValid(string address)
+        {
+            if (!string.IsNullOrEmpty(address))
+                return validIpV4AddressRegex.IsMatch(address.Trim());
+
+            return false;
+        }
+
+        /// <summary>
+        /// Validates an IPv6 address.
+        /// </summary>
+        public static bool IsIpV6AddressValid(string address)
+        {
+#if !NETFX_CORE
+            if (!string.IsNullOrEmpty(address))
+            {
+                System.Net.IPAddress ip;
+                if (System.Net.IPAddress.TryParse(address, out ip))
+                  return ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6;
+            }
+#endif
+            return false;
+        }
+
+        #endregion
+
+        #region String Conversions
+
+        public static int ToInt32(this string str, int defaultValue = default(int))
+        {
+            if (str == null)
+                return defaultValue;
+
+            try
+            {
+                return int.Parse(str);
+            }
+            catch
+            {
+                return defaultValue;
+            }
+        }
+
+        public static long ToInt64(this string str, long defaultValue = default(long))
+        {
+            if (str == null)
+                return defaultValue;
+
+            try
+            {
+                return long.Parse(str);
+            }
+            catch
+            {
+                return defaultValue;
+            }
+        }
+
+        public static DateTime ToDateTime(this string str, DateTime defaultValue = default(DateTime))
+        {
+            if (str == null)
+                return defaultValue;
+
+            try
+            {
+                DateTime.TryParse(str, out defaultValue);
+                return defaultValue.ToUniversalTime();
+            }
+            catch
+            {
+                return defaultValue;
+            }
+        }
+
+        public static string ToStrOrEmpty(this string str)
+        {
+            if (str == null)
+                return String.Empty;
+
+            return str;
+        }
+
+        #endregion
+
+        #region MD5 Hashing
+
+        public static string CalculateMD5Hash(this string input)
+        {
+            byte[] ascii = input.GetASCIIBytes();
+            var hash = ascii.CalculateMD5Hash();
+            VariableSizedBufferPool.Release(ascii);
+            return hash;
+        }
+
+        public static string CalculateMD5Hash(this byte[] input)
+        {
+#if NETFX_CORE
+            var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
+            IBuffer buff = CryptographicBuffer.CreateFromByteArray(input);
+            var hashed = alg.HashData(buff);
+            var res = CryptographicBuffer.EncodeToHexString(hashed);
+            return res;
+#else
+            using (var md5 = Cryptography.MD5.Create()) {
+                var hash = md5.ComputeHash(input);
+                var sb = new StringBuilder(hash.Length);
+                for (int i = 0; i < hash.Length; ++i)
+                    sb.Append(hash[i].ToString("x2"));
+                VariableSizedBufferPool.Release(hash);
+                return sb.ToString();
+            }
+#endif
+        }
+
+        #endregion
+
+        #region Efficient String Parsing Helpers
+
+        internal static string Read(this string str, ref int pos, char block, bool needResult = true)
+        {
+            return str.Read(ref pos, (ch) => ch != block, needResult);
+        }
+
+        internal static string Read(this string str, ref int pos, Func<char, bool> block, bool needResult = true)
+        {
+            if (pos >= str.Length)
+                return string.Empty;
+
+            str.SkipWhiteSpace(ref pos);
+
+            int startPos = pos;
+
+            while (pos < str.Length && block(str[pos]))
+                pos++;
+
+            string result = needResult ? str.Substring(startPos, pos - startPos) : null;
+
+            // set position to the next char
+            pos++;
+
+            return result;
+        }
+
+        internal static string ReadPossibleQuotedText(this string str, ref int pos)
+        {
+            string result = string.Empty;
+            if (str == null)
+                return result;
+
+            // It's a quoted text?
+            if (str[pos] == '\"')
+            {
+                // Skip the starting quote
+                str.Read(ref pos, '\"', false);
+
+                // Read the text until the ending quote
+                result = str.Read(ref pos, '\"');
+
+                // Next option
+                str.Read(ref pos, ',', false);
+            }
+            else
+                // It's not a quoted text, so we will read until the next option
+                result = str.Read(ref pos, (ch) => ch != ',' && ch != ';');
+
+            return result;
+        }
+
+        internal static void SkipWhiteSpace(this string str, ref int pos)
+        {
+            if (pos >= str.Length)
+                return;
+
+            while (pos < str.Length && char.IsWhiteSpace(str[pos]))
+                pos++;
+        }
+
+        internal static string TrimAndLower(this string str)
+        {
+            if (str == null)
+                return null;
+
+            char[] buffer = new char[str.Length];
+            int length = 0;
+
+            for (int i = 0; i < str.Length; ++i)
+            {
+                char ch = str[i];
+                if (!char.IsWhiteSpace(ch) && !char.IsControl(ch))
+                    buffer[length++] = char.ToLowerInvariant(ch);
+            }
+
+            return new string(buffer, 0, length);
+        }
+
+        internal static char? Peek(this string str, int pos)
+        {
+            if (pos < 0 || pos >= str.Length)
+                return null;
+
+            return str[pos];
+        }
+
+        #endregion
+
+        #region Specialized String Parsers
+
+        //public, max-age=2592000
+        internal static List<HeaderValue> ParseOptionalHeader(this string str)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            if (str == null)
+                return result;
+
+            int idx = 0;
+
+            // process the rest of the text
+            while (idx < str.Length)
+            {
+                // Read key
+                string key = str.Read(ref idx, (ch) => ch != '=' && ch != ',').TrimAndLower();
+                HeaderValue qp = new HeaderValue(key);
+
+                if (str[idx - 1] == '=')
+                    qp.Value = str.ReadPossibleQuotedText(ref idx);
+
+                result.Add(qp);
+            }
+
+            return result;
+        }
+
+        //deflate, gzip, x-gzip, identity, *;q=0
+        internal static List<HeaderValue> ParseQualityParams(this string str)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            if (str == null)
+                return result;
+
+            int idx = 0;
+            while (idx < str.Length)
+            {
+                string key = str.Read(ref idx, (ch) => ch != ',' && ch != ';').TrimAndLower();
+
+                HeaderValue qp = new HeaderValue(key);
+
+                if (str[idx - 1] == ';')
+                {
+                    str.Read(ref idx, '=', false);
+                    qp.Value = str.Read(ref idx, ',');
+                }
+
+                result.Add(qp);
+            }
+
+            return result;
+        }
+
+        #endregion
+
+        #region Buffer Filling
+
+        /// <summary>
+        /// Will fill the entire buffer from the stream. Will throw an exception when the underlying stream is closed.
+        /// </summary>
+        public static void ReadBuffer(this Stream stream, byte[] buffer)
+        {
+            int count = 0;
+
+            do
+            {
+                int read = stream.Read(buffer, count, buffer.Length - count);
+
+                if (read <= 0)
+                    throw ExceptionHelper.ServerClosedTCPStream();
+
+                count += read;
+            } while (count < buffer.Length);
+        }
+
+        public static void ReadBuffer(this Stream stream, byte[] buffer, int length)
+        {
+            int count = 0;
+
+            do
+            {
+                int read = stream.Read(buffer, count, length - count);
+
+                if (read <= 0)
+                    throw ExceptionHelper.ServerClosedTCPStream();
+
+                count += read;
+            } while (count < length);
+        }
+
+        #endregion
+
+        #region BufferPoolMemoryStream
+
+        public static void WriteString(this BufferPoolMemoryStream ms, string str)
+        {
+            var byteCount = Encoding.UTF8.GetByteCount(str);
+            byte[] buffer = VariableSizedBufferPool.Get(byteCount, true);
+            Encoding.UTF8.GetBytes(str, 0, str.Length, buffer, 0);
+            ms.Write(buffer, 0, byteCount);
+            VariableSizedBufferPool.Release(buffer);
+        }
+
+        public static void WriteLine(this BufferPoolMemoryStream ms)
+        {
+            ms.Write(HTTPRequest.EOL, 0, HTTPRequest.EOL.Length);
+        }
+
+        public static void WriteLine(this BufferPoolMemoryStream ms, string str)
+        {
+            ms.WriteString(str);
+            ms.Write(HTTPRequest.EOL, 0, HTTPRequest.EOL.Length);
+        }
+
+        #endregion
+    }
+
+    public static class ExceptionHelper
+    {
+        public static Exception ServerClosedTCPStream()
+        {
+            return new Exception("TCP Stream closed unexpectedly by the remote server");
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/Extensions.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3ed17defed57cb64697daf74b5bb5873
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/Future.cs

@@ -0,0 +1,402 @@
+// Based on https://github.com/nickgravelyn/UnityToolbag/blob/master/Future/Future.cs
+/*
+ * The MIT License (MIT)
+
+Copyright (c) 2017, Nick Gravelyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ * */
+
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Futures
+{
+    /// <summary>
+    /// Describes the state of a future.
+    /// </summary>
+    public enum FutureState
+    {
+        /// <summary>
+        /// The future hasn't begun to resolve a value.
+        /// </summary>
+        Pending,
+
+        /// <summary>
+        /// The future is working on resolving a value.
+        /// </summary>
+        Processing,
+
+        /// <summary>
+        /// The future has a value ready.
+        /// </summary>
+        Success,
+
+        /// <summary>
+        /// The future failed to resolve a value.
+        /// </summary>
+        Error
+    }
+
+    /// <summary>
+    /// Defines the interface of an object that can be used to track a future value.
+    /// </summary>
+    /// <typeparam name="T">The type of object being retrieved.</typeparam>
+    public interface IFuture<T>
+    {
+        /// <summary>
+        /// Gets the state of the future.
+        /// </summary>
+        FutureState state { get; }
+
+        /// <summary>
+        /// Gets the value if the State is Success.
+        /// </summary>
+        T value { get; }
+
+        /// <summary>
+        /// Gets the failure exception if the State is Error.
+        /// </summary>
+        Exception error { get; }
+
+        /// <summary>
+        /// Adds a new callback to invoke when an intermediate result is known.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        IFuture<T> OnItem(FutureValueCallback<T> callback);
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future value is retrieved successfully.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        IFuture<T> OnSuccess(FutureValueCallback<T> callback);
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future has an error.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        IFuture<T> OnError(FutureErrorCallback callback);
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future value is retrieved successfully or has an error.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        IFuture<T> OnComplete(FutureCallback<T> callback);
+    }
+
+    /// <summary>
+    /// Defines the signature for callbacks used by the future.
+    /// </summary>
+    /// <param name="future">The future.</param>
+    public delegate void FutureCallback<T>(IFuture<T> future);
+
+    public delegate void FutureValueCallback<T>(T value);
+    public delegate void FutureErrorCallback(Exception error);
+
+    /// <summary>
+    /// An implementation of <see cref="IFuture{T}"/> that can be used internally by methods that return futures.
+    /// </summary>
+    /// <remarks>
+    /// Methods should always return the <see cref="IFuture{T}"/> interface when calling code requests a future.
+    /// This class is intended to be constructed internally in the method to provide a simple implementation of
+    /// the interface. By returning the interface instead of the class it ensures the implementation can change
+    /// later on if requirements change, without affecting the calling code.
+    /// </remarks>
+    /// <typeparam name="T">The type of object being retrieved.</typeparam>
+    public class Future<T> : IFuture<T>
+    {
+        private volatile FutureState _state;
+        private T _value;
+        private Exception _error;
+        private Func<T> _processFunc;
+
+        private readonly List<FutureValueCallback<T>> _itemCallbacks = new List<FutureValueCallback<T>>();
+        private readonly List<FutureValueCallback<T>> _successCallbacks = new List<FutureValueCallback<T>>();
+        private readonly List<FutureErrorCallback> _errorCallbacks = new List<FutureErrorCallback>();
+        private readonly List<FutureCallback<T>> _complationCallbacks = new List<FutureCallback<T>>();
+
+        /// <summary>
+        /// Gets the state of the future.
+        /// </summary>
+        public FutureState state { get { return _state; } }
+
+        /// <summary>
+        /// Gets the value if the State is Success.
+        /// </summary>
+        public T value
+        {
+            get
+            {
+                if (_state != FutureState.Success && _state != FutureState.Processing)
+                {
+                    throw new InvalidOperationException("value is not available unless state is Success or Processing.");
+                }
+
+                return _value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the failure exception if the State is Error.
+        /// </summary>
+        public Exception error
+        {
+            get
+            {
+                if (_state != FutureState.Error)
+                {
+                    throw new InvalidOperationException("error is not available unless state is Error.");
+                }
+
+                return _error;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Future{T}"/> class.
+        /// </summary>
+        public Future()
+        {
+            _state = FutureState.Pending;
+        }
+
+        public IFuture<T> OnItem(FutureValueCallback<T> callback)
+        {
+            if (_state < FutureState.Success && !_itemCallbacks.Contains(callback))
+              _itemCallbacks.Add(callback);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future value is retrieved successfully.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        public IFuture<T> OnSuccess(FutureValueCallback<T> callback)
+        {
+            if (_state == FutureState.Success)
+            {
+                callback(this.value);
+            }
+            else if (_state != FutureState.Error && !_successCallbacks.Contains(callback))
+            {
+                _successCallbacks.Add(callback);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future has an error.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        public IFuture<T> OnError(FutureErrorCallback callback)
+        {
+            if (_state == FutureState.Error)
+            {
+                callback(this.error);
+            }
+            else if (_state != FutureState.Success && !_errorCallbacks.Contains(callback))
+            {
+                _errorCallbacks.Add(callback);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a new callback to invoke if the future value is retrieved successfully or has an error.
+        /// </summary>
+        /// <param name="callback">The callback to invoke.</param>
+        /// <returns>The future so additional calls can be chained together.</returns>
+        public IFuture<T> OnComplete(FutureCallback<T> callback)
+        {
+            if (_state == FutureState.Success || _state == FutureState.Error)
+            {
+                callback(this);
+            }
+            else
+            {
+                if (!_complationCallbacks.Contains(callback))
+                    _complationCallbacks.Add(callback);
+            }
+
+            return this;
+        }
+
+#pragma warning disable 1998
+
+        /// <summary>
+        /// Begins running a given function on a background thread to resolve the future's value, as long
+        /// as it is still in the Pending state.
+        /// </summary>
+        /// <param name="func">The function that will retrieve the desired value.</param>
+        public IFuture<T> Process(Func<T> func)
+        {
+            if (_state != FutureState.Pending)
+            {
+                throw new InvalidOperationException("Cannot process a future that isn't in the Pending state.");
+            }
+
+            BeginProcess();
+            _processFunc = func;
+
+#if NETFX_CORE
+#pragma warning disable 4014
+            Windows.System.Threading.ThreadPool.RunAsync(ThreadFunc);
+#pragma warning restore 4014
+#else
+            System.Threading.ThreadPool.QueueUserWorkItem(ThreadFunc);
+#endif
+
+            return this;
+        }
+
+        private
+#if NETFX_CORE
+            async
+#endif
+            void ThreadFunc(object param)
+        {
+            try
+            {
+                // Directly call the Impl version to avoid the state validation of the public method
+                AssignImpl(_processFunc());
+            }
+            catch (Exception e)
+            {
+                // Directly call the Impl version to avoid the state validation of the public method
+                FailImpl(e);
+            }
+            finally
+            {
+                _processFunc = null;
+            }
+        }
+
+#pragma warning restore 1998
+
+        /// <summary>
+        /// Allows manually assigning a value to a future, as long as it is still in the pending state.
+        /// </summary>
+        /// <remarks>
+        /// There are times where you may not need to do background processing for a value. For example,
+        /// you may have a cache of values and can just hand one out. In those cases you still want to
+        /// return a future for the method signature, but can just call this method to fill in the future.
+        /// </remarks>
+        /// <param name="value">The value to assign the future.</param>
+        public void Assign(T value)
+        {
+            if (_state != FutureState.Pending && _state != FutureState.Processing)
+            {
+                throw new InvalidOperationException("Cannot assign a value to a future that isn't in the Pending or Processing state.");
+            }
+
+            AssignImpl(value);
+        }
+
+        public void BeginProcess(T initialItem = default(T))
+        {
+            _state = FutureState.Processing;
+            _value = initialItem;
+        }
+
+        public void AssignItem(T value)
+        {
+            _value = value;
+            _error = null;
+
+            foreach (var callback in _itemCallbacks)
+                callback(this.value);
+        }
+
+        /// <summary>
+        /// Allows manually failing a future, as long as it is still in the pending state.
+        /// </summary>
+        /// <remarks>
+        /// As with the Assign method, there are times where you may know a future value is a failure without
+        /// doing any background work. In those cases you can simply fail the future manually and return it.
+        /// </remarks>
+        /// <param name="error">The exception to use to fail the future.</param>
+        public void Fail(Exception error)
+        {
+            if (_state != FutureState.Pending && _state != FutureState.Processing)
+            {
+                throw new InvalidOperationException("Cannot fail future that isn't in the Pending or Processing state.");
+            }
+
+            FailImpl(error);
+        }
+
+        private void AssignImpl(T value)
+        {
+            _value = value;
+            _error = null;
+            _state = FutureState.Success;
+
+            FlushSuccessCallbacks();
+        }
+
+        private void FailImpl(Exception error)
+        {
+            _value = default(T);
+            _error = error;
+            _state = FutureState.Error;
+
+            FlushErrorCallbacks();
+        }
+
+        private void FlushSuccessCallbacks()
+        {
+            foreach (var callback in _successCallbacks)
+                callback(this.value);
+
+            FlushComplationCallbacks();
+        }
+
+        private void FlushErrorCallbacks()
+        {
+            foreach (var callback in _errorCallbacks)
+                callback(this.error);
+
+            FlushComplationCallbacks();
+        }
+
+        private void FlushComplationCallbacks()
+        {
+            foreach (var callback in _complationCallbacks)
+                callback(this);
+            ClearCallbacks();
+        }
+
+        private void ClearCallbacks()
+        {
+            _itemCallbacks.Clear();
+            _successCallbacks.Clear();
+            _errorCallbacks.Clear();
+            _complationCallbacks.Clear();
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/Future.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: a9009e6f5e86bd5459d443846e42be9e
+timeCreated: 1515175777
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeaderParser.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// Will parse a comma-separeted header value
+    /// </summary>
+    public sealed class HeaderParser : KeyValuePairList
+    {
+        public HeaderParser(string headerStr)
+        {
+            base.Values = Parse(headerStr);
+        }
+
+        private List<HeaderValue> Parse(string headerStr)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            int pos = 0;
+
+            try
+            {
+                while (pos < headerStr.Length)
+                {
+                    HeaderValue current = new HeaderValue();
+
+                    current.Parse(headerStr, ref pos);
+
+                    result.Add(current);
+                }
+            }
+            catch(System.Exception ex)
+            {
+                HTTPManager.Logger.Exception("HeaderParser - Parse", headerStr, ex);
+            }
+
+            return result;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeaderParser.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 40ea771765c2ae549abc4c264e500b76
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeaderValue.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// Used in string parsers. Its Value is optional.
+    /// </summary>
+    public sealed class HeaderValue
+    {
+        #region Public Properties
+
+        public string Key { get; set; }
+        public string Value { get; set; }
+        public List<HeaderValue> Options { get; set; }
+
+        public bool HasValue { get { return !string.IsNullOrEmpty(this.Value); } }
+
+        #endregion
+
+        #region Constructors
+
+        public HeaderValue()
+        { }
+
+        public HeaderValue(string key)
+        {
+            this.Key = key;
+        }
+
+        #endregion
+
+        #region Public Helper Functions
+
+        public void Parse(string headerStr, ref int pos)
+        {
+            ParseImplementation(headerStr, ref pos, true);
+        }
+
+        public bool TryGetOption(string key, out HeaderValue option)
+        {
+            option = null;
+
+            if (Options == null || Options.Count == 0)
+                return false;
+
+            for (int i = 0; i < Options.Count; ++i)
+                if (String.Equals(Options[i].Key, key, StringComparison.OrdinalIgnoreCase))
+                {
+                    option = Options[i];
+                    return true;
+                }
+
+            return false;
+        }
+
+        #endregion
+
+        #region Private Helper Functions
+
+        private void ParseImplementation(string headerStr, ref int pos, bool isOptionIsAnOption)
+        {
+            string key = headerStr.Read(ref pos, (ch) => ch != ';' && ch != '=' && ch != ',', true);
+            this.Key = key;
+
+            char? skippedChar = headerStr.Peek(pos - 1);
+            bool isValue = skippedChar == '=';
+            bool isOption = isOptionIsAnOption && skippedChar == ';';
+
+            while (skippedChar != null && isValue || isOption)
+            {
+
+                if (isValue)
+                {
+                    string value = headerStr.ReadPossibleQuotedText(ref pos);
+                    this.Value = value;
+                }
+                else if (isOption)
+                {
+                    HeaderValue option = new HeaderValue();
+                    option.ParseImplementation(headerStr, ref pos, false);
+
+                    if (this.Options == null)
+                        this.Options = new List<HeaderValue>();
+
+                    this.Options.Add(option);
+                }
+
+                if (!isOptionIsAnOption)
+                    return;
+
+                skippedChar = headerStr.Peek(pos - 1);
+                isValue = skippedChar == '=';
+                isOption = isOptionIsAnOption && skippedChar == ';';
+            }
+        }
+
+        #endregion
+
+        #region Overrides
+
+        public override string ToString()
+        {
+            if (!string.IsNullOrEmpty(Value))
+                return String.Concat(Key, '=', Value);
+            else
+                return Key;
+        }
+
+        #endregion
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeaderValue.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 1465d4183951bf64dad0047b7c6e7243
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeartbeatManager.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Extensions
+{
+    public interface IHeartbeat
+    {
+        void OnHeartbeatUpdate(TimeSpan dif);
+    }
+
+    /// <summary>
+    /// A manager class that can handle subscribing and unsubscribeing in the same update.
+    /// </summary>
+    public sealed class HeartbeatManager
+    {
+        private List<IHeartbeat> Heartbeats = new List<IHeartbeat>();
+        private IHeartbeat[] UpdateArray;
+        private DateTime LastUpdate = DateTime.MinValue;
+
+        public void Subscribe(IHeartbeat heartbeat)
+        {
+            lock (Heartbeats)
+            {
+                if (!Heartbeats.Contains(heartbeat))
+                    Heartbeats.Add(heartbeat);
+            }
+        }
+
+        public void Unsubscribe(IHeartbeat heartbeat)
+        {
+            lock (Heartbeats)
+                Heartbeats.Remove(heartbeat);
+        }
+
+        public void Update()
+        {
+            if (LastUpdate == DateTime.MinValue)
+                LastUpdate = DateTime.UtcNow;
+            else
+            {
+                TimeSpan dif = DateTime.UtcNow - LastUpdate;
+                LastUpdate = DateTime.UtcNow;
+                
+                int count = 0;
+
+                lock (Heartbeats)
+                {
+                    if (UpdateArray == null || UpdateArray.Length < Heartbeats.Count)
+                        Array.Resize(ref UpdateArray, Heartbeats.Count);
+
+                    Heartbeats.CopyTo(0, UpdateArray, 0, Heartbeats.Count);
+
+                    count = Heartbeats.Count;
+                }
+
+                for (int i = 0; i < count; ++i)
+                {
+                    try
+                    {
+                        UpdateArray[i].OnHeartbeatUpdate(dif);
+                    }
+                    catch
+                    { }
+                }
+            }
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/HeartbeatManager.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6c610eeb580ec8e4c90789edb631cc76
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/KeyValuePairList.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// Base class for specialized parsers
+    /// </summary>
+    public class KeyValuePairList
+    {
+        public List<HeaderValue> Values { get; protected set; }
+
+        public bool TryGet(string valueKeyName, out HeaderValue @param)
+        {
+            @param = null;
+            for (int i = 0; i < Values.Count; ++i)
+                if (string.CompareOrdinal(Values[i].Key, valueKeyName) == 0)
+                {
+                    @param = Values[i];
+                    return true;
+                }
+            return false;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/KeyValuePairList.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 834cc34ef3418894589ef2e8389ff8c0
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/ReadOnlyBufferedStream.cs

@@ -0,0 +1,177 @@
+using System;
+using System.IO;
+
+namespace BestHTTP.Extensions
+{
+    public class ReadOnlyBufferedStream : Stream
+    {
+        public bool CheckForDataAvailability { get; set; }
+        Stream stream;
+        public const int READBUFFER = 8192;
+        byte[] buf;
+        int available = 0;
+        int pos = 0;
+
+        public ReadOnlyBufferedStream(Stream nstream)
+        {
+            stream = nstream;
+            buf = VariableSizedBufferPool.Get(READBUFFER, true);
+        }
+
+        public override int Read(byte[] buffer, int offset, int size)
+        {
+            if (size <= available)
+            {
+                Array.Copy(buf, pos, buffer, offset, size);
+                available -= size;
+                pos += size;
+                return size;
+            }
+            else
+            {
+                int readcount = 0;
+                if (available > 0)
+                {
+                    Array.Copy(buf, pos, buffer, offset, available);
+                    offset += available;
+                    readcount += available;
+                    available = 0;
+                    pos = 0;
+                }
+
+                while (true)
+                {
+                    try
+                    {
+                        available = stream.Read(buf, 0, buf.Length);
+                        pos = 0;
+                    }
+                    catch (Exception ex)
+                    {
+                        if (readcount > 0)
+                        {
+                            return readcount;
+                        }
+
+                        throw (ex);
+                    }
+                    if (available < 1)
+                    {
+                        if (readcount > 0)
+                        {
+                            return readcount;
+                        }
+
+                        return 0;
+                    }
+                    else
+                    {
+                        int toread = size - readcount;
+                        if (toread <= available)
+                        {
+                            Array.Copy(buf, pos, buffer, offset, toread);
+                            available -= toread;
+                            pos += toread;
+                            readcount += toread;
+                            return readcount;
+                        }
+                        else
+                        {
+                            Array.Copy(buf, pos, buffer, offset, available);
+                            offset += available;
+                            readcount += available;
+                            pos = 0;
+                            available = 0;
+                        }
+                    }
+                }
+            }
+        }
+
+        public override int ReadByte()
+        {
+            if (available > 0)
+            {
+                available -= 1;
+                pos += 1;
+                return buf[pos - 1];
+            }
+            else
+            {
+                try
+                {
+                    available = stream.Read(buf, 0, buf.Length);
+                    pos = 0;
+                }
+                catch
+                {
+                    return -1;
+                }
+                if (available < 1)
+                {
+                    return -1;
+                }
+                else
+                {
+                    available -= 1;
+                    pos += 1;
+                    return buf[pos - 1];
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (buf != null)
+                VariableSizedBufferPool.Release(buf);
+
+            buf = null;
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override bool CanWrite
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        public override void Flush()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/ReadOnlyBufferedStream.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e6b9a4ff6813b4f4b9f2ffa453c3fccc
+timeCreated: 1543513046
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/VariableSizedBufferPool.cs

@@ -0,0 +1,386 @@
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// Private data struct that contains the size <-> byte arrays mapping. 
+    /// </summary>
+    struct BufferStore
+    {
+        /// <summary>
+        /// Size/length of the arrays stored in the buffers.
+        /// </summary>
+        public readonly long Size;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public List<BufferDesc> buffers;
+
+        public BufferStore(long size)
+        {
+            this.Size = size;
+            this.buffers = new List<BufferDesc>();
+        }
+
+        /// <summary>
+        /// Create a new store with its first byte[] to store.
+        /// </summary>
+        public BufferStore(long size, byte[] buffer)
+            : this(size)
+        {
+            this.buffers.Add(new BufferDesc(buffer));
+        }
+    }
+
+    struct BufferDesc
+    {
+        public static readonly BufferDesc Empty = new BufferDesc(null);
+
+        /// <summary>
+        /// The actual reference to the stored byte array.
+        /// </summary>
+        public byte[] buffer;
+
+        /// <summary>
+        /// When the buffer is put back to the pool. Based on this value the pool will calculate the age of the buffer.
+        /// </summary>
+        public DateTime released;
+
+        public BufferDesc(byte[] buff)
+        {
+            this.buffer = buff;
+            this.released = DateTime.UtcNow;
+        }
+    }
+
+    public static class VariableSizedBufferPool
+    {
+        public static readonly byte[] NoData = new byte[0];
+
+        /// <summary>
+        /// Setting this property to false the pooling mechanism can be disabled.
+        /// </summary>
+        public static bool IsEnabled {
+            get { return _isEnabled; }
+            set
+            {
+                _isEnabled = value;
+
+                // When set to non-enabled remove all stored entries
+                if (!_isEnabled)
+                    Clear();
+            }
+        }
+        public static volatile bool _isEnabled = true;
+
+        /// <summary>
+        /// Buffer entries that released back to the pool and older than this value are moved when next maintenance is triggered.
+        /// </summary>
+        public static TimeSpan RemoveOlderThan = TimeSpan.FromSeconds(30);
+
+        /// <summary>
+        /// How often pool maintenance must run.
+        /// </summary>
+        public static TimeSpan RunMaintenanceEvery = TimeSpan.FromSeconds(10);
+
+        /// <summary>
+        /// Minumum buffer size that the plugin will allocate when the requested size is smaller than this value, and canBeLarger is set to true.
+        /// </summary>
+        public static long MinBufferSize = 256;
+
+        /// <summary>
+        /// Maximum size of a buffer that the plugin will store.
+        /// </summary>
+        public static long MaxBufferSize = long.MaxValue;
+
+        /// <summary>
+        /// Maximum accomulated size of the stored buffers.
+        /// </summary>
+        public static long MaxPoolSize = 10 * 1024 * 1024;
+
+        /// <summary>
+        /// Whether to remove empty buffer stores from the free list.
+        /// </summary>
+        public static bool RemoveEmptyLists = true;
+
+        /// <summary>
+        /// If it set to true and a byte[] is released more than once it will log out an error.
+        /// </summary>
+        public static bool IsDoubleReleaseCheckEnabled = false;
+
+        // It must be sorted by buffer size!
+        private static List<BufferStore> FreeBuffers = new List<BufferStore>();
+        private static DateTime lastMaintenance = DateTime.MinValue;
+
+        // Statistics
+        private static volatile int PoolSize = 0;
+        private static volatile uint GetBuffers = 0;
+        private static volatile uint ReleaseBuffers = 0;
+        private static System.Text.StringBuilder statiscticsBuilder = new System.Text.StringBuilder();
+
+        static VariableSizedBufferPool()
+        {
+#if UNITY_EDITOR
+            IsDoubleReleaseCheckEnabled = true;
+#else
+            IsDoubleReleaseCheckEnabled = false;
+#endif
+        }
+
+        /// <summary>
+        /// Get byte[] from the pool. If canBeLarge is true, the returned buffer might be larger than the requested size.
+        /// </summary>
+        public static byte[] Get(long size, bool canBeLarger)
+        {
+            if (!_isEnabled)
+                return new byte[size];
+
+            // Return a fix reference for 0 length requests. Any resize call (even Array.Resize) creates a new reference
+            //  so we are safe to expose it to multiple callers.
+            if (size == 0)
+                return VariableSizedBufferPool.NoData;
+
+            lock (FreeBuffers)
+            {
+                if (FreeBuffers.Count == 0)
+                    return new byte[size];
+
+                BufferDesc bufferDesc = FindFreeBuffer(size, canBeLarger);
+                if (bufferDesc.buffer == null)
+                {
+                    if (canBeLarger)
+                    {
+                        if (size < MinBufferSize)
+                            size = MinBufferSize;
+                        else if (!IsPowerOfTwo(size))
+                            size = NextPowerOf2(size);
+                    }
+
+                    return new byte[size];
+                }
+                else
+                    GetBuffers++;
+
+                PoolSize -= bufferDesc.buffer.Length;
+
+                return bufferDesc.buffer;
+            }
+        }
+
+        /// <summary>
+        /// Release a list of byte arrays back to the pool
+        /// </summary>
+        public static void Release(List<byte[]> buffers)
+        {
+            if (!_isEnabled || buffers == null || buffers.Count == 0)
+                return;
+
+            for (int i = 0; i < buffers.Count; ++i)
+                Release(buffers[i]);
+        }
+
+        /// <summary>
+        /// Release back a byte array to the pool.
+        /// </summary>
+        public static void Release(byte[] buffer)
+        {
+            if (!_isEnabled || buffer == null)
+                return;
+
+            int size = buffer.Length;
+
+            if (size == 0 || size > MaxBufferSize)
+                return;
+
+            lock (FreeBuffers)
+            {
+                if (PoolSize + size > MaxPoolSize)
+                    return;
+                PoolSize += size;
+
+                ReleaseBuffers++;
+
+                AddFreeBuffer(buffer);
+            }
+        }
+
+        /// <summary>
+        /// Resize a byte array. It will release the old one to the pool, and the new one is from the pool too.
+        /// </summary>
+        public static byte[] Resize(ref byte[] buffer, int newSize, bool canBeLarger)
+        {
+            if (!_isEnabled)
+            {
+                Array.Resize<byte>(ref buffer, newSize);
+                return buffer;
+            }
+
+            byte[] newBuf = VariableSizedBufferPool.Get(newSize, canBeLarger);
+            Array.Copy(buffer, 0, newBuf, 0, Math.Min(newBuf.Length, buffer.Length));
+            VariableSizedBufferPool.Release(buffer);
+            return buffer = newBuf;
+        }
+
+        /// <summary>
+        /// Get textual statistics about the buffer pool.
+        /// </summary>
+        public static string GetStatistics(bool showEmptyBuffers = true)
+        {
+            lock (FreeBuffers)
+            {
+                statiscticsBuilder.Length = 0;
+                statiscticsBuilder.AppendFormat("Pooled array reused count: {0:N0}\n", GetBuffers);
+                statiscticsBuilder.AppendFormat("Release call count: {0:N0}\n", ReleaseBuffers);
+                statiscticsBuilder.AppendFormat("PoolSize: {0:N0}\n", PoolSize);
+                statiscticsBuilder.AppendFormat("Buffers: {0}\n", FreeBuffers.Count);
+
+                for (int i = 0; i < FreeBuffers.Count; ++i)
+                {
+                    BufferStore store = FreeBuffers[i];
+                    List<BufferDesc> buffers = store.buffers;
+
+                    if (showEmptyBuffers || buffers.Count > 0)
+                        statiscticsBuilder.AppendFormat("- Size: {0:N0} Count: {1:N0}\n", store.Size, buffers.Count);
+                }
+
+                return statiscticsBuilder.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Remove all stored entries instantly.
+        /// </summary>
+        public static void Clear()
+        {
+            lock (FreeBuffers)
+            {
+                FreeBuffers.Clear();
+                PoolSize = 0;
+            }
+        }
+
+        /// <summary>
+        /// Internal function called by the plugin the remove old, non-used buffers.
+        /// </summary>
+        internal static void Maintain()
+        {
+            DateTime now = DateTime.UtcNow;
+            if (!_isEnabled || lastMaintenance + RunMaintenanceEvery > now)
+                return;
+            lastMaintenance = now;
+
+            DateTime olderThan = now - RemoveOlderThan;
+            lock (FreeBuffers)
+            {
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Information("VariableSizedBufferPool", "Before Maintain: " + GetStatistics());
+
+                for (int i = 0; i < FreeBuffers.Count; ++i)
+                {
+                    BufferStore store = FreeBuffers[i];
+                    List<BufferDesc> buffers = store.buffers;
+
+                    for (int cv = buffers.Count - 1; cv >= 0; cv--)
+                    {
+                        BufferDesc desc = buffers[cv];
+
+                        if (desc.released < olderThan)
+                        {
+                            // buffers stores available buffers ascending by age. So, when we find an old enough, we can
+                            //  delete all entries in the [0..cv] range.
+
+                            int removeCount = cv + 1;
+                            buffers.RemoveRange(0, removeCount);
+                            PoolSize -= (int)(removeCount * store.Size);
+                            break;
+                        }
+                    }
+
+                    if (RemoveEmptyLists && buffers.Count == 0)
+                        FreeBuffers.RemoveAt(i--);
+                }
+
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Information("VariableSizedBufferPool", "After Maintain: " + GetStatistics());
+            }
+        }
+
+#region Private helper functions
+
+        private static bool IsPowerOfTwo(long x)
+        {
+            return (x & (x - 1)) == 0;
+        }
+
+        private static long NextPowerOf2(long x)
+        {
+            long pow = 1;
+            while (pow <= x)
+                pow *= 2;
+            return pow;
+        }
+
+        private static BufferDesc FindFreeBuffer(long size, bool canBeLarger)
+        {
+            for (int i = 0; i < FreeBuffers.Count; ++i)
+            {
+                BufferStore store = FreeBuffers[i];
+
+                if (store.buffers.Count > 0 && (store.Size == size || (canBeLarger && store.Size > size)))
+                {
+                    // Getting the last one has two desired effect:
+                    //  1.) RemoveAt should be quicker as it don't have to move all the remaining entries
+                    //  2.) Old, non-used buffers will age. Getting a buffer and putting it back will not keep buffers fresh.
+
+                    BufferDesc lastFree = store.buffers[store.buffers.Count - 1];
+                    store.buffers.RemoveAt(store.buffers.Count - 1);
+
+                    return lastFree;
+                }
+            }
+
+            return BufferDesc.Empty;
+        }
+
+        private static void AddFreeBuffer(byte[] buffer)
+        {
+            int bufferLength = buffer.Length;
+            for (int i = 0; i < FreeBuffers.Count; ++i)
+            {
+                BufferStore store = FreeBuffers[i];
+
+                if (store.Size == bufferLength)
+                {
+                    // We highly assume here that every buffer will be released only once.
+                    //  Checking for double-release would mean that we have to do another O(n) operation, where n is the
+                    //  count of the store's elements.
+
+                    if (IsDoubleReleaseCheckEnabled)
+                        for (int cv = 0; cv < store.buffers.Count; ++cv)
+                            if (store.buffers[cv].buffer == buffer)
+                            {
+                                HTTPManager.Logger.Error("VariableSizedBufferPool", "Buffer already added to the pool!");
+                                return;
+                            }
+
+                    store.buffers.Add(new BufferDesc(buffer));
+                    return;
+                }
+
+                if (store.Size > bufferLength)
+                {
+                    FreeBuffers.Insert(i, new BufferStore(bufferLength, buffer));
+                    return;
+                }
+            }
+
+            // When we reach this point, there's no same sized or larger BufferStore present, so we have to add a new one
+            //  to the endo of our list.
+            FreeBuffers.Add(new BufferStore(bufferLength, buffer));
+        }
+
+#endregion
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/VariableSizedBufferPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f00c45d747a5e2c46ac0957c9a17523c
+timeCreated: 1543513047
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/WWWAuthenticateHeaderParser.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// Used for parsing WWW-Authenticate headers:
+    /// Digest realm="my realm", nonce="4664b327a2963503ba58bbe13ad672c0", qop=auth, opaque="f7e38bdc1c66fce214f9019ffe43117c"
+    /// </summary>
+    public sealed class WWWAuthenticateHeaderParser : KeyValuePairList
+    {
+        public WWWAuthenticateHeaderParser(string headerValue)
+        {
+            Values = ParseQuotedHeader(headerValue);
+        }
+
+        private List<HeaderValue> ParseQuotedHeader(string str)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            if (str != null)
+            {
+
+                int idx = 0;
+
+                // Read Type (Basic|Digest)
+                string type = str.Read(ref idx, (ch) => !char.IsWhiteSpace(ch) && !char.IsControl(ch)).TrimAndLower();
+                result.Add(new HeaderValue(type));
+
+                // process the rest of the text
+                while (idx < str.Length)
+                {
+                    // Read key
+                    string key = str.Read(ref idx, '=').TrimAndLower();
+                    HeaderValue qp = new HeaderValue(key);
+
+                    // Skip any white space
+                    str.SkipWhiteSpace(ref idx);
+
+                    qp.Value = str.ReadPossibleQuotedText(ref idx);
+
+                    result.Add(qp);
+                }
+            }
+            return result;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/WWWAuthenticateHeaderParser.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4cba91161fe643c419eedafefdf1f959
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/WriteOnlyBufferedStream.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+
+namespace BestHTTP.Extensions
+{
+    /// <summary>
+    /// A custom buffer stream implementation that will not close the underlying stream.
+    /// </summary>
+    public sealed class WriteOnlyBufferedStream : Stream
+    {
+        public override bool CanRead { get { return false; } }
+        public override bool CanSeek { get { return false; } }
+        public override bool CanWrite { get { return true; } }
+        public override long Length { get { return this.buffer.Length; } }
+
+        public override long Position { get { return this._position; } set { throw new NotImplementedException("Position set"); } }
+        private int _position;
+
+        private byte[] buffer;
+        private Stream stream;
+
+        public WriteOnlyBufferedStream(Stream stream, int bufferSize)
+        {
+            this.stream = stream;
+
+            this.buffer = VariableSizedBufferPool.Get(bufferSize, true);
+            this._position = 0;
+        }
+
+        public override void Flush()
+        {
+            if (this._position > 0)
+            {
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Information("BufferStream", string.Format("Flushing {0:N0} bytes", this._position));
+
+                this.stream.Write(this.buffer, 0, this._position);
+                this._position = 0;
+            }
+        }
+
+        public override void Write(byte[] bufferFrom, int offset, int count)
+        {
+            while (count > 0)
+            {
+                int writeCount = Math.Min(count, this.buffer.Length - this._position);
+                Array.Copy(bufferFrom, offset, this.buffer, this._position, writeCount);
+            
+                this._position += writeCount;
+                offset += writeCount;
+                count -= writeCount;
+            
+                if (this._position == this.buffer.Length)
+                    this.Flush();
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return 0;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return 0;
+        }
+
+        public override void SetLength(long value) { }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+
+            if (this.buffer != null)
+                VariableSizedBufferPool.Release(this.buffer);
+            this.buffer = null;
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Extensions/WriteOnlyBufferedStream.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2df120a767773ee478acf872b86ae326
+timeCreated: 1530027551
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ec6485add003b9a469a5298c20d9498c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFieldData.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Forms
+{
+    /// <summary>
+    /// This class represents a HTTP Form's field.
+    /// </summary>
+    public class HTTPFieldData
+    {
+        /// <summary>
+        /// The form's field.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Filename of the field. Optional.
+        /// </summary>
+        public string FileName { get; set; }
+
+        /// <summary>
+        /// Mime-type of the field. Optional
+        /// </summary>
+        public string MimeType { get; set; }
+
+        /// <summary>
+        /// Encoding of the data. Optional
+        /// </summary>
+        public Encoding Encoding { get; set; }
+
+        /// <summary>
+        /// The field's textual data.
+        /// </summary>
+        public string Text { get; set; }
+
+        /// <summary>
+        /// The field's binary data.
+        /// </summary>
+        public byte[] Binary { get; set; }
+
+        /// <summary>
+        /// Will return with the binary data, or if it's not present the textual data will be decoded to binary.
+        /// </summary>
+        public byte[] Payload
+        {
+            get
+            {
+                if (Binary != null)
+                    return Binary;
+
+                if (Encoding == null)
+                    Encoding = Encoding.UTF8;
+
+                return Binary = Encoding.GetBytes(Text);
+            }
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFieldData.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bdf9d0d59653fa8418a86f22360ff91e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFormBase.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Forms
+{
+    /// <summary>
+    /// Base class of a concrete implementation. Don't use it to create a form, use instead one of the already wrote implementation(HTTPMultiPartForm, HTTPUrlEncodedForm), or create a new one by inheriting from this base class.
+    /// </summary>
+    public class HTTPFormBase
+    {
+        const int LongLength = 256;
+
+        #region Properties
+
+        /// <summary>
+        /// A list that holds the form's fields.
+        /// </summary>
+        public List<HTTPFieldData> Fields { get; set; }
+
+        /// <summary>
+        /// Returns true if the Fields has no element.
+        /// </summary>
+        public bool IsEmpty { get { return Fields == null || Fields.Count == 0; } }
+
+        /// <summary>
+        /// True if new fields has been added to our list.
+        /// </summary>
+        public bool IsChanged { get; protected set; }
+
+        /// <summary>
+        /// True if there are at least one form-field with binary data.
+        /// </summary>
+        public bool HasBinary { get; protected set; }
+
+        /// <summary>
+        /// True if there are at least one form-field with a long textual data.
+        /// </summary>
+        public bool HasLongValue { get; protected set; }
+
+        #endregion
+
+        #region Field Management
+
+        public void AddBinaryData(string fieldName, byte[] content)
+        {
+            AddBinaryData(fieldName, content, null, null);
+        }
+
+        public void AddBinaryData(string fieldName, byte[] content, string fileName)
+        {
+            AddBinaryData(fieldName, content, fileName, null);
+        }
+
+        public void AddBinaryData(string fieldName, byte[] content, string fileName, string mimeType)
+        {
+            if (Fields == null)
+                Fields = new List<HTTPFieldData>();
+
+            HTTPFieldData field = new HTTPFieldData();
+            field.Name = fieldName;
+
+            if (fileName == null)
+                field.FileName = fieldName + ".dat";
+            else
+                field.FileName = fileName;
+
+            if (mimeType == null)
+                field.MimeType = "application/octet-stream";
+            else
+                field.MimeType = mimeType;
+
+            field.Binary = content;
+
+            Fields.Add(field);
+
+            HasBinary = IsChanged = true;
+        }
+
+        public void AddField(string fieldName, string value)
+        {
+            AddField(fieldName, value, System.Text.Encoding.UTF8);
+        }
+
+        public void AddField(string fieldName, string value, System.Text.Encoding e)
+        {
+            if (Fields == null)
+                Fields = new List<HTTPFieldData>();
+
+            HTTPFieldData field = new HTTPFieldData();
+            field.Name = fieldName;
+            field.FileName = null;
+            if (e != null)
+                field.MimeType = "text/plain; charset=" + e.WebName;
+            field.Text = value;
+            field.Encoding = e;
+
+            Fields.Add(field);
+
+            IsChanged = true;
+
+            HasLongValue |= value.Length > LongLength;
+        }
+
+        #endregion
+
+        #region Virtual Functions
+
+        /// <summary>
+        /// It should 'clone' all the data from the given HTTPFormBase object.
+        /// Called after the form-implementation created.
+        /// </summary>
+        public virtual void CopyFrom(HTTPFormBase fields)
+        {
+            this.Fields = new List<HTTPFieldData>(fields.Fields);
+            this.IsChanged = true;
+
+            this.HasBinary = fields.HasBinary;
+            this.HasLongValue = fields.HasLongValue;
+        }
+
+        /// <summary>
+        /// Prepares the request to sending a form. It should set only the headers.
+        /// </summary>
+        public virtual void PrepareRequest(HTTPRequest request)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Prepares and returns with the form's raw data.
+        /// </summary>
+        public virtual byte[] GetData()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFormBase.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7d275ec92441f18449bffc98e08d44e8
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFormUsage.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Forms
+{
+    public enum HTTPFormUsage
+    {
+        /// <summary>
+        /// The plugin will try to choose the best form sending method.
+        /// </summary>
+        Automatic,
+
+        /// <summary>
+        /// The plugin will use the Url-Encoded form sending.
+        /// </summary>
+        UrlEncoded,
+
+        /// <summary>
+        /// The plugin will use the Multipart form sending.
+        /// </summary>
+        Multipart,
+
+        /// <summary>
+        /// Using this type of form, the plugin will send the data converted to a JSon string.
+        /// </summary>
+        RawJSon,
+
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/HTTPFormUsage.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: fc8643409dcf53d4db0bf0f654ad8500
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2056708e1386fa042a4c70cbda7d8ea2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/HTTPMultiPartForm.cs

@@ -0,0 +1,79 @@
+using BestHTTP.Extensions;
+
+namespace BestHTTP.Forms
+{
+    /// <summary>
+    /// A HTTP Form implementation to send textual and binary values.
+    /// </summary>
+    public sealed class HTTPMultiPartForm : HTTPFormBase
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// A random boundary generated in the constructor.
+        /// </summary>
+        private string Boundary;
+
+        /// <summary>
+        ///
+        /// </summary>
+        private byte[] CachedData;
+
+        #endregion
+
+        public HTTPMultiPartForm()
+        {
+            this.Boundary = "BestHTTP_HTTPMultiPartForm_" + this.GetHashCode().ToString("X");
+        }
+
+        #region IHTTPForm Implementation
+
+        public override void PrepareRequest(HTTPRequest request)
+        {
+            // Set up Content-Type header for the request
+            request.SetHeader("Content-Type", "multipart/form-data; boundary=\"" + Boundary + "\"");
+        }
+
+        public override byte[] GetData()
+        {
+            if (CachedData != null)
+                return CachedData;
+
+            using (var ms = new Extensions.BufferPoolMemoryStream())
+            {
+                for (int i = 0; i < Fields.Count; ++i)
+                {
+                    HTTPFieldData field = Fields[i];
+
+                    // Set the boundary
+                    ms.WriteLine("--" + Boundary);
+
+                    // Set up Content-Disposition header to our form with the name
+                    ms.WriteLine("Content-Disposition: form-data; name=\"" + field.Name + "\"" + (!string.IsNullOrEmpty(field.FileName) ? "; filename=\"" + field.FileName + "\"" : string.Empty));
+
+                    // Set up Content-Type head for the form.
+                    if (!string.IsNullOrEmpty(field.MimeType))
+                        ms.WriteLine("Content-Type: " + field.MimeType);
+
+                    ms.WriteLine("Content-Length: " + field.Payload.Length.ToString());
+                    ms.WriteLine();
+
+                    // Write the actual data to the MemoryStream
+                    ms.Write(field.Payload, 0, field.Payload.Length);
+
+                    ms.Write(HTTPRequest.EOL, 0, HTTPRequest.EOL.Length);
+                }
+
+                // Write out the trailing boundary
+                ms.WriteLine("--" + Boundary + "--");
+
+                IsChanged = false;
+
+                // Set the RawData of our request
+                return CachedData = ms.ToArray();
+            }
+        }
+
+        #endregion
+    };
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/HTTPMultiPartForm.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 5f9390c7b6f72b845805363b01dfbba9
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/HTTPUrlEncodedForm.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Forms
+{
+    /// <summary>
+    /// A HTTP Form implementation to send textual values.
+    /// </summary>
+    public sealed class HTTPUrlEncodedForm : HTTPFormBase
+    {
+        private const int EscapeTreshold = 256;
+
+        private byte[] CachedData;
+
+        public override void PrepareRequest(HTTPRequest request)
+        {
+            request.SetHeader("Content-Type", "application/x-www-form-urlencoded");
+        }
+
+        public override byte[] GetData()
+        {
+            if (CachedData != null && !IsChanged)
+                return CachedData;
+
+            StringBuilder sb = new StringBuilder();
+
+            // Create a "field1=value1&field2=value2" formatted string
+            for (int i = 0; i < Fields.Count; ++i)
+            {
+                var field = Fields[i];
+
+                if (i > 0)
+                    sb.Append("&");
+
+                sb.Append(EscapeString(field.Name));
+                sb.Append("=");
+
+                if (!string.IsNullOrEmpty(field.Text) || field.Binary == null)
+                    sb.Append(EscapeString(field.Text));
+                else
+                    // If forced to this form type with binary data, we will create a string from the binary data first and encode this string.
+                    sb.Append(EscapeString(Encoding.UTF8.GetString(field.Binary, 0, field.Binary.Length)));
+            }
+
+            IsChanged = false;
+            return CachedData = Encoding.UTF8.GetBytes(sb.ToString());
+        }
+
+        public static string EscapeString(string originalString)
+        {
+            if (originalString.Length < EscapeTreshold)
+                return Uri.EscapeDataString(originalString);
+            else
+            {
+                int loops = originalString.Length / EscapeTreshold;
+                StringBuilder sb = new StringBuilder(loops);
+
+                for (int i = 0; i <= loops; i++)
+                   sb.Append(i < loops ?
+                                Uri.EscapeDataString(originalString.Substring(EscapeTreshold * i, EscapeTreshold)) :
+                                Uri.EscapeDataString(originalString.Substring(EscapeTreshold * i)));
+                return sb.ToString();
+            }
+        }
+
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/HTTPUrlEncodedForm.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 023a00e6d3a980b4babe8c70a7d00088
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/RawJSonForm.cs

@@ -0,0 +1,36 @@
+// Contributed by Matt Senne from conjoinedcats.com
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BestHTTP.Forms
+{
+    public sealed class RawJsonForm : HTTPFormBase
+    {
+        private byte[] CachedData;
+
+        /// <summary>
+        /// Prepares the request to sending a form. It should set only the headers.
+        /// </summary>
+        public override void PrepareRequest(HTTPRequest request)
+        {
+            request.SetHeader("Content-Type", "application/json");
+        }
+
+        /// <summary>
+        /// Prepares and returns with the form's raw data.
+        /// </summary>
+        public override byte[] GetData()
+        {
+            if (CachedData != null && !IsChanged)
+                return CachedData;
+
+            Dictionary<string, string> dict = Fields.ToDictionary(x => x.Name, x => x.Text);
+            string json = JSON.Json.Encode(dict);
+
+            IsChanged = false;
+            return CachedData = Encoding.UTF8.GetBytes(json);
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/Forms/Implementations/RawJSonForm.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 23946220d212ad04aaff31e9eccd4018
+timeCreated: 1493280601
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPConnection.cs

@@ -0,0 +1,780 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using System.Text;
+using System.Threading;
+using BestHTTP.Extensions;
+using BestHTTP.Authentication;
+
+#if !NETFX_CORE || UNITY_EDITOR
+    using System.Net.Security;
+#endif
+
+#if !BESTHTTP_DISABLE_CACHING
+    using BestHTTP.Caching;
+#endif
+
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+    using BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls;
+    using Org.BouncyCastle.Crypto.Tls2;
+#endif
+
+#if !BESTHTTP_DISABLE_COOKIES
+    using BestHTTP.Cookies;
+#endif
+
+#if NETFX_CORE || BUILD_FOR_WP8
+    using System.Threading.Tasks;
+    using Windows.Networking.Sockets;
+
+    using TcpClient = BestHTTP.PlatformSupport.TcpClient.WinRT.TcpClient;
+
+    //Disable CD4014: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.
+    #pragma warning disable 4014
+#else
+    using TcpClient = BestHTTP.PlatformSupport.TcpClient.General.TcpClient;
+#endif
+
+namespace BestHTTP
+{
+    /// <summary>
+    /// https://tools.ietf.org/html/draft-thomson-hybi-http-timeout-03
+    /// Test servers: http://tools.ietf.org/ http://nginx.org/
+    /// </summary>
+    internal sealed class KeepAliveHeader
+    {
+        /// <summary>
+        /// A host sets the value of the "timeout" parameter to the time that the host will allow an idle connection to remain open before it is closed. A connection is idle if no data is sent or received by a host.
+        /// </summary>
+        public TimeSpan TimeOut { get; private set; }
+
+        /// <summary>
+        /// The "max" parameter has been used to indicate the maximum number of requests that would be made on the connection.This parameter is deprecated.Any limit on requests can be enforced by sending "Connection: close" and closing the connection.
+        /// </summary>
+        public int MaxRequests { get; private set; }
+
+        public void Parse(List<string> headerValues)
+        {
+            HeaderParser parser = new HeaderParser(headerValues[0]);
+            HeaderValue value;
+            if (parser.TryGet("timeout", out value) && value.HasValue)
+            {
+                int intValue = 0;
+                if (int.TryParse(value.Value, out intValue))
+                    this.TimeOut = TimeSpan.FromSeconds(intValue);
+                else
+                    this.TimeOut = TimeSpan.MaxValue;
+            }
+
+            if (parser.TryGet("max", out value) && value.HasValue)
+            {
+                int intValue = 0;
+                if (int.TryParse("max", out intValue))
+                    this.MaxRequests = intValue;
+                else
+                    this.MaxRequests = int.MaxValue;
+            }
+        }
+    }
+
+    internal enum RetryCauses
+    {
+        /// <summary>
+        /// The request processed without any special case.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// If the server closed the connection while we sending a request we should reconnect and send the request again. But we will try it once.
+        /// </summary>
+        Reconnect,
+
+        /// <summary>
+        /// We need an another try with Authorization header set.
+        /// </summary>
+        Authenticate,
+
+#if !BESTHTTP_DISABLE_PROXY
+        /// <summary>
+        /// The proxy needs authentication.
+        /// </summary>
+        ProxyAuthenticate,
+#endif
+    }
+
+    /// <summary>
+    /// Represents and manages a connection to a server.
+    /// </summary>
+    internal sealed class HTTPConnection : ConnectionBase
+    {
+        public override bool IsRemovable
+        {
+            get
+            {
+                // Plugin's own connection pooling
+                if (base.IsRemovable)
+                    return true;
+
+                // Overridden keep-alive timeout by a Keep-Alive header
+                if (IsFree && KeepAlive != null && (DateTime.UtcNow - base.LastProcessTime) >= KeepAlive.TimeOut)
+                    return true;
+
+                return false;
+            }
+        }
+
+        #region Private Properties
+
+        private TcpClient Client;
+        private Stream Stream;
+        private KeepAliveHeader KeepAlive;
+
+        #endregion
+
+        internal HTTPConnection(string serverAddress)
+            :base(serverAddress)
+        {}
+
+        #region Request Processing Implementation
+
+        protected override
+#if NETFX_CORE
+            async
+#endif
+            void ThreadFunc(object param)
+        {
+            bool alreadyReconnected = false;
+            bool redirected = false;
+
+            RetryCauses cause = RetryCauses.None;
+
+            try
+            {
+#if !BESTHTTP_DISABLE_CACHING
+                // Try load the full response from an already saved cache entity. If the response
+                if (TryLoadAllFromCache())
+                    return;
+#endif
+
+                if (Client != null && !Client.IsConnected())
+                    Close();
+
+                do // of while (reconnect)
+                {
+                    if (cause == RetryCauses.Reconnect)
+                    {
+                        Close();
+#if NETFX_CORE
+                        await Task.Delay(100);
+#else
+                        Thread.Sleep(100);
+#endif
+                    }
+
+                    LastProcessedUri = CurrentRequest.CurrentUri;
+
+                    cause = RetryCauses.None;
+
+                    // Connect to the server
+                    Connect();
+
+                    if (State == HTTPConnectionStates.AbortRequested)
+                        throw new Exception("AbortRequested");
+
+                    #if !BESTHTTP_DISABLE_CACHING
+                    // Setup cache control headers before we send out the request
+                    if (!CurrentRequest.DisableCache)
+                        HTTPCacheService.SetHeaders(CurrentRequest);
+                    #endif
+
+                    // Write the request to the stream
+                    // sentRequest will be true if the request sent out successfully(no SocketException), so we can try read the response
+                    bool sentRequest = false;
+                    try
+                    {
+#if !NETFX_CORE
+                         Client.NoDelay = CurrentRequest.TryToMinimizeTCPLatency;
+#endif
+                         CurrentRequest.SendOutTo(Stream);
+
+                         sentRequest = true;
+                    }
+                    catch (Exception ex)
+                    {
+                        Close();
+
+                        if (State == HTTPConnectionStates.TimedOut ||
+                            State == HTTPConnectionStates.AbortRequested)
+                            throw new Exception("AbortRequested");
+
+                        // We will try again only once
+                        if (!alreadyReconnected && !CurrentRequest.DisableRetry)
+                        {
+                            alreadyReconnected = true;
+                            cause = RetryCauses.Reconnect;
+                        }
+                        else // rethrow exception
+                            throw ex;
+                    }
+
+                    // If sending out the request succeeded, we will try read the response.
+                    if (sentRequest)
+                    {
+                        bool received = Receive();
+
+                        if (State == HTTPConnectionStates.TimedOut ||
+                            State == HTTPConnectionStates.AbortRequested)
+                            throw new Exception("AbortRequested");
+
+                        if (!received && !alreadyReconnected && !CurrentRequest.DisableRetry)
+                        {
+                            alreadyReconnected = true;
+                            cause = RetryCauses.Reconnect;
+                        }
+
+                        if (CurrentRequest.Response != null)
+                        {
+#if !BESTHTTP_DISABLE_COOKIES
+                            // Try to store cookies before we do anything else, as we may remove the response deleting the cookies as well.
+                            if (CurrentRequest.IsCookiesEnabled)
+                            {
+                                CookieJar.Set(CurrentRequest.Response);
+                                CookieJar.Persist();
+                            }
+#endif
+
+                            switch (CurrentRequest.Response.StatusCode)
+                            {
+                                // Not authorized
+                                // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2
+                                case 401:
+                                    {
+                                        string authHeader = DigestStore.FindBest(CurrentRequest.Response.GetHeaderValues("www-authenticate"));
+                                        if (!string.IsNullOrEmpty(authHeader))
+                                        {
+                                            var digest = DigestStore.GetOrCreate(CurrentRequest.CurrentUri);
+                                            digest.ParseChallange(authHeader);
+
+                                            if (CurrentRequest.Credentials != null && digest.IsUriProtected(CurrentRequest.CurrentUri) && (!CurrentRequest.HasHeader("Authorization") || digest.Stale))
+                                                cause = RetryCauses.Authenticate;
+                                        }
+
+                                        goto default;
+                                    }
+
+#if !BESTHTTP_DISABLE_PROXY
+                                // Proxy authentication required
+                                // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.8
+                                case 407:
+                                    {
+                                        if (CurrentRequest.HasProxy)
+                                        {
+                                            string authHeader = DigestStore.FindBest(CurrentRequest.Response.GetHeaderValues("proxy-authenticate"));
+                                            if (!string.IsNullOrEmpty(authHeader))
+                                            {
+                                                var digest = DigestStore.GetOrCreate(CurrentRequest.Proxy.Address);
+                                                digest.ParseChallange(authHeader);
+
+                                                if (CurrentRequest.Proxy.Credentials != null && digest.IsUriProtected(CurrentRequest.Proxy.Address) && (!CurrentRequest.HasHeader("Proxy-Authorization") || digest.Stale))
+                                                    cause = RetryCauses.ProxyAuthenticate;
+                                            }
+                                        }
+
+                                        goto default;
+                                    }
+#endif
+
+                                // Redirected
+                                case 301: // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.2
+                                case 302: // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.3
+                                case 307: // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.8
+                                case 308: // http://tools.ietf.org/html/rfc7238
+                                    {
+                                        if (CurrentRequest.RedirectCount >= CurrentRequest.MaxRedirects)
+                                            goto default;
+                                        CurrentRequest.RedirectCount++;
+
+                                        string location = CurrentRequest.Response.GetFirstHeaderValue("location");
+                                        if (!string.IsNullOrEmpty(location))
+                                        {
+                                            Uri redirectUri = GetRedirectUri(location);
+
+                                            if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                                                HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - Redirected to Location: '{1}' redirectUri: '{1}'", this.CurrentRequest.CurrentUri.ToString(), location, redirectUri));
+
+                                            // Let the user to take some control over the redirection
+                                            if (!CurrentRequest.CallOnBeforeRedirection(redirectUri))
+                                            {
+                                                HTTPManager.Logger.Information("HTTPConnection", "OnBeforeRedirection returned False");
+                                                goto default;
+                                            }
+
+                                            // Remove the previously set Host header.
+                                            CurrentRequest.RemoveHeader("Host");
+
+                                            // Set the Referer header to the last Uri.
+                                            CurrentRequest.SetHeader("Referer", CurrentRequest.CurrentUri.ToString());
+
+                                            // Set the new Uri, the CurrentUri will return this while the IsRedirected property is true
+                                            CurrentRequest.RedirectUri = redirectUri;
+
+                                            // Discard the redirect response, we don't need it any more
+                                            CurrentRequest.Response = null;
+
+                                            redirected = CurrentRequest.IsRedirected = true;
+                                        }
+                                        else
+                                            #if !NETFX_CORE
+                                                throw new MissingFieldException(string.Format("Got redirect status({0}) without 'location' header!", CurrentRequest.Response.StatusCode.ToString()));
+                                            #else
+                                                throw new Exception(string.Format("Got redirect status({0}) without 'location' header!", CurrentRequest.Response.StatusCode.ToString()));
+                                            #endif
+
+                                        goto default;
+                                    }
+
+
+                                default:
+#if !BESTHTTP_DISABLE_CACHING
+                                    TryStoreInCache();
+#endif
+                                    break;
+                            }
+                          
+                            // Closing the stream is done manually
+                            if (CurrentRequest.Response == null || !CurrentRequest.Response.IsClosedManually) {
+                                // If we have a response and the server telling us that it closed the connection after the message sent to us, then
+                                //  we will close the connection too.
+                                bool closeByServer = CurrentRequest.Response == null || CurrentRequest.Response.HasHeaderWithValue("connection", "close");
+                                bool closeByClient = !CurrentRequest.IsKeepAlive;
+
+                                if (closeByServer || closeByClient)
+                                    Close();
+                                else if (CurrentRequest.Response != null)
+                                {
+                                    var keepAliveheaderValues = CurrentRequest.Response.GetHeaderValues("keep-alive");
+                                    if (keepAliveheaderValues != null && keepAliveheaderValues.Count > 0)
+                                    {
+                                        if (KeepAlive == null)
+                                            KeepAlive = new KeepAliveHeader();
+                                        KeepAlive.Parse(keepAliveheaderValues);
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                } while (cause != RetryCauses.None);
+            }
+            catch(TimeoutException e)
+            {
+                CurrentRequest.Response = null;
+                CurrentRequest.Exception = e;
+                CurrentRequest.State = HTTPRequestStates.ConnectionTimedOut;
+
+                Close();
+            }
+            catch (Exception e)
+            {
+                if (CurrentRequest != null)
+                {
+#if !BESTHTTP_DISABLE_CACHING
+                    if (CurrentRequest.UseStreaming)
+                        HTTPCacheService.DeleteEntity(CurrentRequest.CurrentUri);
+#endif
+
+                    // Something gone bad, Response must be null!
+                    CurrentRequest.Response = null;
+
+                    switch (State)
+                    {
+                        case HTTPConnectionStates.Closed:
+                        case HTTPConnectionStates.AbortRequested:
+                            CurrentRequest.State = HTTPRequestStates.Aborted;
+                            break;
+                        case HTTPConnectionStates.TimedOut:
+                            CurrentRequest.State = HTTPRequestStates.TimedOut;
+                            break;
+                        default:
+                            CurrentRequest.Exception = e;
+                            CurrentRequest.State = HTTPRequestStates.Error;
+                            break;
+                    }
+                }
+
+                Close();
+            }
+            finally
+            {
+                if (CurrentRequest != null)
+                {
+                    // Avoid state changes. While we are in this block changing the connection's State, on Unity's main thread
+                    //  the HTTPManager's OnUpdate will check the connections's State and call functions that can change the inner state of
+                    //  the object. (Like setting the CurrentRequest to null in function Recycle() causing a NullRef exception)
+                    lock (HTTPManager.Locker)
+                    {
+                        if (CurrentRequest != null && CurrentRequest.Response != null && CurrentRequest.Response.IsUpgraded)
+                            State = HTTPConnectionStates.Upgraded;
+                        else
+                            State = redirected ? HTTPConnectionStates.Redirected : (Client == null ? HTTPConnectionStates.Closed : HTTPConnectionStates.WaitForRecycle);
+
+                        // Change the request's state only when the whole processing finished
+                        if (CurrentRequest.State == HTTPRequestStates.Processing && (State == HTTPConnectionStates.Closed || State == HTTPConnectionStates.WaitForRecycle))
+                        {
+                            if (CurrentRequest.Response != null)
+                                CurrentRequest.State = HTTPRequestStates.Finished;
+                            else
+                            {
+                                CurrentRequest.Exception = new Exception(string.Format("Remote server closed the connection before sending response header! Previous request state: {0}. Connection state: {1}",
+                                        CurrentRequest.State.ToString(),
+                                        State.ToString()));
+                                CurrentRequest.State = HTTPRequestStates.Error;
+                            }
+                        }
+
+                        if (CurrentRequest.State == HTTPRequestStates.ConnectionTimedOut)
+                            State = HTTPConnectionStates.Closed;
+
+                        LastProcessTime = DateTime.UtcNow;
+
+                        if (OnConnectionRecycled != null)
+                            RecycleNow();
+                    }
+                }
+            }
+        }
+
+        private void Connect()
+        {
+            Uri uri =
+#if !BESTHTTP_DISABLE_PROXY
+                CurrentRequest.HasProxy ? CurrentRequest.Proxy.Address :
+#endif
+                CurrentRequest.CurrentUri;
+
+            #region TCP Connection
+
+            if (Client == null)
+                Client = new TcpClient();
+
+            if (!Client.Connected)
+            {
+                Client.ConnectTimeout = CurrentRequest.ConnectTimeout;
+
+#if NETFX_CORE
+                Client.UseHTTPSProtocol =
+                #if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+                    !CurrentRequest.UseAlternateSSL &&
+                #endif
+                    HTTPProtocolFactory.IsSecureProtocol(uri);
+#endif
+
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Verbose("HTTPConnection", string.Format("'{0}' - Connecting to {1}:{2}", this.CurrentRequest.CurrentUri.ToString(), uri.Host, uri.Port.ToString()));
+
+#if !NETFX_CORE && (!UNITY_WEBGL || UNITY_EDITOR)
+                Client.SendBufferSize = HTTPManager.SendBufferSize;
+                Client.ReceiveBufferSize = HTTPManager.ReceiveBufferSize;
+
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Verbose("HTTPConnection", string.Format("'{0}' - Buffer sizes - Send: {1} Receive: {2} Blocking: {3}", this.CurrentRequest.CurrentUri.ToString(), Client.SendBufferSize.ToString(), Client.ReceiveBufferSize.ToString(), Client.Client.Blocking.ToString()));
+#endif
+
+                Client.Connect(uri.Host, uri.Port);
+
+                if (HTTPManager.Logger.Level <= Logger.Loglevels.Information)
+                    HTTPManager.Logger.Information("HTTPConnection", "Connected to " + uri.Host + ":" + uri.Port.ToString());
+            }
+            else if (HTTPManager.Logger.Level <= Logger.Loglevels.Information)
+                    HTTPManager.Logger.Information("HTTPConnection", "Already connected to " + uri.Host + ":" + uri.Port.ToString());
+
+            #endregion
+
+            StartTime = DateTime.UtcNow;
+
+            if (Stream == null)
+            {
+                bool isSecure = HTTPProtocolFactory.IsSecureProtocol(CurrentRequest.CurrentUri);
+
+                Stream = Client.GetStream();
+                /*if (Stream.CanTimeout)
+                    Stream.ReadTimeout = Stream.WriteTimeout = (int)CurrentRequest.Timeout.TotalMilliseconds;*/
+
+
+#if !BESTHTTP_DISABLE_PROXY
+                if (CurrentRequest.Proxy != null)
+                    CurrentRequest.Proxy.Connect(this.Stream, this.CurrentRequest);
+#endif
+
+                // We have to use CurrentRequest.CurrentUri here, because uri can be a proxy uri with a different protocol
+                if (isSecure)
+                {
+                    // Under the new experimental runtime there's a bug in the Socket.Send implementation that can cause a 
+                    //  connection when the TLS protocol is used.
+#if !NETFX_CORE && (!UNITY_WEBGL || UNITY_EDITOR) && NET_4_6
+                    //Client.SendBufferSize = 0;
+#endif
+
+#region SSL Upgrade
+
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+                    if (CurrentRequest.UseAlternateSSL)
+                    {
+                        var handler = new TlsClientProtocol(Client.GetStream(), new BestHTTP.SecureProtocol.Org.BouncyCastle.Security.SecureRandom());
+
+                        // http://tools.ietf.org/html/rfc3546#section-3.1
+                        // -It is RECOMMENDED that clients include an extension of type "server_name" in the client hello whenever they locate a server by a supported name type.
+                        // -Literal IPv4 and IPv6 addresses are not permitted in "HostName".
+
+                        // User-defined list has a higher priority
+                        List<string> hostNames = CurrentRequest.CustomTLSServerNameList;
+
+                        // If there's no user defined one and the host isn't an IP address, add the default one
+                        if ((hostNames == null || hostNames.Count == 0) && !CurrentRequest.CurrentUri.IsHostIsAnIPAddress())
+                        {
+                            hostNames = new List<string>(1);
+                            hostNames.Add(CurrentRequest.CurrentUri.Host);
+                        }
+
+                        handler.Connect(new LegacyTlsClient(CurrentRequest.CurrentUri,
+                                                            CurrentRequest.CustomCertificateVerifyer == null ? new AlwaysValidVerifyer() : CurrentRequest.CustomCertificateVerifyer,
+                                                            CurrentRequest.CustomClientCredentialsProvider,
+                                                            hostNames));
+
+                        Stream = handler.Stream;
+                    }
+                    else
+#endif
+                    {
+#if !NETFX_CORE
+                        SslStream sslStream = new SslStream(Client.GetStream(), false, (sender, cert, chain, errors) =>
+                        {
+                            return CurrentRequest.CallCustomCertificationValidator(cert, chain);
+                        });
+
+                        if (!sslStream.IsAuthenticated)
+                            sslStream.AuthenticateAsClient(CurrentRequest.CurrentUri.Host);
+                        Stream = sslStream;
+#else
+                        Stream = Client.GetStream();
+#endif
+                    }
+
+#endregion
+                }
+            }
+        }
+
+        private bool Receive()
+        {
+            SupportedProtocols protocol = CurrentRequest.ProtocolHandler == SupportedProtocols.Unknown ? HTTPProtocolFactory.GetProtocolFromUri(CurrentRequest.CurrentUri) : CurrentRequest.ProtocolHandler;
+
+            if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - Receive - protocol: {1}", this.CurrentRequest.CurrentUri.ToString(), protocol.ToString()));
+
+            CurrentRequest.Response = HTTPProtocolFactory.Get(protocol, CurrentRequest, Stream, CurrentRequest.UseStreaming, false);
+
+            if (!CurrentRequest.Response.Receive())
+            {
+                if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                    HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - Receive - Failed! Response will be null, returning with false.", this.CurrentRequest.CurrentUri.ToString()));
+                CurrentRequest.Response = null;
+                return false;
+            }
+
+            if (CurrentRequest.Response.StatusCode == 304
+#if !BESTHTTP_DISABLE_CACHING
+                && !CurrentRequest.DisableCache
+#endif
+                )
+            {
+#if !BESTHTTP_DISABLE_CACHING
+                if (CurrentRequest.IsRedirected)
+                {
+                    if (!LoadFromCache(CurrentRequest.RedirectUri))
+                        LoadFromCache(CurrentRequest.Uri);
+                }
+                else
+                    LoadFromCache(CurrentRequest.Uri);
+#else
+                return false;
+#endif
+            }
+
+            if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - Receive - Finished Successfully!", this.CurrentRequest.CurrentUri.ToString()));
+
+            return true;
+        }
+
+#endregion
+
+#region Helper Functions
+
+#if !BESTHTTP_DISABLE_CACHING
+
+        private bool LoadFromCache(Uri uri)
+        {
+            if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - LoadFromCache for Uri: {1}", this.CurrentRequest.CurrentUri.ToString(), uri.ToString()));
+
+            var cacheEntity = HTTPCacheService.GetEntity(uri);
+            if (cacheEntity == null)
+            {
+                HTTPManager.Logger.Warning("HTTPConnection", string.Format("{0} - LoadFromCache for Uri: {1} - Cached entity not found!", this.CurrentRequest.CurrentUri.ToString(), uri.ToString()));
+                return false;
+            }
+
+            CurrentRequest.Response.CacheFileInfo = cacheEntity;
+
+            int bodyLength;
+            using (var cacheStream = cacheEntity.GetBodyStream(out bodyLength))
+            {
+                if (cacheStream == null)
+                    return false;
+
+                if (!CurrentRequest.Response.HasHeader("content-length"))
+                    CurrentRequest.Response.Headers.Add("content-length", new List<string>(1) { bodyLength.ToString() });
+                CurrentRequest.Response.IsFromCache = true;
+
+                if (!CurrentRequest.CacheOnly)
+                    CurrentRequest.Response.ReadRaw(cacheStream, bodyLength);
+            }
+
+            return true;
+        }
+
+        private bool TryLoadAllFromCache()
+        {
+            if (CurrentRequest.DisableCache || !HTTPCacheService.IsSupported)
+                return false;
+
+            // We will try read the response from the cache, but if something happens we will fallback to the normal way.
+            try
+            {
+                //Unless specifically constrained by a cache-control (section 14.9) directive, a caching system MAY always store a successful response (see section 13.8) as a cache entity,
+                //  MAY return it without validation if it is fresh, and MAY    return it after successful validation.
+                // MAY return it without validation if it is fresh!
+                if (HTTPCacheService.IsCachedEntityExpiresInTheFuture(CurrentRequest))
+                {
+                    if (HTTPManager.Logger.Level == Logger.Loglevels.All)
+                        HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - TryLoadAllFromCache - whole response loading from cache", this.CurrentRequest.CurrentUri.ToString()));
+
+                    CurrentRequest.Response = HTTPCacheService.GetFullResponse(CurrentRequest);
+
+                    if (CurrentRequest.Response != null)
+                        return true;
+                }
+            }
+            catch
+            {
+                HTTPCacheService.DeleteEntity(CurrentRequest.CurrentUri);
+            }
+
+            return false;
+        }
+#endif
+
+#if !BESTHTTP_DISABLE_CACHING
+        private void TryStoreInCache()
+        {
+            // if UseStreaming && !DisableCache then we already wrote the response to the cache
+            if (!CurrentRequest.UseStreaming &&
+                !CurrentRequest.DisableCache &&
+                CurrentRequest.Response != null &&
+                HTTPCacheService.IsSupported &&
+                HTTPCacheService.IsCacheble(CurrentRequest.CurrentUri, CurrentRequest.MethodType, CurrentRequest.Response))
+            {
+                if(CurrentRequest.IsRedirected)
+                    HTTPCacheService.Store(CurrentRequest.Uri, CurrentRequest.MethodType, CurrentRequest.Response);
+                else
+                    HTTPCacheService.Store(CurrentRequest.CurrentUri, CurrentRequest.MethodType, CurrentRequest.Response);
+                HTTPCacheService.SaveLibrary();
+            }
+        }
+#endif
+
+        private Uri GetRedirectUri(string location)
+        {
+            Uri result = null;
+            try
+            {
+                result = new Uri(location);
+
+                if (result.IsFile || result.AbsolutePath == location)
+                    result = null;
+            }
+#if !NETFX_CORE
+            catch (UriFormatException)
+#else
+            catch
+#endif
+            {
+                // Sometimes the server sends back only the path and query component of the new uri
+                result = null;
+            }
+
+            if (result == null)
+            {
+                var uri = CurrentRequest.Uri;
+                var builder = new UriBuilder(uri.Scheme, uri.Host, uri.Port, location);
+                result = builder.Uri;
+
+            }
+
+            return result;
+        }
+
+        internal override void Abort(HTTPConnectionStates newState)
+        {
+            State = newState;
+
+            switch(State)
+            {
+                case HTTPConnectionStates.TimedOut: TimedOutStart = DateTime.UtcNow; break;
+            }
+
+            if (Stream != null)
+            {
+                try
+                {
+                    Stream.Dispose();
+                }
+                catch
+                { }
+            }
+        }
+
+        private void Close()
+        {
+            KeepAlive = null;
+            LastProcessedUri = null;
+            if (Client != null)
+            {
+                try
+                {
+                    Client.Close();
+                }
+                catch
+                {
+
+                }
+                finally
+                {
+                    Stream = null;
+                    Client = null;
+                }
+            }
+        }
+
+#endregion
+
+        protected override void Dispose(bool disposing)
+        {
+            Close();
+
+            base.Dispose(disposing);
+        }
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPConnection.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c6e10f65ea45b8e4682ebe6a0c885e06
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPConnectionStates.cs

@@ -0,0 +1,59 @@
+namespace BestHTTP
+{
+    /// <summary>
+    /// Possible states of a Http Connection.
+    /// The ideal lifecycle of a connection that has KeepAlive is the following: Initial => [Processing => WaitForRecycle => Free] => Closed.
+    /// </summary>
+    internal enum HTTPConnectionStates
+    {
+        /// <summary>
+        /// This Connection instance is just created.
+        /// </summary>
+        Initial,
+
+        /// <summary>
+        /// This Connection is processing a request
+        /// </summary>
+        Processing,
+
+        /// <summary>
+        /// The request redirected.
+        /// </summary>
+        Redirected,
+
+        /// <summary>
+        /// The connection is upgraded from http.
+        /// </summary>
+        Upgraded,
+
+        /// <summary>
+        /// Wait for the upgraded protocol to shut down.
+        /// </summary>
+        WaitForProtocolShutdown,
+
+        /// <summary>
+        /// The Connection is finished processing the request, it's waiting now to deliver it's result.
+        /// </summary>
+        WaitForRecycle,
+
+        /// <summary>
+        /// The request result's delivered, it's now up to processing again.
+        /// </summary>
+        Free,
+
+        /// <summary>
+        /// A request from outside of the plugin to abort the connection.
+        /// </summary>
+        AbortRequested,
+
+        /// <summary>
+        /// The request is not finished in the given time.
+        /// </summary>
+        TimedOut,
+
+        /// <summary>
+        /// If it's not a KeepAlive connection, or something happend, then we close this connection and remove from the pool.
+        /// </summary>
+        Closed
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPConnectionStates.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ae2c4bf49da6b1b4097d46250f2ff3bf
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPManager.cs

@@ -0,0 +1,823 @@
+using System;
+using System.Collections.Generic;
+
+#if !BESTHTTP_DISABLE_CACHING
+    using BestHTTP.Caching;
+#endif
+
+using BestHTTP.Extensions;
+using BestHTTP.Logger;
+using BestHTTP.Statistics;
+
+namespace BestHTTP
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class HTTPManager
+    {
+        // Static constructor. Setup default values
+        static HTTPManager()
+        {
+            MaxConnectionPerServer = 4;
+            KeepAliveDefaultValue = true;
+            MaxPathLength = 255;
+            MaxConnectionIdleTime = TimeSpan.FromSeconds(20);
+
+#if !BESTHTTP_DISABLE_COOKIES
+#if UNITY_WEBGL
+            // Under webgl when IsCookiesEnabled is true, it will set the withCredentials flag for the XmlHTTPRequest
+            //  and that's different from the default behavior.
+            // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials
+            IsCookiesEnabled = false;
+#else
+            IsCookiesEnabled = true;
+#endif
+#endif
+
+            CookieJarSize = 10 * 1024 * 1024;
+            EnablePrivateBrowsing = false;
+            ConnectTimeout = TimeSpan.FromSeconds(20);
+            RequestTimeout = TimeSpan.FromSeconds(60);
+
+            // Set the default logger mechanism
+            logger = new BestHTTP.Logger.DefaultLogger();
+
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+            DefaultCertificateVerifyer = null;
+            UseAlternateSSLDefaultValue = true;
+#endif
+
+#if NETFX_CORE
+            IOService = new PlatformSupport.FileSystem.NETFXCOREIOService();
+#elif UNITY_WEBGL && !UNITY_EDITOR
+            IOService = new PlatformSupport.FileSystem.WebGLIOService();
+#else
+            IOService = new PlatformSupport.FileSystem.DefaultIOService();
+#endif
+
+        }
+
+        #region Global Options
+
+        /// <summary>
+        /// The maximum active TCP connections that the client will maintain to a server. Default value is 4. Minimum value is 1.
+        /// </summary>
+        public static byte MaxConnectionPerServer
+        {
+            get{ return maxConnectionPerServer; }
+            set
+            {
+                if (value <= 0)
+                    throw new ArgumentOutOfRangeException("MaxConnectionPerServer must be greater than 0!");
+                maxConnectionPerServer = value;
+            }
+        }
+        private static byte maxConnectionPerServer;
+
+        /// <summary>
+        /// Default value of a HTTP request's IsKeepAlive value. Default value is true. If you make rare request to the server it should be changed to false.
+        /// </summary>
+        public static bool KeepAliveDefaultValue { get; set; }
+
+#if !BESTHTTP_DISABLE_CACHING
+        /// <summary>
+        /// Set to true, if caching is prohibited.
+        /// </summary>
+        public static bool IsCachingDisabled { get; set; }
+#endif
+
+        /// <summary>
+        /// How many time must be passed to destroy that connection after a connection finished its last request. Its default value is 20 seconds.
+        /// </summary>
+        public static TimeSpan MaxConnectionIdleTime { get; set; }
+
+#if !BESTHTTP_DISABLE_COOKIES
+        /// <summary>
+        /// Set to false to disable all Cookie. It's default value is true.
+        /// </summary>
+        public static bool IsCookiesEnabled { get; set; }
+#endif
+
+        /// <summary>
+        /// Size of the Cookie Jar in bytes. It's default value is 10485760 (10 MB).
+        /// </summary>
+        public static uint CookieJarSize { get; set; }
+
+        /// <summary>
+        /// If this property is set to true, then new cookies treated as session cookies and these cookies are not saved to disk. Its default value is false;
+        /// </summary>
+        public static bool EnablePrivateBrowsing { get; set; }
+
+        /// <summary>
+        /// Global, default value of the HTTPRequest's ConnectTimeout property. If set to TimeSpan.Zero or lower, no connect timeout logic is executed. Default value is 20 seconds.
+        /// </summary>
+        public static TimeSpan ConnectTimeout { get; set; }
+
+        /// <summary>
+        /// Global, default value of the HTTPRequest's Timeout property. Default value is 60 seconds.
+        /// </summary>
+        public static TimeSpan RequestTimeout { get; set; }
+
+#if !(BESTHTTP_DISABLE_CACHING && BESTHTTP_DISABLE_COOKIES)
+        /// <summary>
+        /// By default the plugin will save all cache and cookie data under the path returned by Application.persistentDataPath.
+        /// You can assign a function to this delegate to return a custom root path to define a new path.
+        /// <remarks>This delegate will be called on a non Unity thread!</remarks>
+        /// </summary>
+        public static System.Func<string> RootCacheFolderProvider { get; set; }
+#endif
+
+#if !BESTHTTP_DISABLE_PROXY
+        /// <summary>
+        /// The global, default proxy for all HTTPRequests. The HTTPRequest's Proxy still can be changed per-request. Default value is null.
+        /// </summary>
+        public static Proxy Proxy { get; set; }
+#endif
+
+        /// <summary>
+        /// Heartbeat manager to use less threads in the plugin. The heartbeat updates are called from the OnUpdate function.
+        /// </summary>
+        public static HeartbeatManager Heartbeats
+        {
+            get
+            {
+                if (heartbeats == null)
+                    heartbeats = new HeartbeatManager();
+                return heartbeats;
+            }
+        }
+        private static HeartbeatManager heartbeats;
+
+        /// <summary>
+        /// A basic BestHTTP.Logger.ILogger implementation to be able to log intelligently additional informations about the plugin's internal mechanism.
+        /// </summary>
+        public static BestHTTP.Logger.ILogger Logger
+        {
+            get
+            {
+                // Make sure that it has a valid logger instance.
+                if (logger == null)
+                {
+                    logger = new DefaultLogger();
+                    logger.Level = Loglevels.None;
+                }
+
+                return logger;
+            }
+
+            set { logger = value; }
+        }
+        private static BestHTTP.Logger.ILogger logger;
+
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+        /// <summary>
+        /// The default ICertificateVerifyer implementation that the plugin will use when the request's UseAlternateSSL property is set to true.
+        /// </summary>
+        public static Org.BouncyCastle.Crypto.Tls2.ICertificateVerifyer DefaultCertificateVerifyer { get; set; }
+
+        /// <summary>
+        /// The default IClientCredentialsProvider implementation that the plugin will use when the request's UseAlternateSSL property is set to true.
+        /// </summary>
+        public static Org.BouncyCastle.Crypto.Tls2.IClientCredentialsProvider DefaultClientCredentialsProvider { get; set; }
+
+        /// <summary>
+        /// The default value for the HTTPRequest's UseAlternateSSL property.
+        /// </summary>
+        public static bool UseAlternateSSLDefaultValue { get; set; }
+#endif
+
+#if !NETFX_CORE
+        public static Func<HTTPRequest, System.Security.Cryptography.X509Certificates.X509Certificate, System.Security.Cryptography.X509Certificates.X509Chain, bool> DefaultCertificationValidator { get; set; }
+#endif
+
+        /// <summary>
+        /// Setting this option to true, the processing connection will set the TCP NoDelay option to send out data as soon as it can.
+        /// </summary>
+        public static bool TryToMinimizeTCPLatency = false;
+
+        public static int SendBufferSize = 65 * 1024;
+        public static int ReceiveBufferSize = 65 * 1024;
+
+        /// <summary>
+        /// An IIOService implementation to handle filesystem operations.
+        /// </summary>
+        public static PlatformSupport.FileSystem.IIOService IOService;
+
+        /// <summary>
+        /// On most systems the maximum length of a path is around 255 character. If a cache entity's path is longer than this value it doesn't get cached. There no platform independent API to query the exact value on the current system, but it's
+        /// exposed here and can be overridden. It's default value is 255.
+        /// </summary>
+        internal static int MaxPathLength { get; set; }
+
+        #endregion
+
+        #region Manager variables
+
+        /// <summary>
+        /// All connection has a reference in this Dictionary until it's removed completely.
+        /// </summary>
+        private static Dictionary<string, List<ConnectionBase>> Connections = new Dictionary<string, List<ConnectionBase>>();
+
+        /// <summary>
+        /// Active connections. These connections all has a request to process.
+        /// </summary>
+        private static List<ConnectionBase> ActiveConnections = new List<ConnectionBase>();
+
+        /// <summary>
+        /// Free connections. They can be removed completely after a specified time.
+        /// </summary>
+        private static List<ConnectionBase> FreeConnections = new List<ConnectionBase>();
+
+        /// <summary>
+        /// Connections that recycled in the Update loop. If they are not used in the same loop to process a request, they will be transferred to the FreeConnections list.
+        /// </summary>
+        private static List<ConnectionBase> RecycledConnections = new List<ConnectionBase>();
+
+        /// <summary>
+        /// List of request that have to wait until there is a free connection to the server.
+        /// </summary>
+        private static List<HTTPRequest> RequestQueue = new List<HTTPRequest>();
+        private static bool IsCallingCallbacks;
+
+        internal static System.Object Locker = new System.Object();
+
+        internal static bool IsQuitting { get; private set; }
+
+        #endregion
+
+        #region Public Interface
+
+        public static void Setup()
+        {
+            HTTPUpdateDelegator.CheckInstance();
+
+#if !BESTHTTP_DISABLE_CACHING
+            HTTPCacheService.CheckSetup();
+#endif
+
+#if !BESTHTTP_DISABLE_COOKIES
+            Cookies.CookieJar.SetupFolder();
+#endif
+        }
+
+        public static HTTPRequest SendRequest(string url, OnRequestFinishedDelegate callback)
+        {
+            return SendRequest(new HTTPRequest(new Uri(url), HTTPMethods.Get, callback));
+        }
+
+        public static HTTPRequest SendRequest(string url, HTTPMethods methodType, OnRequestFinishedDelegate callback)
+        {
+            return SendRequest(new HTTPRequest(new Uri(url), methodType, callback));
+        }
+
+        public static HTTPRequest SendRequest(string url, HTTPMethods methodType, bool isKeepAlive, OnRequestFinishedDelegate callback)
+        {
+            return SendRequest(new HTTPRequest(new Uri(url), methodType, isKeepAlive, callback));
+        }
+
+        public static HTTPRequest SendRequest(string url, HTTPMethods methodType, bool isKeepAlive, bool disableCache, OnRequestFinishedDelegate callback)
+        {
+            return SendRequest(new HTTPRequest(new Uri(url), methodType, isKeepAlive, disableCache, callback));
+        }
+
+        public static HTTPRequest SendRequest(HTTPRequest request)
+        {
+            lock (Locker)
+            {
+                Setup();
+
+                if (IsCallingCallbacks)
+                {
+                    request.State = HTTPRequestStates.Queued;
+                    RequestQueue.Add(request);
+                }
+                else
+                    SendRequestImpl(request);
+
+                return request;
+            }
+        }
+
+        public static GeneralStatistics GetGeneralStatistics(StatisticsQueryFlags queryFlags)
+        {
+            GeneralStatistics stat = new GeneralStatistics();
+
+            stat.QueryFlags = queryFlags;
+
+            if ((queryFlags & StatisticsQueryFlags.Connections) != 0)
+            {
+                int connections = 0;
+                foreach(var conn in HTTPManager.Connections)
+                {
+                    if (conn.Value != null)
+                        connections += conn.Value.Count;
+                }
+
+#if !BESTHTTP_DISABLE_WEBSOCKET && UNITY_WEBGL && !UNITY_EDITOR
+                connections += WebSocket.WebSocket.WebSockets.Count;
+#endif
+
+                stat.Connections = connections;
+                stat.ActiveConnections = ActiveConnections.Count
+#if !BESTHTTP_DISABLE_WEBSOCKET && UNITY_WEBGL && !UNITY_EDITOR
+                                         + WebSocket.WebSocket.WebSockets.Count
+#endif
+                ;
+                stat.FreeConnections = FreeConnections.Count;
+                stat.RecycledConnections = RecycledConnections.Count;
+                stat.RequestsInQueue = RequestQueue.Count;
+            }
+
+#if !BESTHTTP_DISABLE_CACHING
+            if ((queryFlags & StatisticsQueryFlags.Cache) != 0)
+            {
+                stat.CacheEntityCount = HTTPCacheService.GetCacheEntityCount();
+                stat.CacheSize = HTTPCacheService.GetCacheSize();
+            }
+#endif
+
+#if !BESTHTTP_DISABLE_COOKIES
+            if ((queryFlags & StatisticsQueryFlags.Cookies) != 0)
+            {
+                List<Cookies.Cookie> cookies = Cookies.CookieJar.GetAll();
+                stat.CookieCount = cookies.Count;
+                uint cookiesSize = 0;
+                for (int i = 0; i < cookies.Count; ++i)
+                    cookiesSize += cookies[i].GuessSize();
+                stat.CookieJarSize = cookiesSize;
+            }
+#endif
+
+            return stat;
+        }
+
+        #endregion
+
+        #region Private Functions
+
+        private static void SendRequestImpl(HTTPRequest request)
+        {
+            ConnectionBase conn = FindOrCreateFreeConnection(request);
+
+            if (conn != null)
+            {
+                // found a free connection: put it in the ActiveConnection list(they will be checked periodically in the OnUpdate call)
+                if (ActiveConnections.Find((c) => c == conn) == null)
+                    ActiveConnections.Add(conn);
+
+                FreeConnections.Remove(conn);
+
+                request.State = HTTPRequestStates.Processing;
+
+                request.Prepare();
+
+                // then start process the request
+                conn.Process(request);
+            }
+            else
+            {
+                // If no free connection found and creation prohibited, we will put back to the queue
+                request.State = HTTPRequestStates.Queued;
+                RequestQueue.Add(request);
+            }
+        }
+
+        private static string GetKeyForRequest(HTTPRequest request)
+        {
+            if (request.CurrentUri.IsFile)
+                return request.CurrentUri.ToString();
+
+            // proxyUri + requestUri
+            // HTTP and HTTPS needs different connections.
+            return
+#if !BESTHTTP_DISABLE_PROXY
+                (request.Proxy != null ? new UriBuilder(request.Proxy.Address.Scheme, request.Proxy.Address.Host, request.Proxy.Address.Port).Uri.ToString() : string.Empty) +
+#endif
+                                            new UriBuilder(request.CurrentUri.Scheme, request.CurrentUri.Host, request.CurrentUri.Port).Uri.ToString();
+        }
+
+        /// <summary>
+        /// Factory method to create a concrete connection object.
+        /// </summary>
+        private static ConnectionBase CreateConnection(HTTPRequest request, string serverUrl)
+        {
+            if (request.CurrentUri.IsFile && UnityEngine.Application.platform != UnityEngine.RuntimePlatform.WebGLPlayer)
+                return new FileConnection(serverUrl);
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+            return new WebGLConnection(serverUrl);
+#else
+            return new HTTPConnection(serverUrl);
+#endif
+        }
+
+        private static ConnectionBase FindOrCreateFreeConnection(HTTPRequest request)
+        {
+            ConnectionBase conn = null;
+            List<ConnectionBase> connections;
+
+            string serverUrl = GetKeyForRequest(request);
+
+            if (Connections.TryGetValue(serverUrl, out connections))
+            {
+                // count active connections
+
+                int activeConnections = 0;
+                for (int i = 0; i < connections.Count; ++i)
+                    if (connections[i].IsActive)
+                        activeConnections++;
+
+                if (activeConnections <= MaxConnectionPerServer)
+                    // search for a Free connection
+                    for (int i = 0; i < connections.Count && conn == null; ++i)
+                    {
+                        var tmpConn = connections[i];
+
+                        if (tmpConn != null &&
+                            tmpConn.IsFree &&
+                            (
+#if !BESTHTTP_DISABLE_PROXY
+                            !tmpConn.HasProxy ||
+#endif
+                             tmpConn.LastProcessedUri == null ||
+                             tmpConn.LastProcessedUri.Host.Equals(request.CurrentUri.Host, StringComparison.OrdinalIgnoreCase)))
+                            conn = tmpConn;
+                    }
+            }
+            else
+                Connections.Add(serverUrl, connections = new List<ConnectionBase>(MaxConnectionPerServer));
+
+            // No free connection found?
+            if (conn == null)
+            {
+                // Max connection reached?
+                if (connections.Count >= MaxConnectionPerServer)
+                    return null;
+
+                // if no, create a new one
+                connections.Add(conn = CreateConnection(request, serverUrl));
+            }
+
+            return conn;
+        }
+
+        /// <summary>
+        /// Will return with true when there at least one request that can be processed from the RequestQueue.
+        /// </summary>
+        private  static bool CanProcessFromQueue()
+        {
+            for (int i = 0; i < RequestQueue.Count; ++i)
+                if (FindOrCreateFreeConnection(RequestQueue[i]) != null)
+                    return true;
+
+            return false;
+        }
+
+        private static void RecycleConnection(ConnectionBase conn)
+        {
+            conn.Recycle(OnConnectionRecylced);
+        }
+
+        private static void OnConnectionRecylced(ConnectionBase conn)
+        {
+            lock (RecycledConnections)
+            {
+                RecycledConnections.Add(conn);
+            }
+        }
+
+        #endregion
+
+        #region Internal Helper Functions
+
+        /// <summary>
+        /// Will return the ConnectionBase object that processing the given request.
+        /// </summary>
+        internal static ConnectionBase GetConnectionWith(HTTPRequest request)
+        {
+            lock (Locker)
+            {
+                for (int i = 0; i < ActiveConnections.Count; ++i)
+                {
+                    var connection = ActiveConnections[i];
+                    if (connection.CurrentRequest == request)
+                        return connection;
+                }
+
+                return null;
+            }
+        }
+
+        internal static bool RemoveFromQueue(HTTPRequest request)
+        {
+            return RequestQueue.Remove(request);
+        }
+
+#if !(BESTHTTP_DISABLE_CACHING && BESTHTTP_DISABLE_COOKIES)
+        /// <summary>
+        /// Will return where the various caches should be saved.
+        /// </summary>
+        internal static string GetRootCacheFolder()
+        {
+            try
+            {
+                if (RootCacheFolderProvider != null)
+                    return RootCacheFolderProvider();
+            }
+            catch(Exception ex)
+            {
+                HTTPManager.Logger.Exception("HTTPManager", "GetRootCacheFolder", ex);
+            }
+
+#if NETFX_CORE
+            return Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+#else
+            return UnityEngine.Application.persistentDataPath;
+#endif
+        }
+#endif
+
+        #endregion
+
+        #region MonoBehaviour Events (Called from HTTPUpdateDelegator)
+
+        /// <summary>
+        /// Update function that should be called regularly from a Unity event(Update, LateUpdate). Callbacks are dispatched from this function.
+        /// </summary>
+        public static void OnUpdate()
+        {
+            // We will try to acquire a lock. If it fails, we will skip this frame without calling any callback.
+            if (System.Threading.Monitor.TryEnter(Locker))
+            {
+                try
+                {
+                    IsCallingCallbacks = true;
+                    try
+                    {
+                        for (int i = 0; i < ActiveConnections.Count; ++i)
+                        {
+                            ConnectionBase conn = ActiveConnections[i];
+
+                            switch (conn.State)
+                            {
+                                case HTTPConnectionStates.Processing:
+                                    conn.HandleProgressCallback();
+
+                                    if (conn.CurrentRequest.UseStreaming && conn.CurrentRequest.Response != null && conn.CurrentRequest.Response.HasStreamedFragments())
+                                        conn.HandleCallback();
+
+                                    try
+                                    {
+                                        if (((!conn.CurrentRequest.UseStreaming && conn.CurrentRequest.UploadStream == null) || conn.CurrentRequest.EnableTimoutForStreaming) &&
+                                            DateTime.UtcNow - conn.StartTime > conn.CurrentRequest.Timeout)
+                                            conn.Abort(HTTPConnectionStates.TimedOut);
+                                    }
+                                    catch (OverflowException)
+                                    {
+                                        HTTPManager.Logger.Warning("HTTPManager", "TimeSpan overflow");
+                                    }
+                                    break;
+
+                                case HTTPConnectionStates.TimedOut:
+                                    // The connection is still in TimedOut state, and if we waited enough time, we will dispatch the
+                                    //  callback and recycle the connection
+                                    try
+                                    {
+                                        if (DateTime.UtcNow - conn.TimedOutStart > TimeSpan.FromMilliseconds(500))
+                                        {
+                                            HTTPManager.Logger.Information("HTTPManager", "Hard aborting connection because of a long waiting TimedOut state");
+
+                                            conn.CurrentRequest.Response = null;
+                                            conn.CurrentRequest.State = HTTPRequestStates.TimedOut;
+                                            conn.HandleCallback();
+
+                                            // this will set the connection's CurrentRequest to null
+                                            RecycleConnection(conn);
+                                        }
+                                    }
+                                    catch(OverflowException)
+                                    {
+                                        HTTPManager.Logger.Warning("HTTPManager", "TimeSpan overflow");
+                                    }
+                                    break;
+
+                                case HTTPConnectionStates.Redirected:
+                                    // If the server redirected us, we need to find or create a connection to the new server and send out the request again.
+                                    SendRequest(conn.CurrentRequest);
+
+                                    RecycleConnection(conn);
+                                    break;
+
+                                case HTTPConnectionStates.WaitForRecycle:
+                                    // If it's a streamed request, it's finished now
+                                    conn.CurrentRequest.FinishStreaming();
+
+                                    // Call the callback
+                                    conn.HandleCallback();
+
+                                    // Then recycle the connection
+                                    RecycleConnection(conn);
+                                    break;
+
+                                case HTTPConnectionStates.Upgraded:
+                                    // The connection upgraded to an other protocol
+                                    conn.HandleCallback();
+                                    break;
+
+                                case HTTPConnectionStates.WaitForProtocolShutdown:
+                                    var ws = conn.CurrentRequest.Response as IProtocol;
+                                    if (ws != null)
+                                        ws.HandleEvents();
+
+                                    if (ws == null || ws.IsClosed)
+                                    {
+                                        conn.HandleCallback();
+
+                                        // After both sending and receiving a Close message, an endpoint considers the WebSocket connection closed and MUST close the underlying TCP connection.
+                                        conn.Dispose();
+                                        RecycleConnection(conn);
+                                    }
+                                    break;
+
+                                case HTTPConnectionStates.AbortRequested:
+                                    // Corner case: we aborted a WebSocket connection
+                                    {
+                                        ws = conn.CurrentRequest.Response as IProtocol;
+                                        if (ws != null)
+                                        {
+                                            ws.HandleEvents();
+
+                                            if (ws.IsClosed)
+                                            {
+                                                conn.HandleCallback();
+                                                conn.Dispose();
+
+                                                RecycleConnection(conn);
+                                            }
+                                        }
+                                    }
+                                    break;
+
+                                case HTTPConnectionStates.Closed:
+                                    // If it's a streamed request, it's finished now
+                                    conn.CurrentRequest.FinishStreaming();
+
+                                    // Call the callback
+                                    conn.HandleCallback();
+
+                                    // It will remove from the ActiveConnections
+                                    RecycleConnection(conn);
+                                    break;
+
+                                case HTTPConnectionStates.Free:
+                                    RecycleConnection(conn);
+                                    break;
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        IsCallingCallbacks = false;
+                    }
+
+                    // Just try to grab the lock, if we can't have it we can wait another turn because it isn't
+                    //  critical to do it right now.
+                    if (System.Threading.Monitor.TryEnter(RecycledConnections))
+                        try
+                        {
+                            if (RecycledConnections.Count > 0)
+                            {
+                                for (int i = 0; i < RecycledConnections.Count; ++i)
+                                {
+                                    var connection = RecycledConnections[i];
+                                    // If in a callback made a request that acquired this connection, then we will not remove it from the
+                                    //  active connections.
+                                    if (connection.IsFree)
+                                    {
+                                        ActiveConnections.Remove(connection);
+                                        FreeConnections.Add(connection);
+                                    }
+                                }
+                                RecycledConnections.Clear();
+                            }
+                        }
+                        finally
+                        {
+                            System.Threading.Monitor.Exit(RecycledConnections);
+                        }
+
+                    if (FreeConnections.Count > 0)
+                        for (int i = 0; i < FreeConnections.Count; i++)
+                        {
+                            var connection = FreeConnections[i];
+
+                            if (connection.IsRemovable)
+                            {
+                                // Remove the connection from the connection reference table
+                                List<ConnectionBase> connections = null;
+                                if (Connections.TryGetValue(connection.ServerAddress, out connections))
+                                    connections.Remove(connection);
+
+                                // Dispose the connection
+                                connection.Dispose();
+
+                                FreeConnections.RemoveAt(i);
+                                i--;
+                            }
+                        }
+
+
+                    if (CanProcessFromQueue())
+                    {
+                        // Sort the queue by priority, only if we have to
+                        if (RequestQueue.Find((req) => req.Priority != 0) != null)
+                            RequestQueue.Sort((req1, req2) => req1.Priority - req2.Priority);
+
+                        // Create an array from the queue and clear it. When we call the SendRequest while still no room for new connections, the same queue will be rebuilt.
+
+                        var queue = RequestQueue.ToArray();
+                        RequestQueue.Clear();
+
+                        for (int i = 0; i < queue.Length; ++i)
+                            SendRequest(queue[i]);
+                    }
+                }
+                finally
+                {
+                    System.Threading.Monitor.Exit(Locker);
+                }
+            }
+
+            if (heartbeats != null)
+                heartbeats.Update();
+
+            VariableSizedBufferPool.Maintain();
+        }
+
+        public static void OnQuit()
+        {
+            lock (Locker)
+            {
+                IsQuitting = true;
+
+#if !BESTHTTP_DISABLE_CACHING
+                Caching.HTTPCacheService.SaveLibrary();
+#endif
+
+#if !BESTHTTP_DISABLE_COOKIES
+                Cookies.CookieJar.Persist();
+#endif
+
+                AbortAll(true);
+
+                OnUpdate();
+            }
+        }
+
+        public static void AbortAll(bool allowCallbacks = false)
+        {
+            lock (Locker)
+            {
+                var queue = RequestQueue.ToArray();
+                RequestQueue.Clear();
+                foreach (var req in queue)
+                {
+                    // Swallow any exceptions, we are quitting anyway.
+                    try
+                    {
+                        if (!allowCallbacks)
+                            req.Callback = null;
+                        req.Abort();
+                    }
+                    catch { }
+                }
+
+                // Close all TCP connections when the application is terminating.
+                foreach (var kvp in Connections)
+                {
+                    foreach (var conn in kvp.Value)
+                    {
+                        // Swallow any exceptions, we are quitting anyway.
+                        try
+                        {
+                            if (conn.CurrentRequest != null)
+                            {
+                                if (!allowCallbacks)
+                                    conn.CurrentRequest.Callback = null;
+                                conn.CurrentRequest.State = HTTPRequestStates.Aborted;
+                            }
+                            conn.Abort(HTTPConnectionStates.Closed);
+                            conn.Dispose();
+                        }
+                        catch { }
+                    }
+                    kvp.Value.Clear();
+                }
+                Connections.Clear();
+            }
+        }
+
+        #endregion
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPManager.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8598bf6546f50e64197d043a215a5897
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPMethods.cs

@@ -0,0 +1,76 @@
+namespace BestHTTP
+{
+    /// <summary>
+    /// Some supported methods described in the rfc: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
+    /// </summary>
+    public enum HTTPMethods : byte
+    {
+        /// <summary>
+        /// The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.
+        /// If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the
+        /// entity in the response and not the source text of the process, unless that text happens to be the output of the process.
+        /// </summary>
+        Get,
+
+        /// <summary>
+        /// The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response.
+        /// The metainformation contained in the HTTP headers in response to a HEAD request SHOULD be identical to the information sent in response to a GET request.
+        /// This method can be used for obtaining metainformation about the entity implied by the request without transferring the entity-body itself.
+        /// This method is often used for testing hypertext links for validity, accessibility, and recent modification.
+        /// </summary>
+        Head,
+
+        /// <summary>
+        /// The POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.
+        /// POST is designed to allow a uniform method to cover the following functions:
+        /// <list type="bullet">
+        ///     <item><description>Annotation of existing resources;</description></item>
+        ///     <item><description>Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;</description></item>
+        ///     <item><description>Providing a block of data, such as the result of submitting a form, to a data-handling process;</description></item>
+        ///     <item><description>Extending a database through an append operation.</description></item>
+        /// </list>
+        /// The actual function performed by the POST method is determined by the server and is usually dependent on the Request-URI.
+        /// The posted entity is subordinate to that URI in the same way that a file is subordinate to a directory containing it,
+        /// a news article is subordinate to a newsgroup to which it is posted, or a record is subordinate to a database.
+        /// The action performed by the POST method might not result in a resource that can be identified by a URI. In this case,
+        /// either 200 (OK) or 204 (No Content) is the appropriate response status, depending on whether or not the response includes an entity that describes the result.
+        /// </summary>
+        Post,
+
+        /// <summary>
+        /// The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
+        /// If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server.
+        /// If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent,
+        /// the origin server can create the resource with that URI. If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response.
+        /// If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate successful completion of the request.
+        /// If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be given that reflects the nature of the problem.
+        /// The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not understand or implement and MUST return a 501 (Not Implemented) response in such cases.
+        /// </summary>
+        Put,
+
+        /// <summary>
+        /// The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY be overridden by human intervention (or other means) on the origin server.
+        /// The client cannot be guaranteed that the operation has been carried out, even if the status code returned from the origin server indicates that the action has been completed successfully.
+        /// However, the server SHOULD NOT indicate success unless, at the time the response is given, it intends to delete the resource or move it to an inaccessible location.
+        /// A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 202 (Accepted) if the action has not yet been enacted, or 204 (No Content)
+        /// if the action has been enacted but the response does not include an entity.
+        /// </summary>
+        Delete,
+
+        /// <summary>
+        /// http://tools.ietf.org/html/rfc5789
+        /// The PATCH method requests that a set of changes described in the request entity be applied to the resource identified by the Request-URI.
+        /// The set of changes is represented in a format called a "patchdocument" identified by a media type. If the Request-URI does not point to an existing resource,
+        /// the server MAY create a new resource, depending on the patch document type (whether it can logically modify a null resource) and permissions, etc.
+        /// </summary>
+        Patch,
+
+        /// <summary>
+        /// The HTTP methods PATCH can be used to update partial resources. For instance, when you only need to update one field of the resource, PUTting a complete resource representation might be cumbersome and utilizes more bandwidth.
+        /// <seealso href="http://restcookbook.com/HTTP%20Methods/patch/"/>
+        /// </summary>
+        Merge,
+
+        Options
+    }
+}

Assets/ThirdAssets/Best HTTP (Pro)/BestHTTP/HTTPMethods.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: faf468f5056a1614da3acf7f571cc6bb
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: