Dep/CascLib: Update to ladislav-zezula/CascLib@a5080b5794027a25d98aa6024b2bef17d06fe0ea

39 files changed, 2066 insertions, 1625 deletions

diff --git a/dep/CascLib/CMakeLists.txt b/dep/CascLib/CMakeLists.txt
index 273b7155468..078d4f0d5cd 100644
--- a/dep/CascLib/CMakeLists.txt
+++ b/dep/CascLib/CMakeLists.txt
@@ -4,6 +4,7 @@ set(HEADER_FILES
     src/CascPort.h
     src/CascStructs.h
     src/common/Array.h
+    src/common/ArraySparse.h
     src/common/Common.h
     src/common/Csv.h
     src/common/Directory.h
diff --git a/dep/CascLib/src/CascCommon.h b/dep/CascLib/src/CascCommon.h
index 44f94b0b40d..19a6aa98444 100644
--- a/dep/CascLib/src/CascCommon.h
+++ b/dep/CascLib/src/CascCommon.h
@@ -24,6 +24,7 @@
 #include "CascPort.h"
 #include "common/Common.h"
 #include "common/Array.h"
+#include "common/ArraySparse.h"
 #include "common/Map.h"
 #include "common/FileTree.h"
 #include "common/FileStream.h"
@@ -59,9 +60,6 @@
 #define CASC_MAGIC_FILE     0x454C494643534143      // 'CASCFILE'
 #define CASC_MAGIC_FIND     0x444E494643534143      // 'CASCFIND'
 
-// For CASC_CDN_DOWNLOAD::Flags
-#define CASC_CDN_FORCE_DOWNLOAD         0x0001      // Force downloading the file even if in the cache
-
 // The maximum size of an inline file
 #define CASC_MAX_ONLINE_FILE_SIZE   0x40000000
 
@@ -71,11 +69,18 @@
 typedef enum _CBLD_TYPE
 {
     CascBuildNone = 0,                              // No build type found
-    CascBuildInfo,                                  // .build.info
     CascBuildDb,                                    // .build.db (older storages)
-    CascVersionsDb                                  // versions (downloaded online)
+    CascBuildInfo,                                  // .build.info
+    CascVersions                                    // versions (cached or online)
 } CBLD_TYPE, *PCBLD_TYPE;
 
+typedef enum _CPATH_TYPE
+{
+    PathTypeConfig,                                 // The "config" subfolder
+    PathTypeData,                                   // The "data" subfolder
+    PathTypePatch                                   // The "patch" subfolder
+} CPATH_TYPE, *PCPATH_TYPE;
+
 typedef enum _CSTRTG
 {
     CascCacheInvalid,                               // Do not cache anything. Used as invalid value
@@ -90,15 +95,23 @@ typedef struct _CASC_TAG_ENTRY
     char TagName[1];                                // Tag name. Variable length.
 } CASC_TAG_ENTRY, *PCASC_TAG_ENTRY;
 
+// Information about CASC main file
+typedef struct _CASC_BUILD_FILE
+{
+    LPCTSTR szPlainName;                            // Plain file name
+    CBLD_TYPE BuildFileType;                        // Build file type
+    TCHAR   szFullPath[MAX_PATH];                   // Full file name
+} CASC_BUILD_FILE, *PCASC_BUILD_FILE;
+
 // Information about index file
-typedef struct _CASC_INDEX
+struct CASC_INDEX
 {
+    CASC_BLOB FileData;
     LPTSTR szFileName;                              // Full name of the index file
-    LPBYTE pbFileData;                              // Loaded content of the index file
-    size_t cbFileData;                               // Size of the index file
     DWORD NewSubIndex;                              // New subindex
     DWORD OldSubIndex;                              // Old subindex
-} CASC_INDEX, *PCASC_INDEX;
+};
+typedef CASC_INDEX * PCASC_INDEX;
 
 // Normalized header of the index files.
 // Both version 1 and version 2 are converted to this structure
@@ -229,30 +242,15 @@ typedef struct _CASC_FILE_SPAN
 
 } CASC_FILE_SPAN, *PCASC_FILE_SPAN;
 
-// Structure for downloading a file from the CDN (https://wowdev.wiki/TACT#File_types)
-// Remote path is combined as the following:
-//  [szCdnsHost]       /[szCdnsPath]/[szPathType]/EKey[0-1]/EKey[2-3]/[EKey].[Extension]
-//  level3.blizzard.com/tpr/bnt001  /data        /fe       /3d       /fe3d7cf9d04e07066de32bd95a5c2627.index
-typedef struct _CASC_CDN_DOWNLOAD
+// Archive information for a remote file
+typedef struct _CASC_ARCHIVE_INFO
 {
-    ULONGLONG ArchiveOffs;                          // Archive offset (if pbArchiveKey != NULL)
-    LPCTSTR szCdnsHost;                             // Address of the remote CDN server. ("level3.blizzard.com")
-                                                    // If NULL, the downloader will try all CDN servers from the storage
-    LPCTSTR szCdnsPath;                             // Remote CDN path ("tpr/bnt001")
-    LPCTSTR szPathType;                             // Path type ("config", "data", "patch")
-    LPCTSTR szLoPaType;                             // Local path type ("config", "data", "patch"). If NULL, it's gonna be the same like szPathType, If "", then it's not used
-    LPCTSTR szFileName;                             // Plain file name, without path and extension
-    LPBYTE  pbArchiveKey;                            // If non-NULL, then the file is present in the archive.
-    LPBYTE  pbEKey;                                 // 16-byte EKey of the file of of the archive
-    LPCTSTR szExtension;                            // Extension for the file. Can be NULL.
-
-    LPTSTR szLocalPath;                             // Pointer to the variable that, upon success, reveives the local path where the file was downloaded
-    size_t ccLocalPath;                             // Maximum length of szLocalPath, in TCHARs
-    DWORD ArchiveIndex;                             // Index of the archive (if pbArchiveKey != NULL)
-    DWORD EncodedSize;                              // Encoded length (if pbArchiveKey != NULL)
-    DWORD Flags;                                    // See CASC_CDN_FLAG_XXX
-
-} CASC_CDN_DOWNLOAD, *PCASC_CDN_DOWNLOAD;
+    DWORD ArchiveIndex;                             // This is the index of the archive
+    DWORD ArchiveOffs;                              // The file is within an archive at this offset
+    DWORD EncodedSize;                              // The size of the file within the archive
+    BYTE ArchiveKey[MD5_HASH_SIZE];                // This is the CKey of the archive
+
+} CASC_ARCHIVE_INFO, *PCASC_ARCHIVE_INFO;
 
 //-----------------------------------------------------------------------------
 // Structures for CASC storage and CASC file
@@ -282,13 +280,15 @@ struct TCascStorage
     CASC_LOCK StorageLock;                          // Lock for multi-threaded operations
 
     LPCTSTR szIndexFormat;                          // Format of the index file name
-    LPTSTR  szCdnHostUrl;                           // CDN host URL for online storage
     LPTSTR  szCodeName;                             // On local storage, this select a product in a multi-product storage. For online storage, this selects a product
     LPTSTR  szRootPath;                             // Path where the build file is
-    LPTSTR  szDataPath;                             // This is the directory where data files are
-    LPTSTR  szIndexPath;                            // This is the directory where index files are
-    LPTSTR  szBuildFile;                            // Build file name (.build.info or .build.db)
-    LPTSTR  szCdnServers;                           // Multi-SZ list of CDN servers
+    LPTSTR  szDataPath;                             // The directory where data files are
+    LPTSTR  szIndexPath;                            // The directory where index files are
+    LPTSTR  szFilesPath;                            // The directory where raw files are
+    LPTSTR  szConfigPath;                           // The directory with configs
+    LPTSTR  szMainFile;                             // Main storage file (".build.info", ".build.db", "versions")
+    LPTSTR  szCdnHostUrl;                           // URL of the ribbit/http server where to download the "versions" and "cdns" files
+    LPTSTR  szCdnServers;                           // List of CDN servers, separated by space
     LPTSTR  szCdnPath;                              // Remote CDN sub path for the product
     LPSTR   szRegion;                               // Product region. Only when "versions" is used as storage root file
     LPSTR   szBuildKey;                             // Product build key, aka MD5 of the build file
@@ -299,14 +299,14 @@ struct TCascStorage
 
     CBLD_TYPE BuildFileType;                        // Type of the build file
 
-    QUERY_KEY CdnConfigKey;                         // Currently selected CDN config file. Points to "config\%02X\%02X\%s
-    QUERY_KEY CdnBuildKey;                          // Currently selected CDN build file. Points to "config\%02X\%02X\%s
+    CASC_BLOB CdnConfigKey;                         // Currently selected CDN config file. Points to "config\%02X\%02X\%s
+    CASC_BLOB CdnBuildKey;                          // Currently selected CDN build file. Points to "config\%02X\%02X\%s
 
-    QUERY_KEY ArchiveGroup;                         // Key array of the "archive-group"
-    QUERY_KEY ArchivesKey;                          // Key array of the "archives"
-    QUERY_KEY PatchArchivesKey;                     // Key array of the "patch-archives"
-    QUERY_KEY PatchArchivesGroup;                   // Key array of the "patch-archive-group"
-    QUERY_KEY BuildFiles;                           // List of supported build files
+    CASC_BLOB ArchiveGroup;                         // Key array of the "archive-group"
+    CASC_BLOB ArchivesKey;                          // Key array of the "archives"
+    CASC_BLOB PatchArchivesKey;                     // Key array of the "patch-archives"
+    CASC_BLOB PatchArchivesGroup;                   // Key array of the "patch-archive-group"
+    CASC_BLOB BuildFiles;                           // List of supported build files
 
     TFileStream * DataFiles[CASC_MAX_DATA_FILES];   // Array of open data files
     CASC_INDEX IndexFiles[CASC_INDEX_COUNT];        // Array of found index files
@@ -386,9 +386,8 @@ struct TCascSearch
     TCascSearch(TCascStorage * ahs, LPCTSTR aszListFile, const char * aszMask)
     {
         // Init the class
-        if(ahs != NULL)
-            hs = ahs->AddRef();
         ClassName = CASC_MAGIC_FIND;
+        hs = (ahs != NULL) ? ahs->AddRef() : NULL;
 
         // Init provider-specific data
         pCache = NULL;
@@ -440,7 +439,7 @@ struct TCascSearch
 //-----------------------------------------------------------------------------
 // Common functions (CascCommon.cpp)
 
-inline void FreeCascBlob(PQUERY_KEY pBlob)
+inline void FreeCascBlob(PCASC_BLOB pBlob)
 {
     if(pBlob != NULL)
     {
@@ -454,15 +453,18 @@ inline void FreeCascBlob(PQUERY_KEY pBlob)
 
 bool  InvokeProgressCallback(TCascStorage * hs, LPCSTR szMessage, LPCSTR szObject, DWORD CurrentValue, DWORD TotalValue);
 DWORD GetFileSpanInfo(PCASC_CKEY_ENTRY pCKeyEntry, PULONGLONG PtrContentSize, PULONGLONG PtrEncodedSize = NULL);
-DWORD DownloadFileFromCDN(TCascStorage * hs, CASC_CDN_DOWNLOAD & CdnsInfo);
-DWORD CheckGameDirectory(TCascStorage * hs, LPTSTR szDirectory);
-DWORD LoadCdnsFile(TCascStorage * hs);
-DWORD LoadBuildInfo(TCascStorage * hs);
+DWORD FetchCascFile(TCascStorage * hs, CPATH_TYPE PathType, LPBYTE pbEKey, LPCTSTR szExtension, CASC_PATH<TCHAR> & LocalPath, PCASC_ARCHIVE_INFO pArchiveInfo = NULL);
+DWORD CheckCascBuildFileExact(CASC_BUILD_FILE & BuildFile, LPCTSTR szLocalPath);
+DWORD CheckCascBuildFileDirs(CASC_BUILD_FILE & BuildFile, LPCTSTR szLocalPath);
+DWORD CheckOnlineStorage(PCASC_OPEN_STORAGE_ARGS pArgs, CASC_BUILD_FILE & BuildFile, DWORD dwFeatures);
+DWORD CheckArchiveFilesDirectories(TCascStorage * hs);
+DWORD CheckDataFilesDirectory(TCascStorage * hs);
+DWORD LoadMainFile(TCascStorage * hs);
 DWORD LoadCdnConfigFile(TCascStorage * hs);
 DWORD LoadCdnBuildFile(TCascStorage * hs);
 
-LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD * pcbFileData);
-LPBYTE LoadFileToMemory(LPCTSTR szFileName, DWORD * pcbFileData);
+DWORD LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, CASC_BLOB & FileData);
+DWORD LoadFileToMemory(LPCTSTR szFileName, CASC_BLOB & FileData);
 bool OpenFileByCKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD dwOpenFlags, HANDLE * PtrFileHandle);
 bool SetCacheStrategy(HANDLE hFile, CSTRTG CacheStrategy);
 
@@ -493,18 +495,19 @@ void  FreeIndexFiles(TCascStorage * hs);
 //-----------------------------------------------------------------------------
 // Support for ROOT file
 
-DWORD RootHandler_CreateMNDX(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
-DWORD RootHandler_CreateTVFS(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
-DWORD RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
-DWORD RootHandler_CreateWoW(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask);
-DWORD RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
-DWORD RootHandler_CreateStarcraft1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
-DWORD RootHandler_CreateInstall(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile);
+DWORD RootHandler_CreateMNDX(TCascStorage * hs, CASC_BLOB & RootFile);
+DWORD RootHandler_CreateTVFS(TCascStorage * hs, CASC_BLOB & RootFile);
+DWORD RootHandler_CreateDiablo3(TCascStorage * hs, CASC_BLOB & RootFile);
+DWORD RootHandler_CreateWoW(TCascStorage * hs, CASC_BLOB & RootFile, DWORD dwLocaleMask);
+DWORD RootHandler_CreateOverwatch(TCascStorage * hs, CASC_BLOB & RootFile);
+DWORD RootHandler_CreateStarcraft1(TCascStorage * hs, CASC_BLOB & RootFile);
+DWORD RootHandler_CreateInstall(TCascStorage * hs, CASC_BLOB & InstallFile);
 
 //-----------------------------------------------------------------------------
 // Dumpers (CascDumpData.cpp)
 
 #ifdef _DEBUG
+void CascDumpData(LPCSTR szFileName, const void * pvData, size_t cbData);
 void CascDumpFile(HANDLE hFile, const char * szDumpFile = NULL);
 void CascDumpStorage(HANDLE hStorage, const char * szDumpFile = NULL);
 #endif
diff --git a/dep/CascLib/src/CascDecompress.cpp b/dep/CascLib/src/CascDecompress.cpp
index 42c4758eb79..19d7d0a88c4 100644
--- a/dep/CascLib/src/CascDecompress.cpp
+++ b/dep/CascLib/src/CascDecompress.cpp
@@ -40,7 +40,7 @@ DWORD CascDecompress(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer,
     {
         // Call zlib to decompress the data
         nResult = inflate(&z, Z_NO_FLUSH);
-        if (nResult == Z_OK || nResult == Z_STREAM_END)
+        if(nResult == Z_OK || nResult == Z_STREAM_END)
         {
             // Give the size of the uncompressed data
             cbOutBuffer = z.total_out;
diff --git a/dep/CascLib/src/CascDecrypt.cpp b/dep/CascLib/src/CascDecrypt.cpp
index 3dbb5ce31a6..2eba7a5ebff 100644
--- a/dep/CascLib/src/CascDecrypt.cpp
+++ b/dep/CascLib/src/CascDecrypt.cpp
@@ -767,7 +767,7 @@ bool WINAPI CascAddEncryptionKey(HANDLE hStorage, ULONGLONG KeyName, LPBYTE Key)
 
     // Validate the storage handle
     hs = TCascStorage::IsValid(hStorage);
-    if (hs == NULL)
+    if(hs == NULL)
     {
         SetCascError(ERROR_INVALID_HANDLE);
         return false;
@@ -804,7 +804,7 @@ LPBYTE WINAPI CascFindEncryptionKey(HANDLE hStorage, ULONGLONG KeyName)
 
     // Validate the storage handle
     hs = TCascStorage::IsValid(hStorage);
-    if (hs == NULL)
+    if(hs == NULL)
     {
         SetCascError(ERROR_INVALID_HANDLE);
         return NULL;
@@ -819,7 +819,7 @@ bool WINAPI CascGetNotFoundEncryptionKey(HANDLE hStorage, ULONGLONG * KeyName)
     TCascStorage * hs;
 
     // Validate the storage handle
-    if ((hs = TCascStorage::IsValid(hStorage)) == NULL)
+    if((hs = TCascStorage::IsValid(hStorage)) == NULL)
     {
         SetCascError(ERROR_INVALID_HANDLE);
         return false;
diff --git a/dep/CascLib/src/CascDumpData.cpp b/dep/CascLib/src/CascDumpData.cpp
index 7a41d3da9f0..e29e93d093c 100644
--- a/dep/CascLib/src/CascDumpData.cpp
+++ b/dep/CascLib/src/CascDumpData.cpp
@@ -456,7 +456,18 @@ void DumpDownloadManifest(TCascStorage * hs, FILE * fp)
 //-----------------------------------------------------------------------------
 // Public dumping functions
 
-void CascDumpFile(const char * szDumpFile, HANDLE hFile)
+void CascDumpData(LPCSTR szFileName, const void * pvData, size_t cbData)
+{
+    FILE * fp;
+
+    if((fp = fopen(szFileName, "wb")) != NULL)
+    {
+        fwrite(pvData, 1, cbData, fp);
+        fclose(fp);
+    }
+}
+
+void CascDumpFile(HANDLE hFile, const char * szDumpFile)
 {
     FILE * fp;
     DWORD dwBytesRead = 1;
@@ -506,9 +517,8 @@ void CascDumpStorage(HANDLE hStorage, const char * szDumpFile)
         fprintf(fp, "=== Basic Storage Info ======================================================\n");
         fprintf(fp, "DataPath:  %s\n", StringFromLPTSTR(hs->szDataPath, szStringBuff, sizeof(szStringBuff)));
         fprintf(fp, "IndexPath: %s\n", StringFromLPTSTR(hs->szIndexPath, szStringBuff, sizeof(szStringBuff)));
-        fprintf(fp, "BuildFile: %s\n", StringFromLPTSTR(hs->szBuildFile, szStringBuff, sizeof(szStringBuff)));
+        fprintf(fp, "Main File: %s\n", StringFromLPTSTR(hs->szMainFile, szStringBuff, sizeof(szStringBuff)));
         fprintf(fp, "CDN Server: %s\n", StringFromLPTSTR(hs->szCdnServers, szStringBuff, sizeof(szStringBuff)));
-        fprintf(fp, "CDN Host Url: %s\n", StringFromLPTSTR(hs->szCdnHostUrl, szStringBuff, sizeof(szStringBuff)));
         fprintf(fp, "CDN Path: %s\n", StringFromLPTSTR(hs->szCdnPath, szStringBuff, sizeof(szStringBuff)));
         DumpKey(fp, "CDN Config Key: %s\n", hs->CdnConfigKey.pbData, hs->CdnConfigKey.cbData);
         DumpKey(fp, "CDN Build Key:  %s\n", hs->CdnBuildKey.pbData, hs->CdnBuildKey.cbData);
diff --git a/dep/CascLib/src/CascFiles.cpp b/dep/CascLib/src/CascFiles.cpp
index b18b8847a3d..f2546e1befa 100644
--- a/dep/CascLib/src/CascFiles.cpp
+++ b/dep/CascLib/src/CascFiles.cpp
@@ -20,11 +20,14 @@
 //-----------------------------------------------------------------------------
 // Local defines
 
-typedef DWORD (*PARSECSVFILE)(TCascStorage * hs, CASC_CSV & Csv);
-typedef DWORD (*PARSETEXTFILE)(TCascStorage * hs, void * pvListFile);
+#define MAX_VAR_NAME 80
+
+typedef DWORD (*PARSE_CSV_FILE)(TCascStorage * hs, CASC_CSV & Csv);
+typedef DWORD (*PARSE_TEXT_FILE)(TCascStorage * hs, void * pvListFile);
 typedef DWORD (*PARSE_VARIABLE)(TCascStorage * hs, const char * szVariableName, const char * szDataBegin, const char * szDataEnd, void * pvParam);
+typedef DWORD (*PARSE_REGION_LINE)(TCascStorage * hs, CASC_CSV & Csv, size_t nLine);
 
-#define MAX_VAR_NAME 80
+static DWORD RibbitDownloadFile(LPCTSTR szCdnHostUrl, LPCTSTR szProduct, LPCTSTR szFileName, CASC_PATH<TCHAR> & LocalPath, CASC_BLOB & FileData);
 
 //-----------------------------------------------------------------------------
 // Local structures
@@ -32,6 +35,7 @@ typedef DWORD (*PARSE_VARIABLE)(TCascStorage * hs, const char * szVariableName,
 struct TBuildFileInfo
 {
     LPCTSTR szFileName;
+    size_t  nLength;
     CBLD_TYPE BuildFileType;
 };
 
@@ -43,15 +47,14 @@ struct TGameLocaleString
 
 static const TBuildFileInfo BuildTypes[] =
 {
-    {_T(".build.info"), CascBuildInfo},             // Since HOTS build 30027, the game uses .build.info file for storage info
-    {_T(".build.db"),   CascBuildDb},               // Older CASC storages
-    {_T("versions"),    CascVersionsDb},            // Older CASC storages
-    {NULL, CascBuildNone}
+    {_T(".build.info"), 11, CascBuildInfo},         // Since HOTS build 30027, the game uses .build.info file for storage info
+    {_T(".build.db"),   9,  CascBuildDb},           // Older CASC storages
+    {_T("versions"),    8,  CascVersions},          // Online/cached CASC storages
 };
 
 static LPCTSTR DataDirs[] =
 {
-    _T("data") _T(PATH_SEP_STRING) _T("casc"),      // Overwatch
+    _T("data") _T(PATH_SEP_STRING) _T("casc"),      // Overwatch. This item must be the first in the list
     _T("data"),                                     // TACT casc (for Linux systems)
     _T("Data"),                                     // World of Warcraft, Diablo
     _T("SC2Data"),                                  // Starcraft II (Legacy of the Void) build 38749
@@ -61,6 +64,7 @@ static LPCTSTR DataDirs[] =
 };
 
 static const LPCTSTR szDefaultCDN = _T("ribbit://us.version.battle.net/v1/products");
+static const ULONGLONG ValueOne64 = 1;
 
 //-----------------------------------------------------------------------------
 // Local functions
@@ -85,6 +89,60 @@ static bool StringEndsWith(LPCSTR szString, size_t nLength, LPCSTR szSuffix, siz
     return ((nLength > nSuffixLength) && !strcmp(szString + nLength - nSuffixLength, szSuffix));
 }
 
+static LPCTSTR GetSubFolder(CPATH_TYPE PathType)
+{
+    switch(PathType)
+    {
+        case PathTypeConfig: return _T("config");
+        case PathTypeData:   return _T("data");
+        case PathTypePatch:  return _T("patch");
+        
+        default:
+            assert(false);
+            return _T("");
+    }
+}
+
+static bool CheckForTwoDigitFolder(LPCTSTR szPathName, void * pvContext)
+{
+    BYTE Binary[8];
+
+    // Must be a two-digit hexa string (the first two digits of the CKey)
+    if(_tcslen(szPathName) == 2)
+    {
+        if(BinaryFromString(szPathName, 2, Binary) == ERROR_SUCCESS)
+        {
+            *(bool *)pvContext = true;
+            return false;
+        }
+    }
+    
+    // Keep searching
+    return true;
+}
+
+static bool ReplaceVersionsWithCdns(LPTSTR szBuffer, size_t ccBuffer, LPCTSTR szVersions)
+{
+    LPCTSTR szVersions0 = _T("versions");
+    LPCTSTR szCdns0 = _T("cdns");
+    size_t nLength;
+
+    // Copy the existing file name into new buffer
+    CascStrCopy(szBuffer, ccBuffer, GetPlainFileName(szVersions));
+
+    // Find the ending "versions" string
+    if((nLength = _tcslen(szBuffer)) >= 8)
+    {
+        szBuffer = szBuffer + nLength - 8;
+        if(!_tcsicmp(szBuffer, szVersions0))
+        {
+            CascStrCopy(szBuffer, 5, szCdns0);
+            return true;
+        }
+    }
+    return false;
+}
+
 static const char * CaptureDecimalInteger(const char * szDataPtr, const char * szDataEnd, PDWORD PtrValue)
 {
     const char * szSaveDataPtr = szDataPtr;
@@ -147,7 +205,7 @@ static const char * CaptureSingleHash(const char * szDataPtr, const char * szDat
     szHashString = szDataPtr;
 
     // Count all hash characters
-    for (size_t i = 0; i < HashStringLength; i++)
+    for(size_t i = 0; i < HashStringLength; i++)
     {
         if(szDataPtr >= szDataEnd || isxdigit(szDataPtr[0]) == 0)
             return NULL;
@@ -252,7 +310,7 @@ static bool CheckConfigFileVariable(
 }
 
 static DWORD LoadHashArray(
-    PQUERY_KEY pBlob,
+    PCASC_BLOB pBlob,
     const char * szLinePtr,
     const char * szLineEnd,
     size_t HashCount)
@@ -266,7 +324,7 @@ static DWORD LoadHashArray(
     {
         LPBYTE pbBuffer = pBlob->pbData;
 
-        for (size_t i = 0; i < HashCount; i++)
+        for(size_t i = 0; i < HashCount; i++)
         {
             // Capture the hash value
             szLinePtr = CaptureSingleHash(szLinePtr, szLineEnd, pbBuffer, MD5_HASH_SIZE);
@@ -283,7 +341,7 @@ static DWORD LoadHashArray(
     return dwErrCode;
 }
 
-static DWORD LoadMultipleHashes(PQUERY_KEY pBlob, const char * szLineBegin, const char * szLineEnd)
+static DWORD LoadMultipleHashes(PCASC_BLOB pBlob, const char * szLineBegin, const char * szLineEnd)
 {
     size_t HashCount = 0;
     DWORD dwErrCode = ERROR_SUCCESS;
@@ -305,7 +363,7 @@ static DWORD LoadMultipleHashes(PQUERY_KEY pBlob, const char * szLineBegin, cons
 // A QueryKey is an array of "ContentKey EncodedKey1 ... EncodedKeyN"
 static DWORD LoadQueryKey(TCascStorage * /* hs */, const char * /* szVariableName */, const char * szDataBegin, const char * szDataEnd, void * pvParam)
 {
-    return LoadMultipleHashes((PQUERY_KEY)pvParam, szDataBegin, szDataEnd);
+    return LoadMultipleHashes((PCASC_BLOB)pvParam, szDataBegin, szDataEnd);
 }
 
 static DWORD LoadCKeyEntry(TCascStorage * hs, const char * szVariableName, const char * szDataPtr, const char * szDataEnd, void * pvParam)
@@ -488,7 +546,7 @@ static DWORD LoadBuildNumber(TCascStorage * hs, const char * /* szVariableName *
     return ERROR_BAD_FORMAT;
 }
 
-static int LoadQueryKey(const CASC_CSV_COLUMN & Column, QUERY_KEY & Key)
+static int LoadQueryKey(const CASC_CSV_COLUMN & Column, CASC_BLOB & Key)
 {
     // Check the input data
     if(Column.szValue == NULL)
@@ -507,13 +565,17 @@ static void SetProductCodeName(TCascStorage * hs, LPCSTR szCodeName)
     }
 }
 
+static DWORD GetDefaultCdnServers(TCascStorage * hs, const CASC_CSV_COLUMN & Column)
+{
+    if(hs->szCdnServers == NULL && Column.nLength != 0)
+        hs->szCdnServers = CascNewStrA2T(Column.szValue);
+    return ERROR_SUCCESS;
+}
+
 static DWORD GetDefaultCdnPath(TCascStorage * hs, const CASC_CSV_COLUMN & Column)
 {
     if(hs->szCdnPath == NULL && Column.nLength != 0)
-    {
         hs->szCdnPath = CascNewStrA2T(Column.szValue);
-    }
-
     return ERROR_SUCCESS;
 }
 
@@ -542,43 +604,6 @@ static DWORD GetDefaultLocaleMask(TCascStorage * hs, const CASC_CSV_COLUMN & Col
     return ERROR_SUCCESS;
 }
 
-static DWORD ParseFile_CDNS(TCascStorage * hs, CASC_CSV & Csv)
-{
-    const char * szWantedRegion = hs->szRegion;
-    const char * szRegion;
-    size_t nLineCount;
-
-    // Fix the region
-    if(szWantedRegion == NULL || !_stricmp(szWantedRegion, "beta") || !_stricmp(szWantedRegion, "xx"))
-        szWantedRegion = "us";
-
-    // Determine the row count
-    nLineCount = Csv.GetLineCount();
-
-    // Find the active config
-    for(size_t i = 0; i < nLineCount; i++)
-    {
-        // Retrieve the region
-        if((szRegion = Csv[i]["Name!STRING:0"].szValue) != NULL)
-        {
-            // Is it the version we are looking for?
-            if(!strcmp(Csv[i]["Name!STRING:0"].szValue, szWantedRegion))
-            {
-                // Save the list of CDN servers
-                hs->szCdnServers = CascNewStrA2T(Csv[i]["Hosts!STRING:0"].szValue);
-
-                // Save the CDN subpath
-                hs->szCdnPath = CascNewStrA2T(Csv[i]["Path!STRING:0"].szValue);
-
-                // Check and return result
-                return (hs->szCdnServers && hs->szCdnPath) ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
-            }
-        }
-    }
-
-    return ERROR_FILE_NOT_FOUND;
-}
-
 static DWORD ParseFile_BuildInfo(TCascStorage * hs, CASC_CSV & Csv)
 {
     PFNPRODUCTCALLBACK PfnProductCallback = hs->pArgs->PfnProductCallback;
@@ -677,12 +702,16 @@ static DWORD ParseFile_BuildInfo(TCascStorage * hs, CASC_CSV & Csv)
         if(dwErrCode != ERROR_SUCCESS)
             return dwErrCode;
 
-        // Get the CDN path
-        GetDefaultCdnPath(hs, Csv[nSelected]["CDN Path!STRING:0"]);
-
         // If we found tags, we can extract language build from it
         GetDefaultLocaleMask(hs, Csv[nSelected]["Tags!STRING:0"]);
 
+        // Get the CDN servers and hosts
+        if(hs->dwFeatures & CASC_FEATURE_ONLINE)
+        {
+            GetDefaultCdnServers(hs, Csv[nSelected]["CDN Hosts!STRING:0"]);
+            GetDefaultCdnPath(hs, Csv[nSelected]["CDN Path!STRING:0"]);
+        }
+
         // If we found version, extract a build number
         const CASC_CSV_COLUMN & VerColumn = Csv[nSelected]["Version!STRING:0"];
         if(VerColumn.szValue && VerColumn.nLength)
@@ -697,47 +726,47 @@ static DWORD ParseFile_BuildInfo(TCascStorage * hs, CASC_CSV & Csv)
     return ERROR_FILE_NOT_FOUND;
 }
 
-static DWORD ParseFile_VersionsDb(TCascStorage * hs, CASC_CSV & Csv)
+static DWORD ParseRegionLine_Versions(TCascStorage * hs, CASC_CSV & Csv, size_t nLine)
 {
-    size_t nLineCount = Csv.GetLineCount();
-    DWORD dwErrCode = ERROR_SUCCESS;
+    DWORD dwErrCode;
 
-    // Find the active config
-    for (size_t i = 0; i < nLineCount; i++)
-    {
-        // Either take the version required or take the first one
-        if(hs->szRegion == NULL || !strcmp(Csv[i]["Region!STRING:0"].szValue, hs->szRegion))
-        {
-            // Extract the CDN build key
-            dwErrCode = LoadQueryKey(Csv[i]["BuildConfig!HEX:16"], hs->CdnBuildKey);
-            if(dwErrCode != ERROR_SUCCESS)
-                return dwErrCode;
+    // If the region line is not there yet, supply default one
+    if(hs->szRegion == NULL)
+        hs->szRegion = CascNewStr(Csv[nLine]["Region!STRING:0"].szValue);
 
-            // Extract the CDN config key
-            dwErrCode = LoadQueryKey(Csv[i]["CDNConfig!HEX:16"], hs->CdnConfigKey);
-            if(dwErrCode != ERROR_SUCCESS)
-                return dwErrCode;
+    // Extract the CDN build key
+    dwErrCode = LoadQueryKey(Csv[nLine]["BuildConfig!HEX:16"], hs->CdnBuildKey);
+    if(dwErrCode != ERROR_SUCCESS)
+        return dwErrCode;
 
-            const CASC_CSV_COLUMN & VerColumn = Csv[i]["VersionsName!String:0"];
-            if(VerColumn.szValue && VerColumn.nLength)
-            {
-                LoadBuildNumber(hs, NULL, VerColumn.szValue, VerColumn.szValue + VerColumn.nLength, NULL);
-            }
+    // Extract the CDN config key
+    dwErrCode = LoadQueryKey(Csv[nLine]["CDNConfig!HEX:16"], hs->CdnConfigKey);
+    if(dwErrCode != ERROR_SUCCESS)
+        return dwErrCode;
 
-            // Verify all variables
-            if(hs->CdnBuildKey.pbData != NULL && hs->CdnConfigKey.pbData != NULL)
-            {
-                // If we have manually given build key, override the value
-                if(hs->szBuildKey != NULL)
-                    dwErrCode = BinaryFromString(hs->szBuildKey, MD5_STRING_SIZE, hs->CdnBuildKey.pbData);
-                return dwErrCode;
-            }
+    const CASC_CSV_COLUMN & VerColumn = Csv[nLine]["VersionsName!String:0"];
+    if(VerColumn.szValue && VerColumn.nLength)
+    {
+        LoadBuildNumber(hs, NULL, VerColumn.szValue, VerColumn.szValue + VerColumn.nLength, NULL);
+    }
 
-            return ERROR_BAD_FORMAT;
-        }
+    // Verify all variables
+    if(hs->CdnBuildKey.pbData != NULL && hs->CdnConfigKey.pbData != NULL)
+    {
+        // If we have manually given build key, override the value
+        if(hs->szBuildKey != NULL)
+            dwErrCode = BinaryFromString(hs->szBuildKey, MD5_STRING_SIZE, hs->CdnBuildKey.pbData);
+        return dwErrCode;
     }
 
-    return ERROR_FILE_NOT_FOUND;
+    return ERROR_BAD_FORMAT;
+}
+
+static DWORD ParseRegionLine_Cdns(TCascStorage * hs, CASC_CSV & Csv, size_t nLine)
+{
+    hs->szCdnServers = CascNewStrA2T(Csv[nLine]["Hosts!STRING:0"].szValue);
+    hs->szCdnPath = CascNewStrA2T(Csv[nLine]["Path!STRING:0"].szValue);
+    return (hs->szCdnServers && hs->szCdnPath) ? ERROR_SUCCESS : ERROR_FILE_NOT_FOUND;
 }
 
 static DWORD ParseFile_BuildDb(TCascStorage * hs, CASC_CSV & Csv)
@@ -870,109 +899,164 @@ static DWORD ParseFile_CdnBuild(TCascStorage * hs, void * pvListFile)
     return dwErrCode;
 }
 
-static DWORD CheckDataDirectory(TCascStorage * hs, LPTSTR szDirectory)
-{
-    TCHAR szDataPath[MAX_PATH];
-    DWORD dwErrCode = ERROR_FILE_NOT_FOUND;
-
-    // Try all known subdirectories
-    for(size_t i = 0; DataDirs[i] != NULL; i++)
-    {
-        // Create the eventual data path
-        CombinePath(szDataPath, _countof(szDataPath), szDirectory, DataDirs[i], NULL);
-
-        // Does that directory exist?
-        if(DirectoryExists(szDataPath))
-        {
-            hs->szRootPath = CascNewStr(szDirectory);
-            hs->szDataPath = CascNewStr(szDataPath);
-            return ERROR_SUCCESS;
-        }
-    }
-
-    return dwErrCode;
-}
-
-static DWORD LoadCsvFile(TCascStorage * hs, LPBYTE pbFileData, size_t cbFileData, PARSECSVFILE PfnParseProc, bool bHasHeader)
+// Loads a local CSV file
+static DWORD LoadCsvFile(TCascStorage * hs, LPCTSTR szFileName, PARSE_CSV_FILE PfnParseProc, bool bHasHeader)
 {
     CASC_CSV Csv(0x40, bHasHeader);
     DWORD dwErrCode;
 
     // Load the external file to memory
-    if((dwErrCode = Csv.Load(pbFileData, cbFileData)) == ERROR_SUCCESS)
+    if((dwErrCode = Csv.Load(szFileName)) == ERROR_SUCCESS)
         dwErrCode = PfnParseProc(hs, Csv);
     return dwErrCode;
 }
 
-static DWORD LoadCsvFile(TCascStorage * hs, LPCTSTR szFileName, PARSECSVFILE PfnParseProc, bool bHasHeader)
+// Loading an online file (VERSIONS or CDNS)
+static DWORD LoadCsvFile(TCascStorage * hs, PARSE_REGION_LINE PfnParseRegionLine, LPCTSTR szFileName, LPCSTR szColumnName, bool bForceDownload)
 {
-    CASC_CSV Csv(0x40, bHasHeader);
-    DWORD dwErrCode;
+    CASC_PATH<TCHAR> LocalPath;
+    CASC_BLOB FileData;
+    DWORD dwErrCode = ERROR_SUCCESS;
+    char szFileNameA[0x20];
 
-    // Load the external file to memory
-    if((dwErrCode = Csv.Load(szFileName)) == ERROR_SUCCESS)
-        dwErrCode = PfnParseProc(hs, Csv);
+    // Prepare the loading / downloading
+    LocalPath.SetPathRoot(hs->szRootPath);
+    LocalPath.AppendString(szFileName, true);
+    LocalPath.SetLocalCaching(bForceDownload == false);
+
+    // If the storage is defined as online, we can download the file, if it doesn't exist
+    if(hs->dwFeatures & CASC_FEATURE_ONLINE)
+    {
+        // Inform the user that we are downloading something
+        CascStrCopy(szFileNameA, _countof(szFileNameA), szFileName);
+        if(InvokeProgressCallback(hs, "Downloading the \"%s\" file", szFileNameA, 0, 0))
+            return ERROR_CANCELLED;
+
+        // Download the file using Ribbit/HTTP protocol
+        dwErrCode = RibbitDownloadFile(hs->szCdnHostUrl, hs->szCodeName, szFileName, LocalPath, FileData);
+    }
+    else
+    {
+        // Load the local file
+        dwErrCode = LoadFileToMemory(LocalPath, FileData);
+    }
+
+    // Load the VERSIONS file
+    if(dwErrCode == ERROR_SUCCESS)
+    {
+        CASC_CSV Csv(0x40, true);
+
+        // Load the external file to memory
+        if((dwErrCode = Csv.Load(FileData.pbData, FileData.cbData)) == ERROR_SUCCESS)
+        {
+            size_t nLineCount = Csv.GetLineCount();
+            size_t nRegionXX = CASC_INVALID_SIZE_T;
+            size_t nRegionUS = CASC_INVALID_SIZE_T;
+            size_t nRegionEU = CASC_INVALID_SIZE_T;
+
+            // Find a matching config
+            for(size_t i = 0; i < nLineCount; i++)
+            {
+                const char * szRegion = Csv[i][szColumnName].szValue;
+
+                if(hs->szRegion && szRegion && !strcmp(hs->szRegion, szRegion))
+                    return PfnParseRegionLine(hs, Csv, i);
+
+                if(szRegion != NULL)
+                {
+                    if(!strcmp(szRegion, "xx"))
+                    {
+                        nRegionXX = i;
+                        continue;
+                    }
+
+                    if(!strcmp(szRegion, "us"))
+                    {
+                        nRegionUS = i;
+                        continue;
+                    }
+
+                    if(!strcmp(szRegion, "eu"))
+                    {
+                        nRegionEU = i;
+                        continue;
+                    }
+                }
+            }
+
+            // Now load the regions in this order:
+            // 1) US region
+            // 2. EU region
+            // 3. XX region
+            // 4. The first line
+            if(nRegionUS != CASC_INVALID_SIZE_T)
+                return PfnParseRegionLine(hs, Csv, nRegionUS);
+            if(nRegionEU != CASC_INVALID_SIZE_T)
+                return PfnParseRegionLine(hs, Csv, nRegionEU);
+            if(nRegionXX != CASC_INVALID_SIZE_T)
+                return PfnParseRegionLine(hs, Csv, nRegionXX);
+            if(nLineCount != 0)
+                return PfnParseRegionLine(hs, Csv, 0);
+            dwErrCode = ERROR_FILE_NOT_FOUND;
+        }
+    }
     return dwErrCode;
 }
 
 static DWORD ForcePathExist(LPCTSTR szFileName, bool bIsFileName)
 {
-    LPTSTR szLocalPath;
-    size_t nIndex;
-    bool bFirstSeparator = false;
     DWORD dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
+    bool bFirstSeparator = false;
 
     // Sanity checks
     if(szFileName && szFileName[0])
     {
-        szLocalPath = CascNewStr(szFileName);
-        if(szLocalPath != NULL)
+        CASC_PATH<TCHAR> LocalPath(szFileName, NULL);
+
+        // Get the end of search
+        if(bIsFileName)
+            LocalPath.CutLastPart();
+
+        // Check whether the path exists
+        if(_taccess(LocalPath, 0) != 0)
         {
-            // Get the end of search
-            if(bIsFileName)
-                CutLastPathPart(szLocalPath);
+            LPTSTR szLocalPath = (LPTSTR)(LPCTSTR)LocalPath;
 
-            // Check the entire path
-            if(_taccess(szLocalPath, 0) != 0)
+            // Search the entire path
+            for(size_t nIndex = 0; nIndex < LocalPath.Length(); nIndex++)
             {
-                // Searth the entire path
-                for(nIndex = 0; szLocalPath[nIndex] != 0; nIndex++)
+                if(szLocalPath[nIndex] == '\\' || szLocalPath[nIndex] == '/')
                 {
-                    if(szLocalPath[nIndex] == '\\' || szLocalPath[nIndex] == '/')
-                    {
-                        // Cut the path and verify whether the folder/file exists
-                        szLocalPath[nIndex] = 0;
+                    // Cut the path and verify whether the folder/file exists
+                    szLocalPath[nIndex] = 0;
 
-                        // Skip the very first separator
-                        if(bFirstSeparator == true)
+                    // Skip the very first separator
+                    if(bFirstSeparator == true)
+                    {
+                        // Is it there?
+                        if(DirectoryExists(szLocalPath) == false && MakeDirectory(szLocalPath) == false)
                         {
-                            // Is it there?
-                            if(DirectoryExists(szLocalPath) == false && MakeDirectory(szLocalPath) == false)
-                            {
-                                dwErrCode = ERROR_PATH_NOT_FOUND;
-                                break;
-                            }
+                            dwErrCode = ERROR_PATH_NOT_FOUND;
+                            break;
                         }
-
-                        // Restore the character
-                        szLocalPath[nIndex] = PATH_SEP_CHAR;
-                        bFirstSeparator = true;
-                        dwErrCode = ERROR_SUCCESS;
                     }
-                }
 
-                // Now check the final path
-                if(DirectoryExists(szLocalPath) || MakeDirectory(szLocalPath))
-                {
+                    // Restore the character
+                    szLocalPath[nIndex] = PATH_SEP_CHAR;
+                    bFirstSeparator = true;
                     dwErrCode = ERROR_SUCCESS;
                 }
             }
-            else
+
+            // Now check the final path
+            if(DirectoryExists(szLocalPath) || MakeDirectory(szLocalPath))
             {
                 dwErrCode = ERROR_SUCCESS;
             }
-
-            CASC_FREE(szLocalPath);
+        }
+        else
+        {
+            dwErrCode = ERROR_SUCCESS;
         }
     }
 
@@ -1029,78 +1113,87 @@ static LPCTSTR ExtractCdnServerName(LPTSTR szServerName, size_t cchServerName, L
     return NULL;
 }
 
-static void CreateRemoteAndLocalPath(TCascStorage * hs, CASC_CDN_DOWNLOAD & CdnsInfo, CASC_PATH<TCHAR> & RemotePath, CASC_PATH<TCHAR> & LocalPath)
+static bool FileAlreadyExists(LPCTSTR szFileName)
 {
-    PCASC_EKEY_ENTRY pEKeyEntry;
-    ULONGLONG ByteMask = 1;
-    DWORD ArchiveIndex;
-
-    // Append the CDN host / root folder
-    RemotePath.SetPathRoot(CdnsInfo.szCdnsHost);
-    RemotePath.AppendString(CdnsInfo.szCdnsPath, true);
-    LocalPath.SetPathRoot(hs->szRootPath);
-
-    // If there is an EKey, take EKey
-    if(CdnsInfo.pbEKey != NULL)
-    {
-        // The file is given by EKey. It's either a loose file, or it's stored in an archive.
-        // We check that using the EKey map
-        if((pEKeyEntry = (PCASC_EKEY_ENTRY)hs->IndexMap.FindObject(CdnsInfo.pbEKey)) != NULL)
-        {
-            // Change the path type to "data"
-            RemotePath.AppendString(_T("data"), true);
-            LocalPath.AppendString(_T("data"), true);
-
-            // Append the EKey of the archive instead of the file itself
-            ArchiveIndex = (DWORD)(pEKeyEntry->StorageOffset >> hs->FileOffsetBits);
-            CdnsInfo.pbArchiveKey = hs->ArchivesKey.pbData + (MD5_HASH_SIZE * ArchiveIndex);
-            RemotePath.AppendEKey(CdnsInfo.pbArchiveKey);
-            LocalPath.AppendEKey(CdnsInfo.pbArchiveKey);
-
-            // Get the archive index and archive offset
-            CdnsInfo.ArchiveIndex = ArchiveIndex;
-            CdnsInfo.ArchiveOffs = pEKeyEntry->StorageOffset & ((ByteMask << hs->FileOffsetBits) - 1);
-            CdnsInfo.EncodedSize = pEKeyEntry->EncodedSize;
-        }
-        else
-        {
-            // Append the path type
-            RemotePath.AppendString(CdnsInfo.szPathType, true);
-            LocalPath.AppendString((CdnsInfo.szLoPaType != NULL) ? CdnsInfo.szLoPaType : CdnsInfo.szPathType, true);
+    TFileStream * pStream;
+    ULONGLONG FileSize = 0;
 
-            // Append the EKey
-            RemotePath.AppendEKey(CdnsInfo.pbEKey);
-            LocalPath.AppendEKey(CdnsInfo.pbEKey);
-        }
-    }
-    else
+    // The file open must succeed and also must be of non-zero size
+    if((pStream = FileStream_OpenFile(szFileName, 0)) != NULL)
     {
-        assert(CdnsInfo.szFileName != NULL);
-        RemotePath.AppendString(CdnsInfo.szFileName, true);
-        LocalPath.AppendString(CdnsInfo.szFileName, true);
+        FileStream_GetSize(pStream, &FileSize);
+        FileStream_Close(pStream);
     }
 
-    // Append extension
-    RemotePath.AppendString(CdnsInfo.szExtension, false);
-    LocalPath.AppendString(CdnsInfo.szExtension, false);
+    return (FileSize != 0);
 }
 
-static bool FileAlreadyExists(LPCTSTR szFileName)
+static DWORD RibbitDownloadFile(LPCTSTR szCdnHostUrl, LPCTSTR szProduct, LPCTSTR szFileName, CASC_PATH<TCHAR> & LocalPath, CASC_BLOB & FileData)
 {
+    CASC_PATH<TCHAR> LocalFile;
     TFileStream * pStream;
     ULONGLONG FileSize = 0;
+    TCHAR szRemoteUrl[256];
+    DWORD dwErrCode = ERROR_CAN_NOT_COMPLETE;
 
-    // The file open must succeed and also must be of non-zero size
-    if((pStream = FileStream_OpenFile(szFileName, 0)) != NULL)
+    // If required, try to load the local name first
+    if(LocalPath.Length() && LocalPath.LocalCaching())
     {
-        FileStream_GetSize(pStream, &FileSize);
+        // Load the local file into memory
+        if((dwErrCode = LoadFileToMemory(LocalPath, FileData)) == ERROR_SUCCESS)
+        {
+            // Pass the file data to the caller
+            return ERROR_SUCCESS;
+        }
+    }
+
+    // Supply the default CDN URL, if not present
+    if(szCdnHostUrl == NULL || szCdnHostUrl[0] == 0)
+        szCdnHostUrl = szDefaultCDN;
+
+    // Construct the full URL (https://wowdev.wiki/Ribbit)
+    // Old (HTTP) download: wget http://us.patch.battle.net:1119/wow_classic/cdns
+    CascStrPrintf(szRemoteUrl, _countof(szRemoteUrl), _T("%s/%s/%s"), szCdnHostUrl, szProduct, szFileName);
+
+    // Open the file stream
+    if((pStream = FileStream_OpenFile(szRemoteUrl, 0)) != NULL)
+    {
+        if(FileStream_GetSize(pStream, &FileSize) && FileSize <= 0x04000000)
+        {
+            // Fill-in the file pointer and size
+            if((dwErrCode = FileData.SetSize((size_t)FileSize)) == ERROR_SUCCESS)
+            {
+                if(FileStream_Read(pStream, NULL, FileData.pbData, (DWORD)FileSize))
+                {
+                    dwErrCode = ERROR_SUCCESS;
+                }
+                else
+                {
+                    dwErrCode = GetCascError();
+                    FileData.Free();
+                }
+            }
+        }
+        else
+        {
+            dwErrCode = GetCascError();
+        }
+
+        // Close the remote stream
         FileStream_Close(pStream);
     }
+    else
+    {
+        dwErrCode = GetCascError();
+    }
 
-    return (FileSize != 0);
+    // Save the file to the local cache
+    if(LocalPath.Length() && FileData.pbData && FileData.cbData && dwErrCode == ERROR_SUCCESS)
+        SaveLocalFile(LocalPath, FileData.pbData, FileData.cbData);
+    return dwErrCode;
 }
 
-static DWORD DownloadFile(
+static DWORD HttpDownloadFile(
     LPCTSTR szRemoteName,
     LPCTSTR szLocalName,
     PULONGLONG PtrByteOffset,
@@ -1162,208 +1255,161 @@ static DWORD DownloadFile(
     return dwErrCode;
 }
 
-static DWORD RibbitDownloadFile(LPCTSTR szCdnHostUrl, LPCTSTR szProduct, LPCTSTR szFileName, CASC_PATH<TCHAR> & LocalPath, QUERY_KEY & FileData)
+DWORD FetchCascFile(
+    TCascStorage * hs,
+    LPCTSTR szRootPath,
+    CPATH_TYPE PathType,
+    LPBYTE pbEKey,
+    LPCTSTR szExtension,
+    CASC_PATH<TCHAR> & LocalPath)
 {
-    CASC_PATH<TCHAR> LocalFile;
-    TFileStream * pStream;
-    ULONGLONG FileSize = 0;
-    TCHAR szRemoteUrl[256];
-    DWORD dwErrCode = ERROR_CAN_NOT_COMPLETE;
+    LPCTSTR szCdnServers = hs->szCdnServers;
+    DWORD dwErrCode = ERROR_SUCCESS;
+    TCHAR szCdnServer[MAX_PATH] = _T("");
 
-    // If required, try to load the local name first
-    if(LocalPath.Length() && LocalPath.LocalCaching())
+    // First, construct the local path
+    LocalPath.Create(szRootPath, GetSubFolder(PathType), NULL);
+    LocalPath.AppendEKey(pbEKey);
+    LocalPath.AppendString(szExtension, false);
+
+    // Check whether the file already exists
+    if(!FileAlreadyExists(LocalPath))
     {
-        LPBYTE pbFileData;
-        DWORD cbFileData = 0;
+        // If this is not an online version, do nothing and return error
+        if(!(hs->dwFeatures & CASC_FEATURE_ONLINE))
+            return ERROR_FILE_NOT_FOUND;
 
-        // Load the local file into memory
-        pbFileData = LoadFileToMemory(LocalPath, &cbFileData);
-        if(pbFileData && cbFileData)
+        // Force-create the local path
+        if((dwErrCode = ForcePathExist(LocalPath, true)) != ERROR_SUCCESS)
+            return dwErrCode;
+
+        // Try all download servers
+        while((szCdnServers = ExtractCdnServerName(szCdnServer, _countof(szCdnServer), szCdnServers)) != NULL)
         {
-            // Pass the file data to the caller
-            FileData.pbData = pbFileData;
-            FileData.cbData = cbFileData;
-            return ERROR_SUCCESS;
-        }
-    }
+            CASC_PATH<TCHAR> RemotePath(URL_SEP_CHAR);
 
-    // Supply the default CDN URL, if not present
-    if(szCdnHostUrl == NULL || szCdnHostUrl[0] == 0)
-        szCdnHostUrl = szDefaultCDN;
+            // Construct the full remote URL path
+            RemotePath.Create(szCdnServer, hs->szCdnPath, GetSubFolder(PathType), NULL);
+            RemotePath.AppendEKey(pbEKey);
+            RemotePath.AppendString(szExtension, false);
 
-    // Construct the full URL (https://wowdev.wiki/Ribbit)
-    // Old (HTTP) download: wget http://us.patch.battle.net:1119/wow_classic/cdns
-    CascStrPrintf(szRemoteUrl, _countof(szRemoteUrl), _T("%s/%s/%s"), szCdnHostUrl, szProduct, szFileName);
+            // Attempt to download the file
+            dwErrCode = HttpDownloadFile(RemotePath, LocalPath, NULL, 0, 0);
 
-    // Open the file stream
-    if((pStream = FileStream_OpenFile(szRemoteUrl, 0)) != NULL)
-    {
-        if(FileStream_GetSize(pStream, &FileSize) && FileSize <= 0x04000000)
-        {
-            // Fill-in the file pointer and size
-            FileData.pbData = CASC_ALLOC<BYTE>((size_t)FileSize);
-            if(FileData.pbData != NULL)
-            {
-                if(FileStream_Read(pStream, NULL, FileData.pbData, (DWORD)FileSize))
-                {
-                    FileData.cbData = (size_t)FileSize;
-                    dwErrCode = ERROR_SUCCESS;
-                }
-                else
-                {
-                    dwErrCode = GetCascError();
-                    CASC_FREE(FileData.pbData);
-                    FileData.pbData = NULL;
-                }
-            }
-            else
-            {
-                dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
-            }
-        }
-        else
-        {
-            dwErrCode = GetCascError();
+            // Stop on low memory condition, as it will most likely
+            // end up with low memory on next download
+            if(dwErrCode == ERROR_SUCCESS || dwErrCode == ERROR_NOT_ENOUGH_MEMORY)
+                return dwErrCode;
         }
-
-        // Close the remote stream
-        FileStream_Close(pStream);
-    }
-    else
-    {
-        dwErrCode = GetCascError();
+        
+        // Sorry, the file was not found
+        dwErrCode = ERROR_FILE_NOT_FOUND;
     }
-
-    // Save the file to the local cache
-    if(LocalPath.Length() && FileData.pbData && FileData.cbData && dwErrCode == ERROR_SUCCESS)
-        SaveLocalFile(LocalPath, FileData.pbData, FileData.cbData);
     return dwErrCode;
 }
 
-static DWORD DownloadFileFromCDN2(TCascStorage * hs, CASC_CDN_DOWNLOAD & CdnsInfo)
+DWORD FetchCascFile(TCascStorage * hs, CPATH_TYPE PathType, LPBYTE pbEKey, LPCTSTR szExtension, CASC_PATH<TCHAR> & LocalPath, PCASC_ARCHIVE_INFO pArchiveInfo)
 {
-    CASC_PATH<TCHAR> RemotePath(URL_SEP_CHAR);
-    CASC_PATH<TCHAR> LocalPath(PATH_SEP_CHAR);
-    DWORD dwErrCode;
-
-    // Assemble both the remote and local path
-    assert(CdnsInfo.szCdnsHost != NULL && CdnsInfo.szCdnsHost[0] != 0);
-    CreateRemoteAndLocalPath(hs, CdnsInfo, RemotePath, LocalPath);
+    PCASC_EKEY_ENTRY pEKeyEntry;
+    LPBYTE pbArchiveKey;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
-    // Check whether the local file exists
-    if((CdnsInfo.Flags & CASC_CDN_FORCE_DOWNLOAD) || !FileAlreadyExists(LocalPath))
+    // Data files may be stored in archives, therefore we need to check
+    if((pbEKey != NULL) && (pEKeyEntry = (PCASC_EKEY_ENTRY)hs->IndexMap.FindObject(pbEKey)) != NULL)
     {
-        // Make sure that the path exists
-        dwErrCode = ForcePathExist(LocalPath, true);
-        if(dwErrCode != ERROR_SUCCESS)
-            return dwErrCode;
-
-        // Attempt to download the file
-        dwErrCode = DownloadFile(RemotePath, LocalPath, NULL, 0, 0);
-        if(dwErrCode != ERROR_SUCCESS)
-            return dwErrCode;
+        // Can't complete if the caller doesn't know the archive info
+        if(pArchiveInfo != NULL)
+        {
+            // Fill-in the archive info
+            pArchiveInfo->ArchiveIndex = (DWORD)(pEKeyEntry->StorageOffset >> hs->FileOffsetBits);
+            pArchiveInfo->ArchiveOffs = (DWORD)(pEKeyEntry->StorageOffset & ((ValueOne64 << hs->FileOffsetBits) - 1));
+            pArchiveInfo->EncodedSize = pEKeyEntry->EncodedSize;
+
+            // Fill-in the archive key
+            pbArchiveKey = pbEKey = hs->ArchivesKey.pbData + (MD5_HASH_SIZE * pArchiveInfo->ArchiveIndex);
+            memcpy(pArchiveInfo->ArchiveKey, pbArchiveKey, MD5_HASH_SIZE);
+            
+            // Remap the path type to "data"
+            PathType = PathTypeData;
+        }
+        else
+        {
+            dwErrCode = ERROR_CAN_NOT_COMPLETE;
+        }
     }
 
-    // Give the path to the caller, if any
-    LocalPath.Copy(CdnsInfo.szLocalPath, CdnsInfo.ccLocalPath);
-    return ERROR_SUCCESS;
-}
-
-DWORD DownloadFileFromCDN(TCascStorage * hs, CASC_CDN_DOWNLOAD & CdnsInfo)
-{
-    LPCTSTR szCdnServers = hs->szCdnServers;
-    TCHAR szCdnHost[MAX_PATH] = _T("");
-    DWORD dwErrCode = ERROR_CAN_NOT_COMPLETE;
-
-    // If we have a given CDN server, use it. If not, try all CDNs
-    // from the storage's configuration
-    if(CdnsInfo.szCdnsHost == NULL)
+    if(dwErrCode == ERROR_SUCCESS)
     {
-        // Supply the CDN host
-        CdnsInfo.szCdnsHost = szCdnHost;
+        // Try the local archives
+        if(hs->dwFeatures & CASC_FEATURE_DATA_ARCHIVES)
+        {
+            dwErrCode = FetchCascFile(hs, hs->szDataPath, PathType, pbEKey, szExtension, LocalPath);
+            if(dwErrCode == ERROR_SUCCESS)
+                return ERROR_SUCCESS;
+        }
 
-        // Try all download servers
-        while((szCdnServers = ExtractCdnServerName(szCdnHost, _countof(szCdnHost), szCdnServers)) != NULL)
+        // Try to download the file into the "data/<type>" path
+        if(hs->szDataPath != NULL)
         {
-            // Attempt to download the file from the remote server
-            dwErrCode = DownloadFileFromCDN2(hs, CdnsInfo);
-            
-            // If the download succeeded, exit immediately.
-            // Also exit when there is a low memory condition,
-            // as it will most likely end up with low memory on next download
-            if(dwErrCode == ERROR_SUCCESS || dwErrCode == ERROR_NOT_ENOUGH_MEMORY)
-                break;
+            dwErrCode = FetchCascFile(hs, hs->szDataPath, PathType, pbEKey, szExtension, LocalPath);
+            if(dwErrCode == ERROR_SUCCESS)
+                return ERROR_SUCCESS;
         }
 
-        // Don't give the local buffer pointer to the caller
-        CdnsInfo.szCdnsHost = NULL;
-    }
-    else
-    {
-        dwErrCode = DownloadFileFromCDN2(hs, CdnsInfo);
+        // Try to download the file into the "<type>" path
+        if(hs->szRootPath != NULL)
+        {
+            dwErrCode = FetchCascFile(hs, hs->szRootPath, PathType, pbEKey, szExtension, LocalPath);
+            if(dwErrCode == ERROR_SUCCESS)
+                return ERROR_SUCCESS;
+        }
     }
-
     return dwErrCode;
 }
 
-static DWORD FetchAndLoadConfigFile(TCascStorage * hs, PQUERY_KEY pFileKey, PARSETEXTFILE PfnParseProc)
+static DWORD FetchAndLoadConfigFile(TCascStorage * hs, PCASC_BLOB pFileKey, PARSE_TEXT_FILE PfnParseProc)
 {
-    LPCTSTR szPathType = _T("config");
-    TCHAR szLocalPath[MAX_PATH];
-    TCHAR szSubDir[0x80] = _T("");
+    CASC_PATH<TCHAR> LocalPath;
     void * pvListFile = NULL;
-    DWORD dwErrCode = ERROR_CAN_NOT_COMPLETE;
-
-    // If online storage, we download the file. Otherwise, create a local path
-    if(hs->dwFeatures & CASC_FEATURE_ONLINE)
-    {
-        CASC_CDN_DOWNLOAD CdnsInfo = {0};
-
-        // Prepare the download structure for "%CDNS_HOST%/%CDNS_PATH%/##/##/EKey" file
-        CdnsInfo.szCdnsPath = hs->szCdnPath;
-        CdnsInfo.szPathType = szPathType;
-        CdnsInfo.pbEKey = pFileKey->pbData;
-        CdnsInfo.szLocalPath = szLocalPath;
-        CdnsInfo.ccLocalPath = _countof(szLocalPath);
-
-        // Download the config file
-        dwErrCode = DownloadFileFromCDN(hs, CdnsInfo);
-        if(dwErrCode != ERROR_SUCCESS)
-            return dwErrCode;
-    }
-    else
-    {
-        CASC_PATH<TCHAR> Path;
-
-        Path.AppendString(hs->szDataPath, false);
-        Path.AppendString(szSubDir, true);
-        Path.AppendString(szPathType, true);
-        Path.AppendEKey(pFileKey->pbData);
-        Path.Copy(szLocalPath, _countof(szLocalPath));
-    }
+    DWORD dwErrCode;
 
-    // Load and verify the external listfile
-    pvListFile = ListFile_OpenExternal(szLocalPath);
-    if(pvListFile != NULL)
+    // Make sure there is a local copy of the file
+    dwErrCode = FetchCascFile(hs, PathTypeConfig, pFileKey->pbData, NULL, LocalPath);
+    if(dwErrCode == ERROR_SUCCESS)
     {
-        if(ListFile_VerifyMD5(pvListFile, pFileKey->pbData))
+        // Load and verify the external listfile
+        pvListFile = ListFile_OpenExternal(LocalPath);
+        if(pvListFile != NULL)
         {
-            dwErrCode = PfnParseProc(hs, pvListFile);
+            if(ListFile_VerifyMD5(pvListFile, pFileKey->pbData))
+            {
+                dwErrCode = PfnParseProc(hs, pvListFile);
+            }
+            else
+            {
+                dwErrCode = ERROR_FILE_CORRUPT;
+            }
+            CASC_FREE(pvListFile);
         }
         else
         {
-            dwErrCode = ERROR_FILE_CORRUPT;
+            dwErrCode = ERROR_FILE_NOT_FOUND;
         }
-        CASC_FREE(pvListFile);
-    }
-    else
-    {
-        dwErrCode = ERROR_FILE_NOT_FOUND;
     }
-
     return dwErrCode;
 }
 
+static LPTSTR CheckForDirectory(LPCTSTR szParentFolder, LPCTSTR szSubFolder)
+{
+    CASC_PATH<TCHAR> LocalPath(szParentFolder, szSubFolder, NULL);
+    LPTSTR szLocalPath = NULL;
+
+    // Check whether the path exists
+    if(DirectoryExists(LocalPath))
+        szLocalPath = LocalPath.New();
+    return szLocalPath;
+}
+
 //-----------------------------------------------------------------------------
 // Public functions
 
@@ -1408,128 +1454,220 @@ DWORD GetFileSpanInfo(PCASC_CKEY_ENTRY pCKeyEntry, PULONGLONG PtrContentSize, PU
     return dwSpanCount;
 }
 
-// Checks whether there is a ".build.info" or ".build.db".
-// If yes, the function sets "szDataPath" and "szIndexPath"
-// in the storage structure and returns ERROR_SUCCESS
-DWORD CheckGameDirectory(TCascStorage * hs, LPTSTR szDirectory)
+DWORD CheckCascBuildFileExact(CASC_BUILD_FILE & BuildFile, LPCTSTR szLocalPath)
 {
+    // Calculate the length of the local path
     TFileStream * pStream;
-    TCHAR szBuildFile[MAX_PATH];
-    DWORD dwErrCode = ERROR_FILE_NOT_FOUND;
+    LPCTSTR szFileType;
+    size_t nLength = _tcslen(szLocalPath);
 
-    // Try to find any of the root files used in the history
-    for (size_t i = 0; BuildTypes[i].szFileName != NULL; i++)
-    {
-        // Create the full name of the .agent.db file
-        CombinePath(szBuildFile, _countof(szBuildFile), szDirectory, BuildTypes[i].szFileName, NULL);
+    // Clear the build file structure
+    memset(&BuildFile, 0, sizeof(CASC_BUILD_FILE));
 
-        // Attempt to open the file
-        pStream = FileStream_OpenFile(szBuildFile, STREAM_FLAG_READ_ONLY);
-        if(pStream != NULL)
+    // Check every type of the build file
+    for(size_t i = 0; i < _countof(BuildTypes); i++)
+    {
+        // We support any file name with the appropriate ending,
+        // for example wow-19342.build.info or wow-47186.versions
+        szFileType = szLocalPath + nLength - BuildTypes[i].nLength;
+        if(!_tcsicmp(BuildTypes[i].szFileName, szFileType))
         {
-            // Free the stream
-            FileStream_Close(pStream);
-
-            // Check for the data directory
-            dwErrCode = CheckDataDirectory(hs, szDirectory);
-            if(dwErrCode == ERROR_SUCCESS)
+            // We also try to open the file
+            if((pStream = FileStream_OpenFile(szLocalPath, 0)) != NULL)
             {
-                hs->szBuildFile = CascNewStr(szBuildFile);
-                hs->BuildFileType = BuildTypes[i].BuildFileType;
+                CascStrCopy(BuildFile.szFullPath, _countof(BuildFile.szFullPath), szLocalPath);
+                BuildFile.szPlainName = GetPlainFileName(BuildFile.szFullPath);
+                BuildFile.BuildFileType = BuildTypes[i].BuildFileType;
+                FileStream_Close(pStream);
                 return ERROR_SUCCESS;
             }
         }
     }
 
-    return dwErrCode;
+    // Unrecognized file name
+    return ERROR_BAD_FORMAT;
 }
 
-DWORD LoadBuildInfo(TCascStorage * hs)
+DWORD CheckCascBuildFileDirs(CASC_BUILD_FILE & BuildFile, LPCTSTR szLocalPath)
 {
-    PARSECSVFILE PfnParseProc = NULL;
-    DWORD dwErrCode;
-    bool bHasHeader = true;
+    CASC_PATH<TCHAR> WorkPath(szLocalPath, NULL);
+    DWORD dwErrCode = ERROR_FILE_NOT_FOUND;
+
+    // Clear the build file structure
+    memset(&BuildFile, 0, sizeof(CASC_BUILD_FILE));
 
-    // We support ".build.info", ".build.db" or "versions"
-    switch (hs->BuildFileType)
+    for(;;)
     {
-        case CascBuildInfo:
-            PfnParseProc = ParseFile_BuildInfo;
-            break;
+        // Try all supported build file types
+        for(size_t i = 0; i < _countof(BuildTypes); i++)
+        {
+            CASC_PATH<TCHAR> FilePath(WorkPath, BuildTypes[i].szFileName, NULL);
 
-        case CascVersionsDb:
-            PfnParseProc = ParseFile_VersionsDb;
-            break;
+            // If the file exists there, we found it
+            if(CheckCascBuildFileExact(BuildFile, FilePath) == ERROR_SUCCESS)
+            {
+                return ERROR_SUCCESS;
+            }
+        }
 
-        case CascBuildDb:
-            PfnParseProc = ParseFile_BuildDb;
-            bHasHeader = false;
+        // Try to cut off one path path
+        if(!WorkPath.CutLastPart())
+        {
+            dwErrCode = ERROR_PATH_NOT_FOUND;
             break;
-
-        default:
-            return ERROR_NOT_SUPPORTED;
+        }
     }
 
-    // If the storage is online storage, we need to download "versions"
-    if(hs->dwFeatures & CASC_FEATURE_ONLINE)
+    // Unrecognized file name
+    return dwErrCode;
+}
+
+DWORD CheckOnlineStorage(PCASC_OPEN_STORAGE_ARGS pArgs, CASC_BUILD_FILE & BuildFile, DWORD dwFeatures)
+{
+    // If the online storage is required, we try to extract the product code
+    if((dwFeatures & CASC_FEATURE_ONLINE) && (pArgs->szCodeName != NULL))
     {
-        CASC_PATH<TCHAR> LocalPath;
-        QUERY_KEY FileData;
-        LPCTSTR szVersionsName = _T("versions");
+        CASC_PATH<TCHAR> FilePath(pArgs->szLocalPath, _T("versions"), NULL);
 
-        // Inform the user about loading the build.info/build.db/versions
-        if(InvokeProgressCallback(hs, "Downloading the \"versions\" file", NULL, 0, 0))
-            return ERROR_CANCELLED;
+        FilePath.CopyTo(BuildFile.szFullPath, _countof(BuildFile.szFullPath));
+        BuildFile.szPlainName = GetPlainFileName(BuildFile.szFullPath);
+        BuildFile.BuildFileType = CascVersions;
+        return ERROR_SUCCESS;
+    }
+    return ERROR_FILE_NOT_FOUND;
+}
 
-        // Shall we prefer the locally cached file?
-        LocalPath.SetPathRoot(hs->szRootPath);
-        LocalPath.AppendString(szVersionsName, true);
-        LocalPath.SetLocalCaching(hs->dwFeatures & CASC_FEATURE_LOCAL_VERSIONS);
+DWORD CheckArchiveFilesDirectories(TCascStorage * hs)
+{
+    // Sanity checks
+    assert((hs->dwFeatures & CASC_FEATURE_DATA_ARCHIVES) != 0);
+    assert(hs->szRootPath != NULL);
+    assert(hs->szDataPath == NULL);
+    assert(hs->szIndexPath == NULL);
 
-        // Download the file using Ribbit/HTTP protocol
-        dwErrCode = RibbitDownloadFile(hs->szCdnHostUrl, hs->szCodeName, szVersionsName, LocalPath, FileData);
-        if(dwErrCode == ERROR_SUCCESS)
+    LPTSTR szDataPath = NULL;
+    LPTSTR szConfigPath = NULL;
+    LPTSTR szIndexPath = NULL;
+
+    // Try all known subdirectories for the game data sub dirs
+    for(size_t i = 0; i < _countof(DataDirs); i++)
+    {
+        if((szDataPath = CheckForDirectory(hs->szRootPath, DataDirs[i])) != NULL)
         {
-            // Parse the downloaded file
-            dwErrCode = LoadCsvFile(hs, FileData.pbData, FileData.cbData, ParseFile_VersionsDb, true);
+            // If we found the data path, we also need to initialize the index path
+
+            // Check the config folder
+            if((szConfigPath = CheckForDirectory(szDataPath, _T("config"))) != NULL)
+            {
+                // First, check for more common "data" subdirectory
+                if((szIndexPath = CheckForDirectory(szDataPath, _T("data"))) == NULL)
+                {
+                    // Second, try the "darch" subdirectory (older builds of HOTS - Alpha)
+                    szIndexPath = CheckForDirectory(szDataPath, _T("darch"));
+                }
+
+                if(szIndexPath != NULL)
+                {
+                    hs->szDataPath = szDataPath;
+                    hs->szConfigPath = szConfigPath;
+                    hs->szIndexPath = szIndexPath;
+                    return ERROR_SUCCESS;
+                }
+            }
         }
-    }
-    else
-    {
-        assert(hs->szBuildFile != NULL);
-        dwErrCode = LoadCsvFile(hs, hs->szBuildFile, PfnParseProc, bHasHeader);
+
+        CASC_FREE(szDataPath);
+        CASC_FREE(szConfigPath);
+        CASC_FREE(szIndexPath);
     }
 
-    return dwErrCode;
+    // One of the paths was not found
+    return ERROR_FILE_NOT_FOUND;
 }
 
-DWORD LoadCdnsFile(TCascStorage * hs)
+DWORD CheckDataFilesDirectory(TCascStorage * hs)
 {
-    CASC_PATH<TCHAR> LocalPath;
-    QUERY_KEY FileData;
-    LPCTSTR szCdnsName = _T("cdns");
-    DWORD dwErrCode = ERROR_SUCCESS;
+    CASC_PATH<TCHAR> DataPath(hs->szRootPath, _T("data"), NULL);
+    bool bTwoDigitFolderFound = false;
 
-    // Sanity checks
-    assert(hs->dwFeatures & CASC_FEATURE_ONLINE);
+    // When CASC_FEATURE_ONLINE is not set, then the folder must exist
+    if((hs->dwFeatures & CASC_FEATURE_ONLINE) == 0)
+    {
+        // Check if there are subfolders at all. If not, do not bother
+        // the file system with open requests into data files folder
+        if(ScanDirectory(DataPath, CheckForTwoDigitFolder, NULL, &bTwoDigitFolderFound) != ERROR_SUCCESS)
+            return ERROR_PATH_NOT_FOUND;
 
-    // Inform the user about what we are doing
-    if(InvokeProgressCallback(hs, "Downloading the \"cdns\" file", NULL, 0, 0))
-        return ERROR_CANCELLED;
+        if(bTwoDigitFolderFound == false)
+            return ERROR_PATH_NOT_FOUND;
+    }
 
-    // Construct the local path of the file
-    LocalPath.SetPathRoot(hs->szRootPath);
-    LocalPath.AppendString(szCdnsName, true);
-    LocalPath.SetLocalCaching(hs->dwFeatures & CASC_FEATURE_LOCAL_CDNS);
+    // Create the path for raw files
+    if((hs->szFilesPath = DataPath.New()) == NULL)
+        return ERROR_NOT_ENOUGH_MEMORY;
+    return ERROR_SUCCESS;
+}
+
+DWORD LoadBuildFile_Versions_Cdns(TCascStorage * hs)
+{
+    LPCTSTR szVersions = _T("versions");
+    DWORD dwErrCode;
+    TCHAR szBuffer[MAX_PATH];
+    bool bForceDownload = (hs->dwFeatures & CASC_FEATURE_FORCE_DOWNLOAD) ? true : false;
 
-    // Download the file using Ribbit protocol
-    dwErrCode = RibbitDownloadFile(hs->szCdnHostUrl, hs->szCodeName, szCdnsName, LocalPath, FileData);
+    // The default name of the build file is "versions". However, the caller may select different file
+    if(hs->szMainFile && hs->szMainFile[0])
+        szVersions = GetPlainFileName(hs->szMainFile);
+    dwErrCode = LoadCsvFile(hs, ParseRegionLine_Versions, szVersions, "Region!STRING:0", bForceDownload);
+
+    // We also need to load the "cdns" file
     if(dwErrCode == ERROR_SUCCESS)
     {
-        // Parse the downloaded file
-        dwErrCode = LoadCsvFile(hs, FileData.pbData, FileData.cbData, ParseFile_CDNS, true);
+        // The default CDNS file is "cdns". However, if the build file is different, we change "cdns" as well
+        // Example: If the build file name is "hearthstone-25.0.3.160183.159202.versions", then we want "hearthstone-25.0.3.160183.159202.cdns"
+        if(hs->szMainFile && hs->szMainFile[0])
+        {
+            if(ReplaceVersionsWithCdns(szBuffer, _countof(szBuffer), hs->szMainFile))
+            {
+                dwErrCode = LoadCsvFile(hs, ParseRegionLine_Cdns, szBuffer, "Name!STRING:0", bForceDownload);
+                if(dwErrCode == ERROR_SUCCESS)
+                    return dwErrCode;
+            }
+        }
+
+        // Fall back to the default "cdns" file
+        dwErrCode = LoadCsvFile(hs, ParseRegionLine_Cdns, _T("cdns"), "Name!STRING:0", bForceDownload);
     }
+    return dwErrCode;
+}
+
+DWORD LoadMainFile(TCascStorage * hs)
+{
+    DWORD dwErrCode = ERROR_NOT_SUPPORTED;
 
+    // The build file must be known at this point, even for online storage
+    // that are to bo created
+    assert(hs->szMainFile != NULL);
+
+    // Perform support for each build file type
+    switch(hs->BuildFileType)
+    {
+        case CascBuildDb:       // Older storages have "build.db"
+            dwErrCode = LoadCsvFile(hs, hs->szMainFile, ParseFile_BuildDb, false);
+            break;
+
+        case CascBuildInfo:     // Current storages have "build.db"
+            dwErrCode = LoadCsvFile(hs, hs->szMainFile, ParseFile_BuildInfo, true);
+            break;
+
+        case CascVersions:      // Online storages have "versions+cdns"
+            dwErrCode = LoadBuildFile_Versions_Cdns(hs);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
     return dwErrCode;
 }
 
@@ -1560,9 +1698,8 @@ DWORD LoadCdnBuildFile(TCascStorage * hs)
     return FetchAndLoadConfigFile(hs, &hs->CdnBuildKey, ParseFile_CdnBuild);
 }
 
-LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD * pcbFileData)
+DWORD LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, CASC_BLOB & FileData)
 {
-    LPBYTE pbFileData = NULL;
     HANDLE hFile = NULL;
     DWORD dwFileSizeHi = 0;
     DWORD cbFileData = 0;
@@ -1594,11 +1731,10 @@ LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry,
         if(dwErrCode == ERROR_SUCCESS)
         {
             // Allocate space for the ENCODING file
-            pbFileData = CASC_ALLOC<BYTE>(cbFileData);
-            if(pbFileData != NULL)
+            if((dwErrCode = FileData.SetSize(cbFileData)) == ERROR_SUCCESS)
             {
                 // Read the entire file to memory
-                CascReadFile(hFile, pbFileData, cbFileData, &dwBytesRead);
+                CascReadFile(hFile, FileData.pbData, cbFileData, &dwBytesRead);
                 if(dwBytesRead != cbFileData)
                 {
                     dwErrCode = ERROR_FILE_CORRUPT;
@@ -1620,27 +1756,15 @@ LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry,
 
     // Handle errors
     if(dwErrCode != ERROR_SUCCESS)
-    {
-        // Free the file data
-        CASC_FREE(pbFileData);
-        cbFileData = 0;
-
-        // Set the last error
-        SetCascError(dwErrCode);
-    }
-
-    // Give the loaded file length
-    if(pcbFileData != NULL)
-        *pcbFileData = cbFileData;
-    return pbFileData;
+        FileData.Free();
+    return dwErrCode;
 }
 
-LPBYTE LoadFileToMemory(LPCTSTR szFileName, DWORD * pcbFileData)
+DWORD LoadFileToMemory(LPCTSTR szFileName, CASC_BLOB & FileData)
 {
     TFileStream * pStream;
     ULONGLONG FileSize = 0;
-    LPBYTE pbFileData = NULL;
-    DWORD cbFileData = 0;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // Open the stream for read-only access and read the file
     pStream = FileStream_OpenFile(szFileName, STREAM_FLAG_READ_ONLY | STREAM_FLAG_WRITE_SHARE | STREAM_PROVIDER_FLAT | BASE_PROVIDER_FILE);
@@ -1648,47 +1772,44 @@ LPBYTE LoadFileToMemory(LPCTSTR szFileName, DWORD * pcbFileData)
     {
         // Retrieve the file size
         FileStream_GetSize(pStream, &FileSize);
-        cbFileData = (DWORD)FileSize;
 
         // Do not load zero files or too large files
         if(0 < FileSize && FileSize <= 0x2000000)
         {
             // Allocate file data buffer. Make it 1 byte longer
             // so string functions can put '\0' there
-            pbFileData = CASC_ALLOC<BYTE>(cbFileData + 1);
-            if(pbFileData != NULL)
+            dwErrCode = FileData.SetSize((size_t)(FileSize));
+            if(dwErrCode == ERROR_SUCCESS)
             {
-                if(FileStream_Read(pStream, NULL, pbFileData, cbFileData))
+                if(FileStream_Read(pStream, NULL, FileData.pbData, (DWORD)(FileData.cbData)))
                 {
                     // Terminate the data with zero so various string-based functions can process it
-                    pbFileData[cbFileData] = 0;
+                    FileData.pbData[FileData.cbData] = 0;
                 }
                 else
                 {
-                    CASC_FREE(pbFileData);
-                    cbFileData = 0;
+                    dwErrCode = GetCascError();
                 }
             }
             else
             {
-                SetCascError(ERROR_NOT_ENOUGH_MEMORY);
-                cbFileData = 0;
+                dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
             }
         }
         else
         {
-            SetCascError(ERROR_BAD_FORMAT);
-            cbFileData = 0;
+            dwErrCode = ERROR_BAD_FORMAT;
         }
 
         // Close the file stream
         FileStream_Close(pStream);
     }
-
-    // Give out values
-    if(pcbFileData != NULL)
-        pcbFileData[0] = cbFileData;
-    return pbFileData;
+    else
+    {
+        dwErrCode = GetCascError();
+    }
+    
+    return dwErrCode;
 }
 
 //-----------------------------------------------------------------------------
@@ -1702,7 +1823,7 @@ LPCTSTR WINAPI CascCdnGetDefault()
 LPBYTE WINAPI CascCdnDownload(LPCTSTR szCdnHostUrl, LPCTSTR szProduct, LPCTSTR szFileName, DWORD * PtrSize)
 {
     CASC_PATH<TCHAR> LocalPath;
-    QUERY_KEY FileData;
+    CASC_BLOB FileData;
     LPBYTE pbFileData = NULL;
     size_t cbFileData = 0;
     DWORD dwErrCode;
diff --git a/dep/CascLib/src/CascIndexFiles.cpp b/dep/CascLib/src/CascIndexFiles.cpp
index 98416c2b360..45649eaa623 100644
--- a/dep/CascLib/src/CascIndexFiles.cpp
+++ b/dep/CascLib/src/CascIndexFiles.cpp
@@ -27,21 +27,40 @@ typedef bool (*EKEY_ENTRY_CALLBACK)(TCascStorage * hs, CASC_INDEX_HEADER & InHea
 //-----------------------------------------------------------------------------
 // Local functions
 
-// "data.iXY"
+// Check a file name with mask
+static bool IsFileNameMask(LPCTSTR szFileName, LPCTSTR szMask)
+{
+    size_t i;
+
+    for(i = 0; szFileName[i] != 0 && szMask[i] != 0; i++)
+    {
+        // '#' in the mask means any hexa number
+        if(szMask[i] == _T('#'))
+        {
+            if(!IsHexadecimalDigit(szFileName[i]))
+                return false;
+            continue;
+        }
+
+        // Compare both characters, converted to lowercase
+        if(AsciiToUpperTable_BkSlash[(BYTE)(szMask[i])] != AsciiToUpperTable_BkSlash[(BYTE)(szFileName[i])])
+            return false;
+    }
+
+    // If we found end of both strings, it's a match
+    return (szFileName[i] == 0 && szMask[i] == 0);
+}
+
+// Heroes of the Storm, build 29049: "data.i##"
 static bool IsIndexFileName_V1(LPCTSTR szFileName)
 {
-    // Check if the name looks like a valid index file
-    return (_tcslen(szFileName) == 8 &&
-            _tcsnicmp(szFileName, _T("data.i"), 6) == 0 &&
-            _tcsspn(szFileName + 6, szAllowedHexChars) == 2);
+    return IsFileNameMask(szFileName, _T("data.i##"));
 }
 
+// Current CASC storages: ##########.idx
 static bool IsIndexFileName_V2(LPCTSTR szFileName)
 {
-    // Check if the name looks like a valid index file
-    return (_tcslen(szFileName) == 14 &&
-            _tcsspn(szFileName, _T("0123456789aAbBcCdDeEfF")) == 0x0A &&
-            _tcsicmp(szFileName + 0x0A, _T(".idx")) == 0);
+    return IsFileNameMask(szFileName, _T("##########.idx"));
 }
 
 static bool IndexDirectory_OnFileFound(
@@ -61,32 +80,32 @@ static bool IndexDirectory_OnFileFound(
         else if(IsIndexFileName_V1(szFileName))
             hs->szIndexFormat = szIndexFormat_V1;
         else
-            return false;
+            return true;
     }
 
     if(hs->szIndexFormat == szIndexFormat_V2)
     {
         // Check the index file name format
         if(!IsIndexFileName_V2(szFileName))
-            return false;
+            return true;
 
         // Get the main index from the first two digits
         if(ConvertStringToInt(szFileName + 0, 2, IndexValue) != ERROR_SUCCESS)
-            return false;
+            return true;
         if(ConvertStringToInt(szFileName + 2, 8, IndexVersion) != ERROR_SUCCESS)
-            return false;
+            return true;
     }
     else if(hs->szIndexFormat == szIndexFormat_V1)
     {
         // Check the index file name format
         if(!IsIndexFileName_V1(szFileName))
-            return false;
+            return true;
 
         // Get the main index from the first two digits
         if(ConvertStringToInt(szFileName + 6, 1, IndexValue) != ERROR_SUCCESS)
-            return false;
+            return true;
         if(ConvertStringToInt(szFileName + 7, 1, IndexVersion) != ERROR_SUCCESS)
-            return false;
+            return true;
     }
     else
     {
@@ -118,7 +137,6 @@ static bool IndexDirectory_OnFileFound(
 
 static LPTSTR CreateIndexFileName(TCascStorage * hs, DWORD IndexValue, DWORD IndexVersion)
 {
-    TCHAR szFullName[MAX_PATH];
     TCHAR szPlainName[0x40];
 
     // Sanity checks
@@ -126,12 +144,11 @@ static LPTSTR CreateIndexFileName(TCascStorage * hs, DWORD IndexValue, DWORD Ind
     assert(hs->szIndexPath != NULL);
     assert(IndexValue <= 0x0F);
 
-    // Create the full path
+    // Create the plain name of the index file
     CascStrPrintf(szPlainName, _countof(szPlainName), hs->szIndexFormat, IndexValue, IndexVersion);
-    CombinePath(szFullName, _countof(szFullName), hs->szIndexPath, szPlainName, NULL);
 
-    // Return allocated path
-    return CascNewStr(szFullName);
+    // Allocate path
+    return CASC_PATH<TCHAR>(hs->szIndexPath, szPlainName, NULL).New();
 }
 
 static void SaveFileOffsetBitsAndEKeyLength(TCascStorage * hs, BYTE FileOffsetBits, BYTE EKeyLength)
@@ -177,9 +194,9 @@ static LPBYTE CaptureGuardedBlock2(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t E
 
     // Check the guarded block. There must be enough bytes to contain FILE_INDEX_GUARDED_BLOCK
     // and also the block length must not be NULL
-    if ((pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK)) >= pbFileEnd)
+    if((pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK)) >= pbFileEnd)
         return NULL;
-    if (pBlock->BlockSize == 0 || (pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK) + pBlock->BlockSize) > pbFileEnd)
+    if(pBlock->BlockSize == 0 || (pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK) + pBlock->BlockSize) > pbFileEnd)
         return NULL;
 
     //
@@ -188,17 +205,17 @@ static LPBYTE CaptureGuardedBlock2(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t E
 
     pbEntryPtr = pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK);
     EntryCount = pBlock->BlockSize / EntryLength;
-    for (size_t i = 0; i < EntryCount; i++)
+    for(size_t i = 0; i < EntryCount; i++)
     {
         hashlittle2(pbEntryPtr, EntryLength, &HashHigh, &HashLow);
         pbEntryPtr += EntryLength;
     }
 
     // Verify hash
-    if (HashHigh == pBlock->BlockHash)
+    if(HashHigh == pBlock->BlockHash)
     {
         // Give the output
-        if (PtrBlockSize != NULL)
+        if(PtrBlockSize != NULL)
             PtrBlockSize[0] = pBlock->BlockSize;
         return (LPBYTE)(pBlock + 1);
     }
@@ -211,17 +228,17 @@ static LPBYTE CaptureGuardedBlock2(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t E
 
     pbEntryPtr = pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK);
     EntryCount = pBlock->BlockSize / EntryLength;
-    for (size_t i = 0; i < EntryCount; i++)
+    for(size_t i = 0; i < EntryCount; i++)
     {
         HashBlizzGet = hashlittle(pbEntryPtr, EntryLength, HashBlizzGet);
         pbEntryPtr += EntryLength;
     }
 
     // Verify hash
-    if (HashBlizzGet == pBlock->BlockHash)
+    if(HashBlizzGet == pBlock->BlockHash)
     {
         // Give the output
-        if (PtrBlockSize != NULL)
+        if(PtrBlockSize != NULL)
             PtrBlockSize[0] = pBlock->BlockSize;
         return (LPBYTE)(pBlock + 1);
     }
@@ -239,9 +256,9 @@ static LPBYTE CaptureGuardedBlock3(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t E
 
     // Check the guarded block. There must be enough bytes to contain single entry and the hash
     // Also, the hash must be present
-    if ((pbFileData + sizeof(DWORD) + EntryLength) >= pbFileEnd)
+    if((pbFileData + sizeof(DWORD) + EntryLength) >= pbFileEnd)
         return NULL;
-    if (PtrEntryHash[0] == 0)
+    if(PtrEntryHash[0] == 0)
         return NULL;
 
     EntryHash = hashlittle(pbFileData + sizeof(DWORD), EntryLength+1, 0) | 0x80000000;
@@ -251,69 +268,7 @@ static LPBYTE CaptureGuardedBlock3(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t E
     // Give the output
     return (LPBYTE)(PtrEntryHash + 1);
 }
-/*
-static bool CaptureIndexEntry(CASC_INDEX_HEADER & InHeader, PCASC_EKEY_ENTRY pEKeyEntry, LPBYTE pbEKeyEntry)
-{
-    // Copy the EKey of the variable length
-    pbEKeyEntry = CaptureEncodedKey(pEKeyEntry->EKey, pbEKeyEntry, InHeader.EKeyLength);
-
-    // Copy the storage offset and encoded size
-    pEKeyEntry->StorageOffset = ConvertBytesToInteger_5(pbEKeyEntry);
-    pEKeyEntry->EncodedSize = ConvertBytesToInteger_4_LE(pbEKeyEntry + InHeader.StorageOffsetLength);
-    pEKeyEntry->Alignment = 0;
-
-    // We ignore items that have EncodedSize of 0x1E
-    return (pEKeyEntry->EncodedSize > FIELD_OFFSET(BLTE_ENCODED_HEADER, Signature));
-}
 
-static void InsertCKeyEntry(TCascStorage * hs, CASC_EKEY_ENTRY & EKeyEntry, DWORD Flags)
-{
-    PCASC_CKEY_ENTRY pCKeyEntry;
-
-    // Multiple items with the same EKey in the index files may exist.
-    // Example: "2018 - New CASC\00001", EKey 37 89 16 5b 2d cc 71 c1 25 00 00 00 00 00 00 00
-    // Positions: 0x1D, 0x1E, 0x1F
-    // In that case, we only take the first one into account
-    // BREAK_ON_XKEY3(EKeyEntry.EKey, 0x09, 0xF3, 0xCD);
-
-    // If the item is not there yet, insert a new one
-    if((pCKeyEntry = FindCKeyEntry_EKey(hs, EKeyEntry.EKey)) == NULL)
-    {
-        // Insert a new entry to the array. DO NOT ALLOW enlarge array here
-        pCKeyEntry = (PCASC_CKEY_ENTRY)hs->CKeyArray.Insert(1, false);
-        if(pCKeyEntry == NULL)
-            return;
-
-        // Fill-in the information
-        ZeroMemory16(pCKeyEntry->CKey);
-        CopyMemory16(pCKeyEntry->EKey, EKeyEntry.EKey);
-        pCKeyEntry->StorageOffset = EKeyEntry.StorageOffset;
-        pCKeyEntry->TagBitMask = 0;
-        pCKeyEntry->ContentSize = CASC_INVALID_SIZE;
-        pCKeyEntry->EncodedSize = EKeyEntry.EncodedSize;
-        pCKeyEntry->Flags = CASC_CE_HAS_EKEY | CASC_CE_HAS_EKEY_PARTIAL;
-        pCKeyEntry->RefCount = 0;
-        pCKeyEntry->SpanCount = 1;
-        pCKeyEntry->Priority = 0;
-
-        // Insert the item to the EKey table
-        hs->EKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->EKey);
-    }
-    else
-    {
-        // The entry already exists. True e.g. for ENCODING.
-        // Only copy the storage offset and sizes if not available yet
-        if(pCKeyEntry->StorageOffset == CASC_INVALID_OFFS64)
-        {
-            pCKeyEntry->StorageOffset = EKeyEntry.StorageOffset;
-            pCKeyEntry->EncodedSize = EKeyEntry.EncodedSize;
-        }
-    }
-
-    // Add the extra flag
-    pCKeyEntry->Flags |= Flags;
-}
-*/
 static DWORD LoadIndexItems(TCascStorage * hs, CASC_INDEX_HEADER & InHeader, EKEY_ENTRY_CALLBACK PfnEKeyEntry, LPBYTE pbEKeyEntry, LPBYTE pbEKeyEnd)
 {
     size_t EntryLength = InHeader.EntryLength;
@@ -539,7 +494,7 @@ static DWORD ProcessLocalIndexFiles(TCascStorage * hs, EKEY_ENTRY_CALLBACK PfnEK
         }
 
         // Load the index file
-        if((dwErrCode = LoadIndexFile(hs, PfnEKeyEntry, IndexFile.pbFileData, IndexFile.cbFileData, i)) != ERROR_SUCCESS)
+        if((dwErrCode = LoadIndexFile(hs, PfnEKeyEntry, IndexFile.FileData.pbData, IndexFile.FileData.cbData, i)) != ERROR_SUCCESS)
             break;
     }
 
@@ -563,7 +518,7 @@ static DWORD LoadLocalIndexFiles(TCascStorage * hs)
         return ERROR_CANCELLED;
 
     // Perform the directory scan
-    if((dwErrCode = ScanIndexDirectory(hs->szIndexPath, IndexDirectory_OnFileFound, hs)) == ERROR_SUCCESS)
+    if((dwErrCode = ScanDirectory(hs->szIndexPath, NULL, IndexDirectory_OnFileFound, hs)) == ERROR_SUCCESS)
     {
         // If no index file was found, we cannot load anything
         if(hs->szIndexFormat == NULL)
@@ -573,14 +528,14 @@ static DWORD LoadLocalIndexFiles(TCascStorage * hs)
         for(DWORD i = 0; i < CASC_INDEX_COUNT; i++)
         {
             CASC_INDEX & IndexFile = hs->IndexFiles[i];
-            DWORD cbFileData = 0;
 
             // Create the file name
             if((IndexFile.szFileName = CreateIndexFileName(hs, i, IndexFile.NewSubIndex)) == NULL)
                 return ERROR_NOT_ENOUGH_MEMORY;
 
             // WoW6 actually reads THE ENTIRE file to memory. Verified on Mac build (x64).
-            if((IndexFile.pbFileData = LoadFileToMemory(IndexFile.szFileName, &cbFileData)) == NULL)
+            dwErrCode = LoadFileToMemory(IndexFile.szFileName, IndexFile.FileData);
+            if(dwErrCode != ERROR_SUCCESS)
             {
                 // Storages downloaded by Blizzget tool don't have all index files present
                 if((dwErrCode = GetCascError()) == ERROR_FILE_NOT_FOUND)
@@ -588,13 +543,11 @@ static DWORD LoadLocalIndexFiles(TCascStorage * hs)
                     dwErrCode = ERROR_SUCCESS;
                     break;
                 }
-
                 return dwErrCode;
             }
 
             // Add to the total size of the index files
-            IndexFile.cbFileData = cbFileData;
-            TotalSize += cbFileData;
+            TotalSize += IndexFile.FileData.cbData;
             dwIndexCount++;
         }
 
@@ -613,7 +566,7 @@ static DWORD LoadLocalIndexFiles(TCascStorage * hs)
 // Online index files
 // https://wowdev.wiki/TACT#CDN_File_Organization
 
-static DWORD CaptureArcIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbIndexFile, DWORD cbIndexFile)
+static DWORD CaptureArchiveIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbIndexFile, size_t cbIndexFile)
 {
     FILE_INDEX_FOOTER<0x08> * pFooter08;
     BYTE checksum_data[0x40] = { 0 };
@@ -625,7 +578,7 @@ static DWORD CaptureArcIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbInd
 
     // Check the variant for checksum == 0x08
     pFooter08 = (FILE_INDEX_FOOTER<0x08> *)(pbIndexFile + cbIndexFile - sizeof(FILE_INDEX_FOOTER<0x08>));
-    if (pFooter08->Version == 1 && pFooter08->Reserved[0] == 0 && pFooter08->Reserved[1] == 0 && pFooter08->FooterHashBytes == 8)
+    if(pFooter08->Version == 1 && pFooter08->Reserved[0] == 0 && pFooter08->Reserved[1] == 0 && pFooter08->FooterHashBytes == 8)
     {
         // Copy the entire structure
         memcpy(InFooter.TocHash, pFooter08->TocHash, MD5_HASH_SIZE);
@@ -635,7 +588,7 @@ static DWORD CaptureArcIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbInd
         InFooter.SizeBytes = pFooter08->SizeBytes;
         InFooter.EKeyLength = pFooter08->EKeyLength;
         InFooter.FooterHashBytes = pFooter08->FooterHashBytes;
-        InFooter.PageLength = pFooter08->PageSizeKB << 10;
+        InFooter.PageLength = ((size_t)pFooter08->PageSizeKB) << 10;
         InFooter.ItemLength = pFooter08->EKeyLength + pFooter08->OffsetBytes + pFooter08->SizeBytes;
         InFooter.FooterLength = sizeof(FILE_INDEX_FOOTER<0x08>);
         InFooter.ElementCount = ConvertBytesToInteger_4_LE(pFooter08->ElementCount);
@@ -647,8 +600,6 @@ static DWORD CaptureArcIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbInd
         if(!memcmp(md5_hash, InFooter.FooterHash, InFooter.FooterHashBytes))
             return ERROR_SUCCESS;
     }
-
-    assert(false);
     return ERROR_BAD_FORMAT;
 }
 
@@ -658,7 +609,7 @@ static DWORD CaptureIndexEntry(CASC_ARCINDEX_FOOTER  & InFooter, CASC_EKEY_ENTRY
     ULONGLONG ArchiveOffset;
 
     // If there enough bytes for one entry/
-    if ((pbIndexPage + InFooter.ItemLength) > pbIndexPageEnd)
+    if((pbIndexPage + InFooter.ItemLength) > pbIndexPageEnd)
         return ERROR_BAD_FORMAT;
 
     // Capture the EKey (variable length)
@@ -666,7 +617,7 @@ static DWORD CaptureIndexEntry(CASC_ARCINDEX_FOOTER  & InFooter, CASC_EKEY_ENTRY
 
     // Copy the archive offset
     ArchiveOffset = ConvertBytesToInteger_X(pbIndexPage + InFooter.SizeBytes, InFooter.OffsetBytes);
-    if (ArchiveOffset >= 0x10000000)
+    if(ArchiveOffset >= 0x10000000)
         return ERROR_BAD_FORMAT;
 
     // Capture the storage offset and encoded size
@@ -705,7 +656,7 @@ static DWORD LoadArchiveIndexPage(TCascStorage * hs, CASC_ARCINDEX_FOOTER & InFo
     {
         // Capture the index entry
         dwErrCode = CaptureIndexEntry(InFooter, EKeyEntry, pbIndexPage, pbIndexPageEnd, nArchive);
-        if (dwErrCode != ERROR_SUCCESS)
+        if(dwErrCode != ERROR_SUCCESS)
             break;
 
         // Insert a new entry to the index array
@@ -719,15 +670,15 @@ static DWORD LoadArchiveIndexPage(TCascStorage * hs, CASC_ARCINDEX_FOOTER & InFo
     return ERROR_SUCCESS;
 }
 
-static DWORD LoadArchiveIndexFile(TCascStorage * hs, LPBYTE pbIndexFile, DWORD cbIndexFile, size_t nArchive)
+static DWORD LoadArchiveIndexFile(TCascStorage * hs, LPBYTE pbIndexFile, size_t cbIndexFile, size_t nArchive)
 {
     CASC_ARCINDEX_FOOTER InFooter;
     LPBYTE pbIndexEnd = NULL;
     DWORD dwErrCode;
 
     // Validate and capture the footer
-    dwErrCode = CaptureArcIndexFooter(InFooter, pbIndexFile, cbIndexFile);
-    if (dwErrCode != ERROR_SUCCESS)
+    dwErrCode = CaptureArchiveIndexFooter(InFooter, pbIndexFile, cbIndexFile);
+    if(dwErrCode != ERROR_SUCCESS)
         return dwErrCode;
 
     // Remember the file offset and EKey length
@@ -735,7 +686,7 @@ static DWORD LoadArchiveIndexFile(TCascStorage * hs, LPBYTE pbIndexFile, DWORD c
 
     // Verify the size of the index file
     dwErrCode = VerifyIndexSize(InFooter, pbIndexFile, cbIndexFile, &pbIndexEnd);
-    if (dwErrCode != ERROR_SUCCESS)
+    if(dwErrCode != ERROR_SUCCESS)
         return dwErrCode;
 
     // Parse all pages
@@ -743,7 +694,7 @@ static DWORD LoadArchiveIndexFile(TCascStorage * hs, LPBYTE pbIndexFile, DWORD c
     {
         // Load the entire page
         dwErrCode = LoadArchiveIndexPage(hs, InFooter, pbIndexFile, pbIndexFile + InFooter.PageLength, nArchive);
-        if (dwErrCode != ERROR_SUCCESS)
+        if(dwErrCode != ERROR_SUCCESS)
             break;
 
         // Move to the next page
@@ -761,16 +712,16 @@ static DWORD BuildMapOfArchiveIndices(TCascStorage * hs)
 
     // Create the map
     dwErrCode = hs->IndexMap.Create(nItemCount, MD5_HASH_SIZE, FIELD_OFFSET(CASC_EKEY_ENTRY, EKey));
-    if (dwErrCode != ERROR_SUCCESS)
+    if(dwErrCode != ERROR_SUCCESS)
         return dwErrCode;
 
     // Insert all items
     for(size_t i = 0; i < nItemCount; i++)
     {
         pEKeyEntry = (PCASC_EKEY_ENTRY)hs->IndexArray.ItemAt(i);
-        if (pEKeyEntry != NULL)
+        if(pEKeyEntry != NULL)
         {
-            if (!hs->IndexMap.InsertObject(pEKeyEntry, pEKeyEntry->EKey))
+            if(!hs->IndexMap.InsertObject(pEKeyEntry, pEKeyEntry->EKey))
             {
                 return ERROR_NOT_ENOUGH_MEMORY;
             }
@@ -782,21 +733,19 @@ static DWORD BuildMapOfArchiveIndices(TCascStorage * hs)
 
 static DWORD LoadArchiveIndexFiles(TCascStorage * hs)
 {
-    LPBYTE pbFileData;
-    TCHAR szLocalPath[MAX_PATH];
-    DWORD cbFileData = 0;
+    CASC_BLOB FileData;
     size_t nArchiveCount = (hs->ArchivesKey.cbData / MD5_HASH_SIZE);
     DWORD dwErrCode = ERROR_SUCCESS;
 
     // Create the array object for the indices
     dwErrCode = hs->IndexArray.Create(sizeof(CASC_EKEY_ENTRY), 0x10000);
-    if (dwErrCode != ERROR_SUCCESS)
+    if(dwErrCode != ERROR_SUCCESS)
         return dwErrCode;
 
     // Load all the indices
-    for (size_t i = 0; i < nArchiveCount; i++)
+    for(size_t i = 0; i < nArchiveCount; i++)
     {
-        CASC_CDN_DOWNLOAD CdnsInfo = {0};
+        CASC_PATH<TCHAR> LocalPath;
         LPBYTE pbIndexHash = hs->ArchivesKey.pbData + (i * MD5_HASH_SIZE);
 
         // Inform the user about what we are doing
@@ -806,34 +755,24 @@ static DWORD LoadArchiveIndexFiles(TCascStorage * hs)
             break;
         }
 
-        // Prepare the download structure for "%CDNS_HOST%/%CDNS_PATH%/##/##/EKey" file
-        CdnsInfo.szCdnsPath = hs->szCdnPath;
-        CdnsInfo.szPathType = _T("data");
-        CdnsInfo.pbEKey = pbIndexHash;
-        CdnsInfo.szExtension = _T(".index");
-        CdnsInfo.szLocalPath = szLocalPath;
-        CdnsInfo.ccLocalPath = _countof(szLocalPath);
-        dwErrCode = DownloadFileFromCDN(hs, CdnsInfo);
-
-        // Load and parse the archive index
-        if (dwErrCode == ERROR_SUCCESS)
+        // Fetch and parse the archive index
+        dwErrCode = FetchCascFile(hs, PathTypeData, pbIndexHash, _T(".index"), LocalPath);
+        if(dwErrCode == ERROR_SUCCESS)
         {
             // Load the index file to memory
-            pbFileData = LoadFileToMemory(szLocalPath, &cbFileData);
-            if (pbFileData && cbFileData)
+            if((dwErrCode = LoadFileToMemory(LocalPath, FileData)) == ERROR_SUCCESS)
             {
-                dwErrCode = LoadArchiveIndexFile(hs, pbFileData, cbFileData, i);
-                CASC_FREE(pbFileData);
+                dwErrCode = LoadArchiveIndexFile(hs, FileData.pbData, FileData.cbData, i);
             }
         }
 
         // Break if an error
-        if (dwErrCode != ERROR_SUCCESS)
+        if(dwErrCode != ERROR_SUCCESS)
             break;
     }
 
     // Build map of EKey -> CASC_EKEY_ENTRY
-    if (dwErrCode == ERROR_SUCCESS)
+    if(dwErrCode == ERROR_SUCCESS)
         dwErrCode = BuildMapOfArchiveIndices(hs);
     return dwErrCode;
 }
@@ -843,11 +782,11 @@ static DWORD LoadArchiveIndexFiles(TCascStorage * hs)
 
 bool CopyEKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry)
 {
-    LPBYTE pbEKeyEntry = (LPBYTE)hs->IndexEKeyMap.FindObject(pCKeyEntry->EKey);
-
     // Don't do this on online storages
     if(!(hs->dwFeatures & CASC_FEATURE_ONLINE))
     {
+        LPBYTE pbEKeyEntry;
+
         // If the file was found, then copy the content to the CKey entry
         pbEKeyEntry = (LPBYTE)hs->IndexEKeyMap.FindObject(pCKeyEntry->EKey);
         if(pbEKeyEntry == NULL)
@@ -863,15 +802,18 @@ bool CopyEKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry)
 
 DWORD LoadIndexFiles(TCascStorage * hs)
 {
-    // For local storages, load the index files from the disk
-    // For online storages, load the index files from the cache / internet
-    if(hs->dwFeatures & CASC_FEATURE_ONLINE)
+    switch(hs->BuildFileType)
     {
-        return LoadArchiveIndexFiles(hs);
-    }
-    else
-    {
-        return LoadLocalIndexFiles(hs);
+        case CascBuildDb:       // Load the index files from the disk
+        case CascBuildInfo:
+            return LoadLocalIndexFiles(hs);
+
+        case CascVersions:      // Load the index files from the cache / internet
+            return LoadArchiveIndexFiles(hs);
+
+        default:
+            assert(false);
+            return ERROR_NOT_SUPPORTED;
     }
 }
 
@@ -886,8 +828,7 @@ void FreeIndexFiles(TCascStorage * hs)
         CASC_INDEX & IndexFile = hs->IndexFiles[i];
 
         // Free the file data
-        CASC_FREE(IndexFile.pbFileData);
-        IndexFile.cbFileData = 0;
+        IndexFile.FileData.Free();
 
         // Free the file name
         CASC_FREE(IndexFile.szFileName);
diff --git a/dep/CascLib/src/CascLib.h b/dep/CascLib/src/CascLib.h
index 3f4445e9351..b63869a49b4 100644
--- a/dep/CascLib/src/CascLib.h
+++ b/dep/CascLib/src/CascLib.h
@@ -1,7 +1,7 @@
 /*****************************************************************************/
-/* CascLib.h                              Copyright (c) Ladislav Zezula 2014 */
+/* CascLib.h                              Copyright (c) Ladislav Zezula 2022 */
 /*---------------------------------------------------------------------------*/
-/* CascLib library v 1.00                                                    */
+/* CascLib library v 3.0                                                     */
 /*                                                                           */
 /* Author : Ladislav Zezula                                                  */
 /* E-mail : ladik@zezula.net                                                 */
@@ -10,13 +10,14 @@
 /*   Date    Ver   Who  Comment                                              */
 /* --------  ----  ---  -------                                              */
 /* 29.04.14  1.00  Lad  Created                                              */
+/* 19.12.22  1.00  Lad  Version 3.0                                          */
 /*****************************************************************************/
 
 #ifndef __CASCLIB_H__
 #define __CASCLIB_H__
 
 #ifdef _MSC_VER
-#pragma warning(disable:4668)                   // 'XXX' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
+#pragma warning(disable:4668)       // 'XXX' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
 #pragma warning(disable:4820)       // 'XXX' : '2' bytes padding added after data member 'XXX::yyy'
 #endif
 
@@ -74,8 +75,8 @@ extern "C" {
 //-----------------------------------------------------------------------------
 // Defines
 
-#define CASCLIB_VERSION                 0x0210  // CascLib version - integral (2.1)
-#define CASCLIB_VERSION_STRING           "2.1"  // CascLib version - string
+#define CASCLIB_VERSION                 0x0300  // CascLib version - integral (3.0)
+#define CASCLIB_VERSION_STRING           "3.0"  // CascLib version - string
 
 // Values for CascOpenFile
 #define CASC_OPEN_BY_NAME           0x00000000  // Open the file by name. This is the default value
@@ -122,13 +123,14 @@ extern "C" {
 #define MD5_STRING_SIZE                   0x20
 #endif
 
-// Return value for CascGetFileSize and CascSetFilePointer
+// Invalid values of all kind
 #define CASC_INVALID_INDEX          0xFFFFFFFF
 #define CASC_INVALID_SIZE           0xFFFFFFFF
 #define CASC_INVALID_POS            0xFFFFFFFF
 #define CASC_INVALID_ID             0xFFFFFFFF
 #define CASC_INVALID_OFFS64         0xFFFFFFFFFFFFFFFF
 #define CASC_INVALID_SIZE64         0xFFFFFFFFFFFFFFFF
+#define CASC_INVALID_SIZE_T         ((size_t)(-1))
 
 // Flags for CASC_STORAGE_FEATURES::dwFeatures
 #define CASC_FEATURE_FILE_NAMES     0x00000001  // File names are supported by the storage
@@ -139,9 +141,10 @@ extern "C" {
 #define CASC_FEATURE_FILE_DATA_IDS  0x00000020  // The storage indexes files by FileDataId
 #define CASC_FEATURE_LOCALE_FLAGS   0x00000040  // Locale flags are supported
 #define CASC_FEATURE_CONTENT_FLAGS  0x00000080  // Content flags are supported
-#define CASC_FEATURE_ONLINE         0x00000100  // The storage is an online storage
-#define CASC_FEATURE_LOCAL_CDNS     0x00000200  // (Online) use cached "cdns" file, if available
-#define CASC_FEATURE_LOCAL_VERSIONS 0x00000400  // (Online) use cached "versions" file, if available
+#define CASC_FEATURE_DATA_ARCHIVES  0x00000100  // The storage supports files stored in data.### archives
+#define CASC_FEATURE_DATA_FILES     0x00000200  // The storage supports raw files stored in %CascRoot%\xx\yy\xxyy## (CKey-based)
+#define CASC_FEATURE_ONLINE         0x00000400  // Load the missing files from online CDNs
+#define CASC_FEATURE_FORCE_DOWNLOAD 0x00001000  // (Online) always download "versions" and "cdns" even if it exists locally
 
 // Macro to convert FileDataId to the argument of CascOpenFile
 #define CASC_FILE_DATA_ID(FileDataId) ((LPCSTR)(size_t)FileDataId)
diff --git a/dep/CascLib/src/CascOpenFile.cpp b/dep/CascLib/src/CascOpenFile.cpp
index dd1d5407575..eee4566db5d 100644
--- a/dep/CascLib/src/CascOpenFile.cpp
+++ b/dep/CascLib/src/CascOpenFile.cpp
@@ -41,7 +41,7 @@ TCascFile::TCascFile(TCascStorage * ahs, PCASC_CKEY_ENTRY apCKeyEntry)
 TCascFile::~TCascFile()
 {
     // Free all stuff related to file spans
-    if (pFileSpan != NULL)
+    if(pFileSpan != NULL)
     {
         PCASC_FILE_SPAN pSpanPtr = pFileSpan;
 
@@ -430,7 +430,7 @@ bool WINAPI CascCloseFile(HANDLE hFile)
     TCascFile * hf;
 
     hf = TCascFile::IsValid(hFile);
-    if (hf != NULL)
+    if(hf != NULL)
     {
         delete hf;
         return true;
diff --git a/dep/CascLib/src/CascOpenStorage.cpp b/dep/CascLib/src/CascOpenStorage.cpp
index 1231ef58bfe..24afbc73e7b 100644
--- a/dep/CascLib/src/CascOpenStorage.cpp
+++ b/dep/CascLib/src/CascOpenStorage.cpp
@@ -61,7 +61,8 @@ TCascStorage::TCascStorage()
     pRootHandler = NULL;
     dwRefCount = 1;
 
-    szRootPath = szDataPath = szIndexPath = szBuildFile = szCdnServers = szCdnPath = szCdnHostUrl = szCodeName = NULL;
+    szRootPath = szDataPath = szIndexPath = szFilesPath = szConfigPath = szMainFile = NULL;
+    szCdnHostUrl = szCdnServers = szCdnPath = szCodeName = NULL;
     szIndexFormat = NULL;
     szRegion = NULL;
     szBuildKey = NULL;
@@ -100,14 +101,16 @@ TCascStorage::~TCascStorage()
     CascFreeLock(StorageLock);
 
     // Free the file paths
-    CASC_FREE(szDataPath);
     CASC_FREE(szRootPath);
-    CASC_FREE(szBuildFile);
+    CASC_FREE(szDataPath);
     CASC_FREE(szIndexPath);
+    CASC_FREE(szFilesPath);
+    CASC_FREE(szConfigPath);
+    CASC_FREE(szMainFile);
+    CASC_FREE(szCdnHostUrl);
     CASC_FREE(szCdnServers);
     CASC_FREE(szCdnPath);
     CASC_FREE(szCodeName);
-    CASC_FREE(szCdnHostUrl);
     CASC_FREE(szRegion);
     CASC_FREE(szBuildKey);
 
@@ -166,20 +169,6 @@ void * ProbeOutputBuffer(void * pvBuffer, size_t cbLength, size_t cbMinLength, s
     return pvBuffer;
 }
 
-static LPTSTR CheckForIndexDirectory(TCascStorage * hs, LPCTSTR szSubDir)
-{
-    TCHAR szIndexPath[MAX_PATH];
-
-    // Combine the index path
-    CombinePath(szIndexPath, _countof(szIndexPath), hs->szDataPath, szSubDir, NULL);
-
-    // Check whether the path exists
-    if(!DirectoryExists(szIndexPath))
-        return NULL;
-
-    return CascNewStr(szIndexPath);
-}
-
 // Inserts an entry from the text build file
 static PCASC_CKEY_ENTRY InsertCKeyEntry(TCascStorage * hs, CASC_CKEY_ENTRY & CKeyEntry)
 {
@@ -451,8 +440,7 @@ static int LoadEncodingCKeyPage(TCascStorage * hs, CASC_ENCODING_HEADER & EnHead
 static int LoadEncodingManifest(TCascStorage * hs)
 {
     CASC_CKEY_ENTRY & CKeyEntry = hs->EncodingCKey;
-    LPBYTE pbEncodingFile;
-    DWORD cbEncodingFile = 0;
+    CASC_BLOB EncodingFile;
     DWORD dwErrCode = ERROR_SUCCESS;
 
     // Inform the user about what we are doing
@@ -465,24 +453,25 @@ static int LoadEncodingManifest(TCascStorage * hs)
     InsertCKeyEntry(hs, CKeyEntry);
 
     // Load the entire encoding file to memory
-    pbEncodingFile = LoadInternalFileToMemory(hs, &hs->EncodingCKey, &cbEncodingFile);
-    if(pbEncodingFile != NULL && cbEncodingFile != 0)
+    dwErrCode = LoadInternalFileToMemory(hs, &hs->EncodingCKey, EncodingFile);
+    if(dwErrCode == ERROR_SUCCESS && EncodingFile.cbData != 0)
     {
         CASC_ENCODING_HEADER EnHeader;
 
         // Capture the header of the ENCODING file
-        dwErrCode = CaptureEncodingHeader(EnHeader, pbEncodingFile, cbEncodingFile);
+        dwErrCode = CaptureEncodingHeader(EnHeader, EncodingFile.pbData, EncodingFile.cbData);
         if(dwErrCode == ERROR_SUCCESS)
         {
             // Get the CKey page header and the first page
-            PFILE_CKEY_PAGE pPageHeader = (PFILE_CKEY_PAGE)(pbEncodingFile + sizeof(FILE_ENCODING_HEADER) + EnHeader.ESpecBlockSize);
+            PFILE_CKEY_PAGE pPageHeader = (PFILE_CKEY_PAGE)(EncodingFile.pbData + sizeof(FILE_ENCODING_HEADER) + EnHeader.ESpecBlockSize);
+            LPBYTE pbEncodingEnd = EncodingFile.pbData + EncodingFile.cbData;
             LPBYTE pbCKeyPage = (LPBYTE)(pPageHeader + EnHeader.CKeyPageCount);
 
             // Go through all CKey pages and verify them
             for(DWORD i = 0; i < EnHeader.CKeyPageCount; i++)
             {
                 // Check if there is enough space in the buffer
-                if((pbCKeyPage + EnHeader.CKeyPageSize) > (pbEncodingFile + cbEncodingFile))
+                if((pbCKeyPage + EnHeader.CKeyPageSize) > pbEncodingEnd)
                 {
                     dwErrCode = ERROR_FILE_CORRUPT;
                     break;
@@ -519,9 +508,6 @@ static int LoadEncodingManifest(TCascStorage * hs)
         {
             dwErrCode = CopyBuildFileItemsToCKeyArray(hs);
         }
-
-        // Free the loaded ENCODING file
-        CASC_FREE(pbEncodingFile);
     }
     else
     {
@@ -735,15 +721,18 @@ static int LoadDownloadManifest(TCascStorage * hs, CASC_DOWNLOAD_HEADER & DlHead
         // Insert the entry to the central CKey table
         if((pCKeyEntry = InsertCKeyEntry(hs, DlEntry)) != NULL)
         {
-            // Supply the tag bits
-            for(size_t j = 0; j < TagItemCount; j++)
+            if(TagArray != NULL)
             {
-                // Set the bit in the entry, if the tag for it is present
-                if((BitMaskOffset < TagArray[j].BitmapLength) && (TagArray[j].Bitmap[BitMaskOffset] & BitMaskBit))
-                    pCKeyEntry->TagBitMask |= TagBit;
+                // Supply the tag bits
+                for(size_t j = 0; j < TagItemCount; j++)
+                {
+                    // Set the bit in the entry, if the tag for it is present
+                    if((BitMaskOffset < TagArray[j].BitmapLength) && (TagArray[j].Bitmap[BitMaskOffset] & BitMaskBit))
+                        pCKeyEntry->TagBitMask |= TagBit;
 
-                // Move to the next bit
-                TagBit <<= 1;
+                    // Move to the next bit
+                    TagBit <<= 1;
+                }
             }
         }
 
@@ -762,8 +751,7 @@ static int LoadDownloadManifest(TCascStorage * hs, CASC_DOWNLOAD_HEADER & DlHead
 static int LoadDownloadManifest(TCascStorage * hs)
 {
     PCASC_CKEY_ENTRY pCKeyEntry = FindCKeyEntry_CKey(hs, hs->DownloadCKey.CKey);
-    LPBYTE pbDownloadFile = NULL;
-    DWORD cbDownloadFile = 0;
+    CASC_BLOB DownloadFile;
     DWORD dwErrCode = ERROR_SUCCESS;
 
     // Inform the user about what we are doing
@@ -771,21 +759,18 @@ static int LoadDownloadManifest(TCascStorage * hs)
         return ERROR_CANCELLED;
 
     // Load the entire DOWNLOAD file to memory
-    pbDownloadFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbDownloadFile);
-    if(pbDownloadFile != NULL && cbDownloadFile != 0)
+    dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, DownloadFile);
+    if(dwErrCode == ERROR_SUCCESS && DownloadFile.cbData != 0)
     {
         CASC_DOWNLOAD_HEADER DlHeader;
 
         // Capture the header of the DOWNLOAD file
-        dwErrCode = CaptureDownloadHeader(DlHeader, pbDownloadFile, cbDownloadFile);
+        dwErrCode = CaptureDownloadHeader(DlHeader, DownloadFile.pbData, DownloadFile.cbData);
         if(dwErrCode == ERROR_SUCCESS)
         {
             // Parse the entire download manifest
-            dwErrCode = LoadDownloadManifest(hs, DlHeader, pbDownloadFile, pbDownloadFile + cbDownloadFile); 
+            dwErrCode = LoadDownloadManifest(hs, DlHeader, DownloadFile.pbData, DownloadFile.pbData + DownloadFile.cbData); 
         }
-
-        // Free the loaded manifest
-        CASC_FREE(pbDownloadFile);
     }
 
     // If the DOWNLOAD manifest is not present, we won't abort the downloading process.
@@ -799,8 +784,7 @@ static int LoadDownloadManifest(TCascStorage * hs)
 static int LoadInstallManifest(TCascStorage * hs)
 {
     PCASC_CKEY_ENTRY pCKeyEntry = FindCKeyEntry_CKey(hs, hs->InstallCKey.CKey);
-    LPBYTE pbInstallFile = NULL;
-    DWORD cbInstallFile = 0;
+    CASC_BLOB InstallFile;
     DWORD dwErrCode = ERROR_SUCCESS;
 
     // Inform the user about what we are doing
@@ -808,11 +792,10 @@ static int LoadInstallManifest(TCascStorage * hs)
         return ERROR_CANCELLED;
 
     // Load the entire DOWNLOAD file to memory
-    pbInstallFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbInstallFile);
-    if(pbInstallFile != NULL && cbInstallFile != 0)
+    dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, InstallFile);
+    if(dwErrCode == ERROR_SUCCESS && InstallFile.cbData != 0)
     {
-        dwErrCode = RootHandler_CreateInstall(hs, pbInstallFile, cbInstallFile);
-        CASC_FREE(pbInstallFile);
+        dwErrCode = RootHandler_CreateInstall(hs, InstallFile);
     }
     else
     {
@@ -864,9 +847,8 @@ static int LoadBuildManifest(TCascStorage * hs, DWORD dwLocaleMask)
 {
     PCASC_CKEY_ENTRY pCKeyEntry = &hs->RootFile;
     TRootHandler * pOldRootHandler = NULL;
+    CASC_BLOB RootFile;
     PDWORD FileSignature;
-    LPBYTE pbRootFile = NULL;
-    DWORD cbRootFile = 0;
     DWORD dwErrCode = ERROR_BAD_FORMAT;
 
     // Sanity checks
@@ -888,30 +870,30 @@ __LoadRootFile:
 
     // Load the entire ROOT file to memory
     pCKeyEntry = FindCKeyEntry_CKey(hs, pCKeyEntry->CKey);
-    pbRootFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbRootFile);
-    if(pbRootFile != NULL)
+    dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, RootFile);
+    if(dwErrCode == ERROR_SUCCESS)
     {
         // Ignore ROOT files that contain just a MD5 hash
-        if(cbRootFile > MD5_STRING_SIZE)
+        if(RootFile.cbData > MD5_STRING_SIZE)
         {
             // Check the type of the ROOT file
-            FileSignature = (PDWORD)pbRootFile;
+            FileSignature = (PDWORD)(RootFile.pbData);
             switch(FileSignature[0])
             {
                 case CASC_MNDX_ROOT_SIGNATURE:
-                    dwErrCode = RootHandler_CreateMNDX(hs, pbRootFile, cbRootFile);
+                    dwErrCode = RootHandler_CreateMNDX(hs, RootFile);
                     break;
 
                 case CASC_DIABLO3_ROOT_SIGNATURE:
-                    dwErrCode = RootHandler_CreateDiablo3(hs, pbRootFile, cbRootFile);
+                    dwErrCode = RootHandler_CreateDiablo3(hs, RootFile);
                     break;
 
                 case CASC_TVFS_ROOT_SIGNATURE:
-                    dwErrCode = RootHandler_CreateTVFS(hs, pbRootFile, cbRootFile);
+                    dwErrCode = RootHandler_CreateTVFS(hs, RootFile);
                     break;
 
                 case CASC_WOW82_ROOT_SIGNATURE:
-                    dwErrCode = RootHandler_CreateWoW(hs, pbRootFile, cbRootFile, dwLocaleMask);
+                    dwErrCode = RootHandler_CreateWoW(hs, RootFile, dwLocaleMask);
                     break;
 
                 default:
@@ -921,21 +903,18 @@ __LoadRootFile:
                     // If the format was not recognized, they need to return ERROR_BAD_FORMAT
                     //
 
-                    dwErrCode = RootHandler_CreateOverwatch(hs, pbRootFile, cbRootFile);
+                    dwErrCode = RootHandler_CreateOverwatch(hs, RootFile);
                     if(dwErrCode == ERROR_BAD_FORMAT)
                     {
-                        dwErrCode = RootHandler_CreateStarcraft1(hs, pbRootFile, cbRootFile);
+                        dwErrCode = RootHandler_CreateStarcraft1(hs, RootFile);
                         if(dwErrCode == ERROR_BAD_FORMAT)
                         {
-                            dwErrCode = RootHandler_CreateWoW(hs, pbRootFile, cbRootFile, dwLocaleMask);
+                            dwErrCode = RootHandler_CreateWoW(hs, RootFile, dwLocaleMask);
                         }
                     }
                     break;
             }
         }
-
-        // Free the root file
-        CASC_FREE(pbRootFile);
     }
     else
     {
@@ -1109,73 +1088,7 @@ static bool GetStoragePathProduct(TCascStorage * hs, void * pvStorageInfo, size_
     return (szBuffer != NULL);
 }
 
-static DWORD InitializeLocalDirectories(TCascStorage * hs, PCASC_OPEN_STORAGE_ARGS pArgs)
-{
-    LPTSTR szWorkPath;
-    DWORD dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
-
-    // Find the root directory of the storage. The root directory
-    // is the one with ".build.info" or ".build.db".
-    szWorkPath = CascNewStr(pArgs->szLocalPath);
-    if(szWorkPath != NULL)
-    {
-        // Get the length and go up until we find the ".build.info" or ".build.db"
-        for(;;)
-        {
-            // Is this a game directory?
-            dwErrCode = CheckGameDirectory(hs, szWorkPath);
-            if(dwErrCode == ERROR_SUCCESS)
-            {
-                dwErrCode = ERROR_SUCCESS;
-                break;
-            }
-
-            // Cut one path part
-            if(!CutLastPathPart(szWorkPath))
-            {
-                dwErrCode = ERROR_FILE_NOT_FOUND;
-                break;
-            }
-        }
-
-        // Find the index directory
-        if(dwErrCode == ERROR_SUCCESS)
-        {
-            // First, check for more common "data" subdirectory
-            if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("data"))) != NULL)
-                dwErrCode = ERROR_SUCCESS;
-
-            // Second, try the "darch" subdirectory (older builds of HOTS - Alpha)
-            else if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("darch"))) != NULL)
-                dwErrCode = ERROR_SUCCESS;
-
-            else
-                dwErrCode = ERROR_FILE_NOT_FOUND;
-        }
-
-        // Free the work path buffer
-        CASC_FREE(szWorkPath);
-    }
-
-    return dwErrCode;
-}
-
-static DWORD InitializeOnlineDirectories(TCascStorage * hs, PCASC_OPEN_STORAGE_ARGS pArgs)
-{
-    // Create the root path
-    hs->szRootPath = CascNewStr(pArgs->szLocalPath);
-    if(hs->szRootPath != NULL)
-    {
-        hs->BuildFileType = CascVersionsDb;
-        hs->dwFeatures |= CASC_FEATURE_ONLINE;
-        hs->dwFeatures |= (pArgs->dwFlags & (CASC_FEATURE_LOCAL_CDNS | CASC_FEATURE_LOCAL_VERSIONS));
-        return ERROR_SUCCESS;
-    }
-
-    return ERROR_NOT_ENOUGH_MEMORY;
-}
-
-static DWORD LoadCascStorage(TCascStorage * hs, PCASC_OPEN_STORAGE_ARGS pArgs)
+static DWORD LoadCascStorage(TCascStorage * hs, PCASC_OPEN_STORAGE_ARGS pArgs, LPCTSTR szMainFile, CBLD_TYPE BuildFileType, DWORD dwFeatures)
 {
     LPCTSTR szCdnHostUrl = NULL;
     LPCTSTR szCodeName = NULL;
@@ -1206,21 +1119,48 @@ static DWORD LoadCascStorage(TCascStorage * hs, PCASC_OPEN_STORAGE_ARGS pArgs)
     if(ExtractVersionedArgument(pArgs, FIELD_OFFSET(CASC_OPEN_STORAGE_ARGS, szBuildKey), &szBuildKey) && szBuildKey != NULL)
         hs->szBuildKey = CascNewStrT2A(szBuildKey);
 
-    // Special handling to online storages
-    if(hs->dwFeatures & CASC_FEATURE_ONLINE)
-    {
-        // Enable caching of the sockets. This will add references
-        // to all existing and all future sockets
-        sockets_set_caching(true);
+    // Merge features
+    hs->dwFeatures |= (dwFeatures & (CASC_FEATURE_DATA_ARCHIVES | CASC_FEATURE_DATA_FILES | CASC_FEATURE_ONLINE));
+    hs->dwFeatures |= (pArgs->dwFlags & CASC_FEATURE_FORCE_DOWNLOAD);
+    hs->BuildFileType = BuildFileType;
+
+    // Copy the name of the build file
+    hs->szMainFile = CascNewStr(szMainFile);
 
-        // For online storages, we need to load CDN servers
-        dwErrCode = LoadCdnsFile(hs);
+    // Construct the root path from the name of the build file
+    CASC_PATH<TCHAR> RootPath(szMainFile, NULL);
+    hs->szRootPath = RootPath.New(true);
+
+    // If either of the root path or build file is known, it's an error
+    if(hs->szRootPath == NULL || hs->szMainFile == NULL)
+    {
+        dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
     }
 
-    // Now, load the main storage file ".build.info" (or ".build.db" in old storages) 
+    // Initialize variables for local CASC storages
     if(dwErrCode == ERROR_SUCCESS)
     {
-        dwErrCode = LoadBuildInfo(hs);
+        // For local (game) storages, we need the data and indices subdirectory
+        if(hs->dwFeatures & CASC_FEATURE_DATA_ARCHIVES)
+        {
+            if(CheckArchiveFilesDirectories(hs) != ERROR_SUCCESS)
+                hs->dwFeatures &= ~CASC_FEATURE_DATA_ARCHIVES;
+        }
+
+        // For data files storage, we need that folder
+        if(hs->dwFeatures & CASC_FEATURE_DATA_FILES)
+        {
+            if(CheckDataFilesDirectory(hs) != ERROR_SUCCESS)
+                hs->dwFeatures &= ~CASC_FEATURE_DATA_FILES;
+        }
+
+        // Enable caching of the sockets. This will add references
+        // to all existing and all future sockets
+        if(hs->dwFeatures & CASC_FEATURE_ONLINE)
+            sockets_set_caching(true);
+
+        // Now, load the main storage file (".build.info", ".build.db" or "versions")
+        dwErrCode = LoadMainFile(hs);
     }
 
     // Proceed with loading the CDN config file
@@ -1439,33 +1379,49 @@ bool WINAPI CascOpenStorageEx(LPCTSTR szParams, PCASC_OPEN_STORAGE_ARGS pArgs, b
         }
     }
 
-    // Allocate the storage structure
+    // Now we need to get the CASC main file, which is either
+    // [*] .build.info - for current local storages
+    // [*] .build.db   - for older local storages
+    // [*] versions    - for cached online storages
+    // If there is none of these and `bOnlineStorage` is specified,
+    // CascLib will download it, as long as the product code was specified
     if(dwErrCode == ERROR_SUCCESS)
     {
         if((hs = new TCascStorage()) != NULL)
         {
-            // Setup the directories
-            dwErrCode = (bOnlineStorage) ? InitializeOnlineDirectories(hs, pArgs) : InitializeLocalDirectories(hs, pArgs);
-            if(dwErrCode == ERROR_SUCCESS)
+            CASC_BUILD_FILE BuildFile = {NULL};
+            DWORD dwFeatures = bOnlineStorage ? CASC_FEATURE_ONLINE : 0;
+            
+            // Check for one of the supported main files (.build.info, .build.db, versions)
+            if((dwErrCode = CheckCascBuildFileExact(BuildFile, pArgs->szLocalPath)) == ERROR_SUCCESS)
+            {
+                dwErrCode = LoadCascStorage(hs, pArgs, BuildFile.szFullPath, BuildFile.BuildFileType, dwFeatures | CASC_FEATURE_DATA_ARCHIVES | CASC_FEATURE_DATA_FILES);
+            }
+
+            // Search the folder and upper folders for the build file
+            else if((dwErrCode = CheckCascBuildFileDirs(BuildFile, pArgs->szLocalPath)) == ERROR_SUCCESS)
             {
-                // Perform the entire storage loading
-                dwErrCode = LoadCascStorage(hs, pArgs);
+                dwErrCode = LoadCascStorage(hs, pArgs, BuildFile.szFullPath, BuildFile.BuildFileType, dwFeatures | CASC_FEATURE_DATA_ARCHIVES | CASC_FEATURE_DATA_FILES);
+            }
+
+            // If the caller requested an online storage, we must have the code name
+            else if((dwErrCode = CheckOnlineStorage(pArgs, BuildFile, dwFeatures)) == ERROR_SUCCESS)
+            {
+                dwErrCode = LoadCascStorage(hs, pArgs, BuildFile.szFullPath, BuildFile.BuildFileType, dwFeatures | CASC_FEATURE_DATA_FILES);
             }
         }
     }
 
-    // Handle errors
+    // Delete the storage on error
     if(dwErrCode != ERROR_SUCCESS)
-    {
-        SetCascError(dwErrCode);
         hs = hs->Release();
-    }
-
-    // Free the copy of the parameters
     CASC_FREE(szParamsCopy);
 
     // Give the output parameter to the caller
-    *phStorage = (HANDLE)hs;
+    if(phStorage != NULL)
+        phStorage[0] = (HANDLE)hs;
+    if(dwErrCode != ERROR_SUCCESS)
+        SetCascError(dwErrCode);
     return (dwErrCode == ERROR_SUCCESS);
 }
 
diff --git a/dep/CascLib/src/CascPort.h b/dep/CascLib/src/CascPort.h
index 9a136a3385c..c8145a4512d 100644
--- a/dep/CascLib/src/CascPort.h
+++ b/dep/CascLib/src/CascPort.h
@@ -93,7 +93,7 @@
   #include <netdb.h>
 
   // Support for PowerPC on Max OS X
-  #if (__ppc__ == 1) || (__POWERPC__ == 1) || (_ARCH_PPC == 1)
+  #if(__ppc__ == 1) || (__POWERPC__ == 1) || (_ARCH_PPC == 1)
     #include <stdint.h>
     #include <CoreFoundation/CFByteOrder.h>
   #endif
diff --git a/dep/CascLib/src/CascReadFile.cpp b/dep/CascLib/src/CascReadFile.cpp
index c89445c7078..35f91addf75 100644
--- a/dep/CascLib/src/CascReadFile.cpp
+++ b/dep/CascLib/src/CascReadFile.cpp
@@ -29,8 +29,6 @@ static DWORD OpenDataStream(TCascFile * hf, PCASC_FILE_SPAN pFileSpan, PCASC_CKE
 {
     TCascStorage * hs = hf->hs;
     TFileStream * pStream = NULL;
-    TCHAR szCachePath[MAX_PATH];
-    TCHAR szDataFile[MAX_PATH];
     TCHAR szPlainName[0x80];
     DWORD dwErrCode;
 
@@ -48,11 +46,13 @@ static DWORD OpenDataStream(TCascFile * hf, PCASC_FILE_SPAN pFileSpan, PCASC_CKE
         {
             // Prepare the name of the data file
             CascStrPrintf(szPlainName, _countof(szPlainName), _T("data.%03u"), dwArchiveIndex);
-            CombinePath(szDataFile, _countof(szDataFile), hs->szIndexPath, szPlainName, NULL);
+
+            // Create the full path of the data file
+            CASC_PATH<TCHAR> DataFile(hs->szIndexPath, szPlainName, NULL);
 
             // Open the data stream with read+write sharing to prevent Battle.net agent
             // detecting a corruption and redownloading the entire package
-            pStream = FileStream_OpenFile(szDataFile, STREAM_FLAG_READ_ONLY | STREAM_FLAG_WRITE_SHARE | STREAM_PROVIDER_FLAT | STREAM_FLAG_FILL_MISSING | BASE_PROVIDER_FILE);
+            pStream = FileStream_OpenFile(DataFile, STREAM_FLAG_READ_ONLY | STREAM_FLAG_WRITE_SHARE | STREAM_PROVIDER_FLAT | STREAM_FLAG_FILL_MISSING | BASE_PROVIDER_FILE);
             hs->DataFiles[dwArchiveIndex] = pStream;
         }
 
@@ -67,35 +67,29 @@ static DWORD OpenDataStream(TCascFile * hf, PCASC_FILE_SPAN pFileSpan, PCASC_CKE
     {
         if(bDownloadFileIf)
         {
-            CASC_CDN_DOWNLOAD CdnsInfo = {0};
-            LPCTSTR szPathType = (pCKeyEntry->Flags & CASC_CE_FILE_PATCH) ? _T("patch") : _T("data");
-
-            // Prepare the download structure for "%CDNS_HOST%/%CDNS_PATH%/##/##/EKey" file
-            CdnsInfo.szCdnsPath = hs->szCdnPath;
-            CdnsInfo.szPathType = szPathType;
-            CdnsInfo.pbEKey = pCKeyEntry->EKey;
-            CdnsInfo.szLocalPath = szCachePath;
-            CdnsInfo.ccLocalPath = _countof(szCachePath);
-
-            // Download the file from CDN
-            dwErrCode = DownloadFileFromCDN(hs, CdnsInfo);
+            CASC_ARCHIVE_INFO ArchiveInfo = {0};
+            CASC_PATH<TCHAR> LocalPath;
+            CPATH_TYPE PathType = (pCKeyEntry->Flags & CASC_CE_FILE_PATCH) ? PathTypePatch : PathTypeData;
+
+            // Fetch the file
+            dwErrCode = FetchCascFile(hs, PathType, pCKeyEntry->EKey, NULL, LocalPath, &ArchiveInfo);
             if(dwErrCode == ERROR_SUCCESS)
             {
-                pStream = FileStream_OpenFile(szCachePath, BASE_PROVIDER_FILE | STREAM_PROVIDER_FLAT);
+                pStream = FileStream_OpenFile(LocalPath, BASE_PROVIDER_FILE | STREAM_PROVIDER_FLAT);
                 if(pStream != NULL)
                 {
                     // Initialize information about the position and size of the file in archive
                     // On loose files, their position is zero and encoded size is length of the file
-                    if(CdnsInfo.pbArchiveKey != NULL)
+                    if(CascIsValidMD5(ArchiveInfo.ArchiveKey))
                     {
                         // Archive position
-                        pFileSpan->ArchiveIndex = CdnsInfo.ArchiveIndex;
-                        pFileSpan->ArchiveOffs = (DWORD)CdnsInfo.ArchiveOffs;
+                        pFileSpan->ArchiveIndex = ArchiveInfo.ArchiveIndex;
+                        pFileSpan->ArchiveOffs = ArchiveInfo.ArchiveOffs;
 
                         // Encoded size
                         if(pCKeyEntry->EncodedSize == CASC_INVALID_SIZE)
-                            pCKeyEntry->EncodedSize = CdnsInfo.EncodedSize;
-                        assert(pCKeyEntry->EncodedSize == CdnsInfo.EncodedSize);
+                            pCKeyEntry->EncodedSize = ArchiveInfo.EncodedSize;
+                        assert(pCKeyEntry->EncodedSize == ArchiveInfo.EncodedSize);
                     }
                     else
                     {
@@ -157,11 +151,11 @@ static void VerifyHeaderSpan(PBLTE_ENCODED_HEADER pBlteHeader, ULONGLONG HeaderO
     ConvertIntegerToBytes_4_LE(dwInt32, EncodedOffset);
 
     // Calculate checksum of the so-far filled structure
-    for (i = 0; i < FIELD_OFFSET(BLTE_ENCODED_HEADER, Checksum); i++)
+    for(i = 0; i < FIELD_OFFSET(BLTE_ENCODED_HEADER, Checksum); i++)
         HashedHeader[i & 3] ^= pbBlteHeader[i];
 
     // XOR the two values together to get the final checksum.
-    for (j = 0; j < 4; j++, i++)
+    for(j = 0; j < 4; j++, i++)
         Checksum[j] = HashedHeader[i & 3] ^ EncodedOffset[i & 3];
 //  assert(memcmp(pBlteHeader->Checksum, Checksum, sizeof(Checksum)) == 0);
 }
@@ -284,7 +278,7 @@ static DWORD LoadSpanFrames(PCASC_FILE_SPAN pFileSpan, PCASC_CKEY_ENTRY pCKeyEnt
         if(pFrames != NULL)
         {
             // Copy the frames to the file structure
-            for (DWORD i = 0; i < pFileSpan->FrameCount; i++)
+            for(DWORD i = 0; i < pFileSpan->FrameCount; i++)
             {
                 CASC_FILE_FRAME & Frame = pFrames[i];
 
diff --git a/dep/CascLib/src/CascRootFile_Diablo3.cpp b/dep/CascLib/src/CascRootFile_Diablo3.cpp
index c29f13f74a9..c1d09c3ab23 100644
--- a/dep/CascLib/src/CascRootFile_Diablo3.cpp
+++ b/dep/CascLib/src/CascRootFile_Diablo3.cpp
@@ -64,11 +64,26 @@ typedef struct _DIABLO3_CORE_TOC_ENTRY
 
 } DIABLO3_CORE_TOC_ENTRY, *PDIABLO3_CORE_TOC_ENTRY;
 
+// Structure for conversion DirectoryID -> Directory name
+typedef struct _DIABLO3_ASSET_INFO
+{
+    const char * szDirectoryName;                   // Directory name
+    const char * szExtension;
+
+} DIABLO3_ASSET_INFO;
+typedef const DIABLO3_ASSET_INFO * PDIABLO3_ASSET_INFO;
+
 // In-memory structure of parsed directory data
-typedef struct _DIABLO3_DIRECTORY
+struct DIABLO3_DIRECTORY
 {
-    LPBYTE pbDirectoryData;                         // The begin of the directory data block
-    LPBYTE pbDirectoryEnd;                          // The end of the directory data block
+    DIABLO3_DIRECTORY()
+    {
+        pbAssetEntries = pbAssetIdxEntries = pbNamedEntries = NULL;
+        dwAssetEntries = dwAssetIdxEntries = dwNamedEntries = 0;
+        dwNodeIndex = 0;
+    }
+
+    CASC_BLOB Data;                                 // The complete copy of the directory data
     LPBYTE pbAssetEntries;                          // Pointer to asset entries without subitem number. Example: "SoundBank\SoundFile.smp"
     LPBYTE pbAssetIdxEntries;                       // Pointer to asset entries with subitem number
     LPBYTE pbNamedEntries;                          // Pointer to named entries. These are for files with arbitrary names, and they do not belong to an asset
@@ -76,16 +91,7 @@ typedef struct _DIABLO3_DIRECTORY
     DWORD dwAssetIdxEntries;
     DWORD dwNamedEntries;
     DWORD dwNodeIndex;                              // Index of file node for this folder
-} DIABLO3_DIRECTORY, *PDIABLO3_DIRECTORY;
-
-// Structure for conversion DirectoryID -> Directory name
-typedef struct _DIABLO3_ASSET_INFO
-{
-    const char * szDirectoryName;                   // Directory name
-    const char * szExtension;
-
-} DIABLO3_ASSET_INFO;
-typedef const DIABLO3_ASSET_INFO * PDIABLO3_ASSET_INFO;
+};
 
 //-----------------------------------------------------------------------------
 // Local variables
@@ -175,16 +181,12 @@ struct TDiabloRoot : public TFileTreeRoot
     TDiabloRoot() : TFileTreeRoot(0)
     {
         memset(RootFolders, 0, sizeof(RootFolders));
-        pFileIndices = NULL;
-        pbCoreTocFile = NULL;
         pbCoreTocData = NULL;
+        pFileIndices = NULL;
         nFileIndices = 0;
-        cbCoreTocFile = 0;
 
         // Map for searching a real file extension
         memset(&PackagesMap, 0, sizeof(CASC_MAP));
-        pbPackagesDat = NULL;
-        cbPackagesDat = 0;
 
         // We have file names and return CKey as result of search
         dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY);
@@ -212,26 +214,24 @@ struct TDiabloRoot : public TFileTreeRoot
         return (char *)PackagesMap.FindString(szFileName, szFileName + nLength);
     }
 
-    LPBYTE LoadFileToMemory(TCascStorage * hs, const char * szFileName, DWORD * pcbFileData)
+    DWORD LoadFileToMemory(TCascStorage * hs, const char * szFileName, CASC_BLOB & FileData)
     {
         PCASC_CKEY_ENTRY pCKeyEntry;
-        LPBYTE pbFileData = NULL;
+        DWORD dwErrCode = ERROR_FILE_NOT_FOUND;
 
         // Try to find CKey for the file
         pCKeyEntry = GetFile(hs, szFileName);
         if(pCKeyEntry != NULL)
-            pbFileData = LoadInternalFileToMemory(hs, pCKeyEntry, pcbFileData);
-
-        return pbFileData;
+            dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, FileData);
+        return dwErrCode;
     }
 
-    static LPBYTE CaptureDirectoryData(
+    static DWORD CaptureDirectoryData(
         DIABLO3_DIRECTORY & DirHeader,
-        LPBYTE pbDirectory,
-        DWORD cbDirectory)
+        CASC_BLOB & Directory)
     {
-        LPBYTE pbDirectoryData = pbDirectory;
-        LPBYTE pbDataEnd = pbDirectory + cbDirectory;
+        LPBYTE pbDirectory;
+        LPBYTE pbDataEnd;
         DWORD Signature = 0;
 
         //
@@ -245,13 +245,15 @@ struct TDiabloRoot : public TFileTreeRoot
         // 7) Array of DIABLO3_NAMED_ENTRY entries
         //
 
-        // Prepare the header signature
-        memset(&DirHeader, 0, sizeof(DIABLO3_DIRECTORY));
+        // Clone the input data
+        DirHeader.Data.MoveFrom(Directory);
+        pbDirectory = DirHeader.Data.pbData;
+        pbDataEnd = DirHeader.Data.End();
 
         // Get the header signature
         pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &Signature);
         if((pbDirectory == NULL) || (Signature != CASC_DIABLO3_ROOT_SIGNATURE && Signature != DIABLO3_SUBDIR_SIGNATURE))
-            return NULL;
+            return ERROR_BAD_FORMAT;
 
         // Subdirectories have extra two arrays
         if(Signature == DIABLO3_SUBDIR_SIGNATURE)
@@ -259,37 +261,33 @@ struct TDiabloRoot : public TFileTreeRoot
             // Capture the number of DIABLO3_ASSET_ENTRY items
             pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwAssetEntries);
             if(pbDirectory == NULL)
-                return NULL;
+                return ERROR_BAD_FORMAT;
 
             // Capture the array of DIABLO3_ASSET_ENTRY
             pbDirectory = CaptureArray(pbDirectory, pbDataEnd, &DirHeader.pbAssetEntries, DIABLO3_ASSET_ENTRY, DirHeader.dwAssetEntries);
             if(pbDirectory == NULL)
-                return NULL;
+                return ERROR_BAD_FORMAT;
 
             // Capture the number of DIABLO3_ASSETIDX_ENTRY items
             pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwAssetIdxEntries);
             if(pbDirectory == NULL)
-                return NULL;
+                return ERROR_BAD_FORMAT;
 
             // Capture the array of DIABLO3_ASSETIDX_ENTRY
             pbDirectory = CaptureArray(pbDirectory, pbDataEnd, &DirHeader.pbAssetIdxEntries, DIABLO3_ASSETIDX_ENTRY, DirHeader.dwAssetIdxEntries);
             if(pbDirectory == NULL)
-                return NULL;
+                return ERROR_BAD_FORMAT;
         }
 
         // Capture the number of DIABLO3_NAMED_ENTRY array
         pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwNamedEntries);
         if(pbDirectory == NULL)
-            return NULL;
+            return ERROR_BAD_FORMAT;
 
         // Note: Do not capture the array here. We will do that later,
         // when we will be parsing the directory
         DirHeader.pbNamedEntries = pbDirectory;
-
-        // Put the directory range
-        DirHeader.pbDirectoryData = pbDirectoryData;
-        DirHeader.pbDirectoryEnd = pbDirectoryData + cbDirectory;
-        return pbDirectory;
+        return ERROR_SUCCESS;
     }
 
     LPBYTE CaptureCoreTocHeader(
@@ -357,22 +355,17 @@ struct TDiabloRoot : public TFileTreeRoot
         return NULL;
     }
 
-    int LoadDirectoryFile(TCascStorage * hs, DIABLO3_DIRECTORY & DirHeader, PCASC_CKEY_ENTRY pCKeyEntry)
+    DWORD LoadDirectoryFile(TCascStorage * hs, DIABLO3_DIRECTORY & DirHeader, PCASC_CKEY_ENTRY pCKeyEntry)
     {
-        LPBYTE pbData;
-        DWORD cbData = 0;
+        CASC_BLOB Data;
+        DWORD dwErrCode;
 
-        // Load the n-th folder
-        pbData = LoadInternalFileToMemory(hs, pCKeyEntry, &cbData);
-        if(pbData && cbData)
-        {
-            if(CaptureDirectoryData(DirHeader, pbData, cbData) == NULL)
-            {
-                // Clear the directory
-                CASC_FREE(pbData);
-                return ERROR_BAD_FORMAT;
-            }
-        }
+        // Load the n-th folder, if exists
+        dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, Data);
+        if(dwErrCode == ERROR_SUCCESS && Data.cbData)
+            return CaptureDirectoryData(DirHeader, Data);
+
+        // If the folder is not there, ignore the error
         return ERROR_SUCCESS;
     }
 
@@ -546,7 +539,7 @@ struct TDiabloRoot : public TFileTreeRoot
             PCASC_CKEY_ENTRY pCKeyEntry;
             PCASC_FILE_NODE pFileNode;
             LPBYTE pbDataPtr = Directory.pbNamedEntries;
-            LPBYTE pbDataEnd = Directory.pbDirectoryEnd;
+            LPBYTE pbDataEnd = Directory.Data.End();
             DWORD dwNodeIndex;
 
             // Parse all entries
@@ -609,7 +602,7 @@ struct TDiabloRoot : public TFileTreeRoot
         for(size_t i = 0; i < DIABLO3_MAX_ROOT_FOLDERS; i++)
         {
             // Is this root folder loaded?
-            if(RootFolders[i].pbDirectoryData != NULL)
+            if(RootFolders[i].Data.pbData != NULL)
             {
                 // Retrieve the parent name
                 if(RootFolders[i].dwNodeIndex != 0)
@@ -638,15 +631,15 @@ struct TDiabloRoot : public TFileTreeRoot
     DWORD CreateMapOfFileIndices(TCascStorage * hs, const char * szFileName)
     {
         PDIABLO3_CORE_TOC_HEADER pTocHeader = NULL;
-        LPBYTE pbCoreTocPtr = pbCoreTocFile;
         DWORD dwMaxFileIndex = 0;
-        DWORD dwErrCode = ERROR_CAN_NOT_COMPLETE;
+        DWORD dwErrCode;
 
         // Load the entire file to memory
-        pbCoreTocFile = pbCoreTocPtr = LoadFileToMemory(hs, szFileName, &cbCoreTocFile);
-        if(pbCoreTocFile && cbCoreTocFile)
+        dwErrCode = LoadFileToMemory(hs, szFileName, CoreTocFile);
+        if(dwErrCode == ERROR_SUCCESS && CoreTocFile.cbData)
         {
-            LPBYTE pbCoreTocEnd = pbCoreTocFile + cbCoreTocFile;
+            LPBYTE pbCoreTocPtr = CoreTocFile.pbData;
+            LPBYTE pbCoreTocEnd = CoreTocFile.End();
 
             // Capture the header
             if((pbCoreTocPtr = CaptureCoreTocHeader(&pTocHeader, &dwMaxFileIndex, pbCoreTocPtr, pbCoreTocEnd)) == NULL)
@@ -693,17 +686,18 @@ struct TDiabloRoot : public TFileTreeRoot
     // Packages.dat contains a list of full file names (without locale prefix).
     // They are not sorted, nor they correspond to file IDs.
     // Does the sort order mean something? Perhaps we could use them as listfile?
-    int CreateMapOfRealNames(TCascStorage * hs, const char * szFileName)
+    DWORD CreateMapOfRealNames(TCascStorage * hs, const char * szFileName)
     {
         DWORD Signature = 0;
         DWORD NumberOfNames = 0;
+        DWORD dwErrCode;
 
         // Load the entire file to memory
-        pbPackagesDat = LoadFileToMemory(hs, szFileName, &cbPackagesDat);
-        if(pbPackagesDat && cbPackagesDat)
+        dwErrCode = LoadFileToMemory(hs, szFileName, PackagesDat);
+        if(dwErrCode == ERROR_SUCCESS && PackagesDat.cbData)
         {
-            LPBYTE pbPackagesPtr = pbPackagesDat;
-            LPBYTE pbPackagesEnd = pbPackagesDat + cbPackagesDat;
+            LPBYTE pbPackagesPtr = PackagesDat.pbData;
+            LPBYTE pbPackagesEnd = PackagesDat.End();
 
             // Get the header. There is just Signature + NumberOfNames
             if((pbPackagesPtr = CaptureInteger32(pbPackagesPtr, pbPackagesEnd, &Signature)) == NULL)
@@ -768,21 +762,11 @@ struct TDiabloRoot : public TFileTreeRoot
 
     void FreeLoadingStuff()
     {
-        // Free the captured root sub-directories
-        for(size_t i = 0; i < DIABLO3_MAX_SUBDIRS; i++)
-            CASC_FREE(RootFolders[i].pbDirectoryData);
-
         // Free the package map
         PackagesMap.Free();
 
         // Free the array of file indices
         CASC_FREE(pFileIndices);
-
-        // Free the loaded CoreTOC.dat file
-        CASC_FREE(pbCoreTocFile);
-
-        // Free the loaded Packages.dat file
-        CASC_FREE(pbPackagesDat);
     }
 
     // Array of root directory subdirectories
@@ -791,32 +775,29 @@ struct TDiabloRoot : public TFileTreeRoot
     // Array of DIABLO3_TOC_ENTRY structures, sorted by the file index
     // Used for converting FileIndex -> Asset+PlainName during loading
     PDIABLO3_CORE_TOC_ENTRY pFileIndices;
-    LPBYTE pbCoreTocFile;
+    CASC_BLOB CoreTocFile;
     LPBYTE pbCoreTocData;
     size_t nFileIndices;
-    DWORD cbCoreTocFile;
 
     // Map for searching a real file extension
+    CASC_BLOB PackagesDat;
     CASC_MAP PackagesMap;
-    LPBYTE pbPackagesDat;
-    DWORD cbPackagesDat;
 };
 
 //-----------------------------------------------------------------------------
 // Public functions
 
-DWORD RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+DWORD RootHandler_CreateDiablo3(TCascStorage * hs, CASC_BLOB & RootFile)
 {
     TDiabloRoot * pRootHandler = NULL;
     DIABLO3_DIRECTORY RootDirectory;
     DWORD dwErrCode = ERROR_BAD_FORMAT;
 
     // Verify the header of the ROOT file
-    if(TDiabloRoot::CaptureDirectoryData(RootDirectory, pbRootFile, cbRootFile) != NULL)
+    if((dwErrCode = TDiabloRoot::CaptureDirectoryData(RootDirectory, RootFile)) == ERROR_SUCCESS)
     {
         // Allocate the root handler object
-        pRootHandler = new TDiabloRoot();
-        if(pRootHandler != NULL)
+        if((pRootHandler = new TDiabloRoot()) != NULL)
         {
             // Load the root directory. If load failed, we free the object
             dwErrCode = pRootHandler->Load(hs, RootDirectory);
diff --git a/dep/CascLib/src/CascRootFile_Install.cpp b/dep/CascLib/src/CascRootFile_Install.cpp
index 86d621e2e47..2a01acb8590 100644
--- a/dep/CascLib/src/CascRootFile_Install.cpp
+++ b/dep/CascLib/src/CascRootFile_Install.cpp
@@ -36,7 +36,7 @@ struct TRootHandler_Install : public TFileTreeRoot
         pbInstallFile += InHeader.HeaderLength;
 
         // Skip the tags
-        for (DWORD i = 0; i < InHeader.TagCount; i++)
+        for(DWORD i = 0; i < InHeader.TagCount; i++)
         {
             szString = (const char *)pbInstallFile;
             nBitmapLength = GetTagBitmapLength(pbInstallFile, pbInstallEnd, InHeader.EntryCount);
@@ -55,7 +55,7 @@ struct TRootHandler_Install : public TFileTreeRoot
             pbInstallFile += MD5_HASH_SIZE + sizeof(DWORD);
 
             // Insert the FileName+CKey to the file tree
-            if (pCKeyEntry != NULL)
+            if(pCKeyEntry != NULL)
                 FileTree.InsertByName(pCKeyEntry, szString);
             nFileCount--;
         }
@@ -72,11 +72,11 @@ DWORD CaptureInstallHeader(CASC_INSTALL_HEADER & InHeader, LPBYTE pbFileData, si
     PFILE_INSTALL_HEADER pFileHeader = (PFILE_INSTALL_HEADER)pbFileData;
 
     // Check the signature ('DL') and version
-    if (cbFileData < sizeof(FILE_INSTALL_HEADER) || pFileHeader->Magic != FILE_MAGIC_INSTALL || pFileHeader->Version != 1)
+    if(cbFileData < sizeof(FILE_INSTALL_HEADER) || pFileHeader->Magic != FILE_MAGIC_INSTALL || pFileHeader->Version != 1)
         return ERROR_BAD_FORMAT;
 
     // Note that we don't support CKey sizes greater than 0x10 in the INSTALL file
-    if (pFileHeader->EKeyLength > MD5_HASH_SIZE)
+    if(pFileHeader->EKeyLength > MD5_HASH_SIZE)
         return ERROR_BAD_FORMAT;
 
     // Capture the header version 1
@@ -90,22 +90,22 @@ DWORD CaptureInstallHeader(CASC_INSTALL_HEADER & InHeader, LPBYTE pbFileData, si
     return ERROR_SUCCESS;
 }
 
-DWORD RootHandler_CreateInstall(TCascStorage * hs, LPBYTE pbInstallFile, DWORD cbInstallFile)
+DWORD RootHandler_CreateInstall(TCascStorage * hs, CASC_BLOB & InstallFile)
 {
     CASC_INSTALL_HEADER InHeader;
     TRootHandler_Install * pRootHandler = NULL;
     DWORD dwErrCode = ERROR_BAD_FORMAT;
 
     // Capture the header of the DOWNLOAD file
-    dwErrCode = CaptureInstallHeader(InHeader, pbInstallFile, cbInstallFile);
-    if (dwErrCode == ERROR_SUCCESS)
+    dwErrCode = CaptureInstallHeader(InHeader, InstallFile.pbData, InstallFile.cbData);
+    if(dwErrCode == ERROR_SUCCESS)
     {
         // Allocate the root handler object
         pRootHandler = new TRootHandler_Install();
-        if (pRootHandler != NULL)
+        if(pRootHandler != NULL)
         {
             // Parse the entire install manifest
-            dwErrCode = pRootHandler->Load(hs, InHeader, pbInstallFile, pbInstallFile + cbInstallFile);
+            dwErrCode = pRootHandler->Load(hs, InHeader, InstallFile.pbData, InstallFile.End());
             hs->pRootHandler = pRootHandler;
         }
     }
diff --git a/dep/CascLib/src/CascRootFile_MNDX.cpp b/dep/CascLib/src/CascRootFile_MNDX.cpp
index c049d813967..9b820c0d639 100644
--- a/dep/CascLib/src/CascRootFile_MNDX.cpp
+++ b/dep/CascLib/src/CascRootFile_MNDX.cpp
@@ -419,10 +419,10 @@ class TByteStream
             return ERROR_NOT_ENOUGH_MEMORY;
 
         // Allocate bytes for the array
-        if (Pointer != NULL)
+        if(Pointer != NULL)
         {
             Pointer[0] = CASC_ALLOC<T>(ItemCount);
-            if (Pointer[0] == NULL)
+            if(Pointer[0] == NULL)
                 return ERROR_NOT_ENOUGH_MEMORY;
 
             // Get the pointer to the array
@@ -804,7 +804,7 @@ class TSparseArray
 
         // Search the groups and find the BASEVALS structure
         // For spans less than 10 groups, use sequential search, otherwise binary search.
-        if ((maxGroup - minGroup) < 10)
+        if((maxGroup - minGroup) < 10)
         {
             // HOTS: 1959CF7
             while (index >= GROUP_TO_INDEX(minGroup) - BaseVals[minGroup + 1].BaseValue200 + 0x200)
@@ -821,7 +821,7 @@ class TSparseArray
                 // HOTS: 1959D38
                 DWORD middleValue = (maxGroup + minGroup) >> 1;
 
-                if (index < (maxGroup << 0x09) - BaseVals[maxGroup].BaseValue200)
+                if(index < (maxGroup << 0x09) - BaseVals[maxGroup].BaseValue200)
                 {
                     // HOTS: 01959D4B
                     maxGroup = middleValue;
@@ -845,7 +845,7 @@ class TSparseArray
 
         // Find the BASEVALS structure which the start index belongs to
         // For less than 10 values, use sequential search. Otherwise, use binary search
-        if ((nextValue - startValue) < 10)
+        if((nextValue - startValue) < 10)
         {
             // HOTS: 01959F94
             while (index >= BaseVals[startValue + 1].BaseValue200)
@@ -857,12 +857,12 @@ class TSparseArray
         else
         {
             // Binary search (HOTS: 1959FAD)
-            if ((startValue + 1) < nextValue)
+            if((startValue + 1) < nextValue)
             {
                 // HOTS: 1959FB4
                 DWORD middleValue = (nextValue + startValue) >> 1;
 
-                if (index < BaseVals[middleValue].BaseValue200)
+                if(index < BaseVals[middleValue].BaseValue200)
                 {
                     // HOTS: 1959FC4
                     nextValue = middleValue;
@@ -889,7 +889,7 @@ class TSparseArray
         DWORD edx = index;
 
 #ifdef _DEBUG
-        //if (TotalItemCount > 0x200)
+        //if(TotalItemCount > 0x200)
         //{
         //    FILE * fp = fopen("e:\\Ladik\\Appdir\\CascLib\\doc\\mndx-sparse-array.txt", "wt");
         //    Dump(fp);
@@ -898,7 +898,7 @@ class TSparseArray
 #endif
 
         // If the index is at begin of the group, we just return the start value
-        if ((index & 0x1FF) == 0)
+        if((index & 0x1FF) == 0)
             return IndexToItem0[INDEX_TO_GROUP(index)];
 
         // Find the group where the index belongs to
@@ -908,13 +908,13 @@ class TSparseArray
         edx += BaseVals[groupIndex].BaseValue200 - (groupIndex << 0x09);
         dwordIndex = (groupIndex << 4);
 
-        if (edx < 0x100 - BaseVals[groupIndex].AddValue100)
+        if(edx < 0x100 - BaseVals[groupIndex].AddValue100)
         {
             // HOTS: 1959D8C
-            if (edx < 0x80 - BaseVals[groupIndex].AddValue80)
+            if(edx < 0x80 - BaseVals[groupIndex].AddValue80)
             {
                 // HOTS: 01959DA2
-                if (edx >= 0x40 - BaseVals[groupIndex].AddValue40)
+                if(edx >= 0x40 - BaseVals[groupIndex].AddValue40)
                 {
                     // HOTS: 01959DB7
                     dwordIndex += 2;
@@ -924,7 +924,7 @@ class TSparseArray
             else
             {
                 // HOTS: 1959DC0
-                if (edx < 0xC0 - BaseVals[groupIndex].AddValueC0)
+                if(edx < 0xC0 - BaseVals[groupIndex].AddValueC0)
                 {
                     // HOTS: 1959DD3
                     dwordIndex += 4;
@@ -941,10 +941,10 @@ class TSparseArray
         else
         {
             // HOTS: 1959DE8
-            if (edx < 0x180 - BaseVals[groupIndex].AddValue180)
+            if(edx < 0x180 - BaseVals[groupIndex].AddValue180)
             {
                 // HOTS: 01959E00
-                if (edx < 0x140 - BaseVals[groupIndex].AddValue140)
+                if(edx < 0x140 - BaseVals[groupIndex].AddValue140)
                 {
                     // HOTS: 1959E11
                     dwordIndex += 8;
@@ -960,7 +960,7 @@ class TSparseArray
             else
             {
                 // HOTS: 1959E29
-                if (edx < 0x1C0 - BaseVals[groupIndex].AddValue1C0)
+                if(edx < 0x1C0 - BaseVals[groupIndex].AddValue1C0)
                 {
                     // HOTS: 1959E3D
                     dwordIndex += 12;
@@ -980,7 +980,7 @@ class TSparseArray
         bitGroup = ~ItemBits[dwordIndex];
         zeroBits = GetNumberOfSetBits(bitGroup);
 
-        if (edx >= zeroBits.u.Lower32)
+        if(edx >= zeroBits.u.Lower32)
         {
             // HOTS: 1959ea4
             bitGroup = ~ItemBits[++dwordIndex];
@@ -992,10 +992,10 @@ class TSparseArray
         itemIndex = (dwordIndex << 0x05);
 
         // HOTS: 1959eea
-        if (edx < zeroBits.u.Lower16)
+        if(edx < zeroBits.u.Lower16)
         {
             // HOTS: 1959EFC
-            if (edx >= zeroBits.u.Lower08)
+            if(edx >= zeroBits.u.Lower08)
             {
                 // HOTS: 1959F05
                 bitGroup >>= 0x08;
@@ -1006,7 +1006,7 @@ class TSparseArray
         else
         {
             // HOTS: 1959F0D
-            if (edx < zeroBits.u.Lower24)
+            if(edx < zeroBits.u.Lower24)
             {
                 // HOTS: 1959F19
                 bitGroup >>= 0x10;
@@ -1043,7 +1043,7 @@ class TSparseArray
         DWORD bitGroup;
 
         // If the index is at begin of the group, we just return the start value
-        if ((index & 0x1FF) == 0)
+        if((index & 0x1FF) == 0)
             return IndexToItem1[INDEX_TO_GROUP(index)];
 
         // Find the group where the index belongs to
@@ -1054,13 +1054,13 @@ class TSparseArray
         dwordIndex = groupIndex << 0x04;
 
         // Calculate the dword index including the sub-checkpoint
-        if (distFromBase < BaseVals[groupIndex].AddValue100)
+        if(distFromBase < BaseVals[groupIndex].AddValue100)
         {
             // HOTS: 1959FF1
-            if (distFromBase < BaseVals[groupIndex].AddValue80)
+            if(distFromBase < BaseVals[groupIndex].AddValue80)
             {
                 // HOTS: 0195A000
-                if (distFromBase >= BaseVals[groupIndex].AddValue40)
+                if(distFromBase >= BaseVals[groupIndex].AddValue40)
                 {
                     // HOTS: 195A007
                     distFromBase = distFromBase - BaseVals[groupIndex].AddValue40;
@@ -1070,7 +1070,7 @@ class TSparseArray
             else
             {
                 // HOTS: 195A00E
-                if (distFromBase < BaseVals[groupIndex].AddValueC0)
+                if(distFromBase < BaseVals[groupIndex].AddValueC0)
                 {
                     // HOTS: 195A01A
                     distFromBase = distFromBase - BaseVals[groupIndex].AddValue80;
@@ -1087,10 +1087,10 @@ class TSparseArray
         else
         {
             // HOTS: 195A026
-            if (distFromBase < BaseVals[groupIndex].AddValue180)
+            if(distFromBase < BaseVals[groupIndex].AddValue180)
             {
                 // HOTS: 195A037
-                if (distFromBase < BaseVals[groupIndex].AddValue140)
+                if(distFromBase < BaseVals[groupIndex].AddValue140)
                 {
                     // HOTS: 195A041
                     distFromBase = distFromBase - BaseVals[groupIndex].AddValue100;
@@ -1106,7 +1106,7 @@ class TSparseArray
             else
             {
                 // HOTS: 195A04D
-                if (distFromBase < BaseVals[groupIndex].AddValue1C0)
+                if(distFromBase < BaseVals[groupIndex].AddValue1C0)
                 {
                     // HOTS: 195A05A
                     distFromBase = distFromBase - BaseVals[groupIndex].AddValue180;
@@ -1126,7 +1126,7 @@ class TSparseArray
         setBits = GetNumberOfSetBits(bitGroup);
 
         // Get total number of set bits in the bit group
-        if (distFromBase >= setBits.u.Lower32)
+        if(distFromBase >= setBits.u.Lower32)
         {
             // HOTS: 195A0B2
             bitGroup = ItemBits[++dwordIndex];
@@ -1138,10 +1138,10 @@ class TSparseArray
         itemIndex = (dwordIndex << 0x05);
 
         // Get the number of set bits in the lower word (HOTS: 195A0F6)
-        if (distFromBase < setBits.u.Lower16)
+        if(distFromBase < setBits.u.Lower16)
         {
             // HOTS: 195A111
-            if (distFromBase >= setBits.u.Lower08)
+            if(distFromBase >= setBits.u.Lower08)
             {
                 // HOTS: 195A111
                 itemIndex = itemIndex + 0x08;
@@ -1152,7 +1152,7 @@ class TSparseArray
         else
         {
             // HOTS: 195A119
-            if (distFromBase < setBits.u.Lower24)
+            if(distFromBase < setBits.u.Lower24)
             {
                 // HOTS: 195A125
                 bitGroup = bitGroup >> 0x10;
@@ -1190,7 +1190,7 @@ class TSparseArray
                     "========================================================\n"
                     "   Index    Base200h  +40  +80  +C0  +100 +140 +180 +1C0\n"
                     "--------------------------------------------------------\n");
-        for (size_t i = 0; i < BaseVals.ItemCount; i++)
+        for(size_t i = 0; i < BaseVals.ItemCount; i++)
         {
             fprintf(fp, "[%08zX]: %08x  %04x %04x %04x %04x %04x %04x %04x\n", GROUP_TO_INDEX(i), BaseVals[i].BaseValue200,
                 BaseVals[i].AddValue40,
@@ -1208,7 +1208,7 @@ class TSparseArray
                     "========================================\n"
                     "   Index     Item0    Item1\n"
                     "-----------------------------\n");
-        for (size_t i = 0; i < IndexToItem0.ItemCount; i++)
+        for(size_t i = 0; i < IndexToItem0.ItemCount; i++)
         {
             fprintf(fp, "[%08zX]: %08x %08x\n", GROUP_TO_INDEX(i), IndexToItem0[i], IndexToItem1[i]);
         }
@@ -1218,16 +1218,16 @@ class TSparseArray
         // Output values of Item1 and Item0 for every index
         ArrayNormal = new size_t[TotalItemCount];
         ArrayInvert = new size_t[TotalItemCount];
-        if (ArrayNormal && ArrayInvert)
+        if(ArrayNormal && ArrayInvert)
         {
             // Invalidate both arrays
             memset(ArrayNormal, 0xFF, TotalItemCount * sizeof(size_t));
             memset(ArrayInvert, 0xFF, TotalItemCount * sizeof(size_t));
 
             // Load the both arrays
-            for (size_t i = 0; i < TotalItemCount; i++)
+            for(size_t i = 0; i < TotalItemCount; i++)
             {
-                if (IsItemPresent(i))
+                if(IsItemPresent(i))
                     ArrayNormal[IndexNormal++] = i;
                 else
                     ArrayInvert[IndexInvert++] = i;
@@ -1238,12 +1238,12 @@ class TSparseArray
                         "========================================\n"
                         "   Index     Item0    Item1\n"
                         "-----------------------------\n");
-            for (size_t i = 0; i < TotalItemCount; i++)
+            for(size_t i = 0; i < TotalItemCount; i++)
             {
                 char NormalValue[0x20];
                 char InvertValue[0x20];
 
-                if (ArrayNormal[i] == MNDX_INVALID_SIZE_T && ArrayInvert[i] == MNDX_INVALID_SIZE_T)
+                if(ArrayNormal[i] == MNDX_INVALID_SIZE_T && ArrayInvert[i] == MNDX_INVALID_SIZE_T)
                     break;
                 fprintf(fp, "[%08zX]: %8s  %8s\n", i, DumpValue(InvertValue, _countof(InvertValue), ArrayInvert[i]), DumpValue(NormalValue, _countof(NormalValue), ArrayNormal[i]));
             }
@@ -1256,9 +1256,9 @@ class TSparseArray
 
         // Output array of all values
         fprintf(fp, "Item List: Index -> Value\n==========================\n");
-        for (size_t i = 0; i < TotalItemCount; i++)
+        for(size_t i = 0; i < TotalItemCount; i++)
         {
-            if (IsItemPresent(i))
+            if(IsItemPresent(i))
             {
                 fprintf(fp, "[%08zX]: %08x\n", i, GetItemValueAt(i));
             }
@@ -1441,7 +1441,7 @@ class TPathFragmentTable
         TStruct40 * pStruct40 = &pSearch->Struct40;
 
         // Do we have path fragment separators in an external structure?
-        if (PathMarks.IsEmpty())
+        if(PathMarks.IsEmpty())
         {
             // HOTS: 195A40C
             while (PathFragments[nFragmentOffset] != 0)
@@ -1694,13 +1694,13 @@ class TFileNameDatabase
     DWORD GetPathFragmentOffset2(DWORD & index_hibits, DWORD index_lobits)
     {
         // If the hi-bits index is invalid, we need to get its starting value
-        if (index_hibits == CASC_INVALID_INDEX)
+        if(index_hibits == CASC_INVALID_INDEX)
         {
 /*
             printf("\n");
-            for (DWORD i = 0; i < CollisionHiBitsIndexes.TotalItemCount; i++)
+            for(DWORD i = 0; i < CollisionHiBitsIndexes.TotalItemCount; i++)
             {
-                if (CollisionHiBitsIndexes.IsItemPresent(i))
+                if(CollisionHiBitsIndexes.IsItemPresent(i))
                     printf("[%02X] = %02X\n", i, CollisionHiBitsIndexes.GetIntValueAt(i));
                 else
                     printf("[%02X] = NOT_PRESENT\n", i);
@@ -1775,17 +1775,17 @@ class TFileNameDatabase
         if(pHashEntry->NodeIndex == pStruct40->NodeIndex)
         {
             // Check if there is single character match
-            if (!IsPathFragmentSingleChar(pHashEntry))
+            if(!IsPathFragmentSingleChar(pHashEntry))
             {
                 // Check if there is a name fragment match
-                if (pChildDB != NULL)
+                if(pChildDB != NULL)
                 {
-                    if (!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
+                    if(!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
                         return false;
                 }
                 else
                 {
-                    if (!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset))
+                    if(!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset))
                         return false;
                 }
             }
@@ -1863,82 +1863,82 @@ class TFileNameDatabase
         DWORD eax;
 
         // HOTS: 1957B95
-        for (;;)
+        for(;;)
         {
             // Get the hasn table item
             pHashEntry = &HashTable[TableIndex & HashTableMask];
 
             // 
-            if (TableIndex == pHashEntry->NextIndex)
+            if(TableIndex == pHashEntry->NextIndex)
             {
                 // HOTS: 01957BB4
-                if (!IsPathFragmentSingleChar(pHashEntry))
+                if(!IsPathFragmentSingleChar(pHashEntry))
                 {
                     // HOTS: 1957BC7
-                    if (pChildDB != NULL)
+                    if(pChildDB != NULL)
                     {
                         // HOTS: 1957BD3
-                        if (!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
+                        if(!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
                             return false;
                     }
                     else
                     {
                         // HOTS: 1957BE0
-                        if (!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset))
+                        if(!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset))
                             return false;
                     }
                 }
                 else
                 {
                     // HOTS: 1957BEE
-                    if (pSearch->szSearchMask[pStruct40->PathLength] != pHashEntry->SingleChar)
+                    if(pSearch->szSearchMask[pStruct40->PathLength] != pHashEntry->SingleChar)
                         return false;
                     pStruct40->PathLength++;
                 }
 
                 // HOTS: 1957C05
                 TableIndex = pHashEntry->NodeIndex;
-                if (TableIndex == 0)
+                if(TableIndex == 0)
                     return true;
 
-                if (pStruct40->PathLength >= pSearch->cchSearchMask)
+                if(pStruct40->PathLength >= pSearch->cchSearchMask)
                     return false;
             }
             else
             {
                 // HOTS: 1957C30
-                if (IsPathFragmentString(TableIndex))
+                if(IsPathFragmentString(TableIndex))
                 {
                     DWORD FragmentOffset = GetPathFragmentOffset1(TableIndex);
 
                     // HOTS: 1957C4C
-                    if (pChildDB != NULL)
+                    if(pChildDB != NULL)
                     {
                         // HOTS: 1957C58
-                        if (!pChildDB->ComparePathFragmentByIndex(pSearch, FragmentOffset))
+                        if(!pChildDB->ComparePathFragmentByIndex(pSearch, FragmentOffset))
                             return false;
                     }
                     else
                     {
                         // HOTS: 1957350
-                        if (!PathFragmentTable.ComparePathFragment(pSearch, FragmentOffset))
+                        if(!PathFragmentTable.ComparePathFragment(pSearch, FragmentOffset))
                             return false;
                     }
                 }
                 else
                 {
                     // HOTS: 1957C8E
-                    if (LoBitsTable[TableIndex] != pSearch->szSearchMask[pStruct40->PathLength])
+                    if(LoBitsTable[TableIndex] != pSearch->szSearchMask[pStruct40->PathLength])
                         return false;
 
                     pStruct40->PathLength++;
                 }
 
                 // HOTS: 1957CB2
-                if (TableIndex <= field_214)
+                if(TableIndex <= field_214)
                     return true;
 
-                if (pStruct40->PathLength >= pSearch->cchSearchMask)
+                if(pStruct40->PathLength >= pSearch->cchSearchMask)
                     return false;
 
                 eax = CollisionTable.GetItem1(TableIndex);
@@ -1954,16 +1954,16 @@ class TFileNameDatabase
         PHASH_ENTRY pHashEntry;
 
         // HOTS: 1958D84
-        for (;;)
+        for(;;)
         {
             pHashEntry = &HashTable[TableIndex & HashTableMask];
-            if (TableIndex == pHashEntry->NextIndex)
+            if(TableIndex == pHashEntry->NextIndex)
             {
                 // HOTS: 1958DA6
-                if (!IsPathFragmentSingleChar(pHashEntry))
+                if(!IsPathFragmentSingleChar(pHashEntry))
                 {
                     // HOTS: 1958DBA
-                    if (pChildDB != NULL)
+                    if(pChildDB != NULL)
                     {
                         pChildDB->CopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex);
                     }
@@ -1981,18 +1981,18 @@ class TFileNameDatabase
 
                 // HOTS: 1958E71
                 TableIndex = pHashEntry->NodeIndex;
-                if (TableIndex == 0)
+                if(TableIndex == 0)
                     return;
             }
             else
             {
                 // HOTS: 1958E8E
-                if (IsPathFragmentString(TableIndex))
+                if(IsPathFragmentString(TableIndex))
                 {
                     DWORD FragmentOffset = GetPathFragmentOffset1(TableIndex);
 
                     // HOTS: 1958EAF
-                    if (pChildDB != NULL)
+                    if(pChildDB != NULL)
                     {
                         pChildDB->CopyPathFragmentByIndex(pSearch, FragmentOffset);
                     }
@@ -2009,7 +2009,7 @@ class TFileNameDatabase
                 }
 
                 // HOTS: 1958FDE
-                if (TableIndex <= field_214)
+                if(TableIndex <= field_214)
                     return;
 
                 TableIndex = 0xFFFFFFFF - TableIndex + CollisionTable.GetItem1(TableIndex);
@@ -2027,9 +2027,9 @@ class TFileNameDatabase
         DWORD TableIndex;
 /*
         FILE * fp = fopen("E:\\PathFragmentTable.txt", "wt");
-        if (fp != NULL)
+        if(fp != NULL)
         {
-            for (DWORD i = 0; i < HashTable.ItemCount; i++)
+            for(DWORD i = 0; i < HashTable.ItemCount; i++)
             {
                 FragOffs = HashTable[i].FragOffs;
                 fprintf(fp, "%02x ('%c') %08X %08X %08X", i, (0x20 <= i && i < 0x80) ? i : 0x20, HashTable[i].ItemIndex, HashTable[i].NextIndex, FragOffs);
@@ -2059,14 +2059,14 @@ class TFileNameDatabase
             if(!IsPathFragmentSingleChar(pHashEntry))
             {
                 // HOTS: 1958B59
-                if (pChildDB != NULL)
+                if(pChildDB != NULL)
                 {
-                    if (!pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
+                    if(!pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex))
                         return false;
                 }
                 else
                 {
-                    if (!PathFragmentTable.CompareAndCopyPathFragment(pSearch, pHashEntry->FragmentOffset))
+                    if(!PathFragmentTable.CompareAndCopyPathFragment(pSearch, pHashEntry->FragmentOffset))
                         return false;
                 }
             }
@@ -2232,7 +2232,7 @@ class TFileNameDatabase
         DWORD edi;
 
         // Perform action based on the search phase
-        switch (pStruct40->SearchPhase)
+        switch(pStruct40->SearchPhase)
         {
             case MNDX_SEARCH_INITIALIZING:
             {
@@ -2242,7 +2242,7 @@ class TFileNameDatabase
                 // If the caller passed a part of the search path, we need to find that one
                 while (pStruct40->PathLength < pSearch->cchSearchMask)
                 {
-                    if (!CompareAndCopyPathFragment(pSearch))
+                    if(!CompareAndCopyPathFragment(pSearch))
                     {
                         pStruct40->SearchPhase = MNDX_SEARCH_FINISHED;
                         return false;
@@ -2254,7 +2254,7 @@ class TFileNameDatabase
                 pStruct40->PathStops.Insert(PathStop);
                 pStruct40->ItemCount = 1;
 
-                if (FileNameIndexes.IsItemPresent(pStruct40->NodeIndex))
+                if(FileNameIndexes.IsItemPresent(pStruct40->NodeIndex))
                 {
                     pSearch->szFoundPath = &pStruct40->PathBuffer[0];
                     pSearch->cchFoundPath = pStruct40->PathBuffer.ItemCount;
@@ -2267,10 +2267,10 @@ class TFileNameDatabase
             case MNDX_SEARCH_SEARCHING:
             {
                 // HOTS: 1959522
-                for (;;)
+                for(;;)
                 {
                     // HOTS: 1959530
-                    if (pStruct40->ItemCount == pStruct40->PathStops.ItemCount)
+                    if(pStruct40->ItemCount == pStruct40->PathStops.ItemCount)
                     {
                         TPathStop * pLastStop;
                         DWORD ColTableIndex;
@@ -2288,17 +2288,17 @@ class TFileNameDatabase
                     pPathStop = &pStruct40->PathStops[pStruct40->ItemCount];
 
                     // HOTS: 19595CC
-                    if (CollisionTable.IsItemPresent(pPathStop->field_4++))
+                    if(CollisionTable.IsItemPresent(pPathStop->field_4++))
                     {
                         // HOTS: 19595F2
                         pStruct40->ItemCount++;
 
-                        if (IsPathFragmentString(pPathStop->LoBitsIndex))
+                        if(IsPathFragmentString(pPathStop->LoBitsIndex))
                         {
                             DWORD FragmentOffset = GetPathFragmentOffset2(pPathStop->HiBitsIndex_PathFragment, pPathStop->LoBitsIndex);
 
                             // HOTS: 1959630
-                            if (pChildDB != NULL)
+                            if(pChildDB != NULL)
                             {
                                 // HOTS: 1959649
                                 pChildDB->CopyPathFragmentByIndex(pSearch, FragmentOffset);
@@ -2320,10 +2320,10 @@ class TFileNameDatabase
                         pPathStop->Count = pStruct40->PathBuffer.ItemCount;
 
                         // HOTS: 19596b6
-                        if (FileNameIndexes.IsItemPresent(pPathStop->LoBitsIndex))
+                        if(FileNameIndexes.IsItemPresent(pPathStop->LoBitsIndex))
                         {
                             // HOTS: 19596D1
-                            if (pPathStop->field_10 == 0xFFFFFFFF)
+                            if(pPathStop->field_10 == 0xFFFFFFFF)
                             {
                                 // HOTS: 19596D9
                                 pPathStop->field_10 = FileNameIndexes.GetItemValueAt(pPathStop->LoBitsIndex);
@@ -2343,7 +2343,7 @@ class TFileNameDatabase
                     else
                     {
                         // HOTS: 19596E9
-                        if (pStruct40->ItemCount == 1)
+                        if(pStruct40->ItemCount == 1)
                         {
                             pStruct40->SearchPhase = MNDX_SEARCH_FINISHED;
                             return false;
@@ -2435,7 +2435,7 @@ class TFileNameDatabase
             TFileNameDatabase * pNewDB;
 
             pNewDB = new TFileNameDatabase;
-            if (pNewDB == NULL)
+            if(pNewDB == NULL)
                 return ERROR_NOT_ENOUGH_MEMORY;
 
             dwErrCode = SetChildDatabase(pNewDB);
@@ -2627,11 +2627,11 @@ struct TMndxHandler
     {
         // Capture the root header
         pbRootPtr = CaptureData(pbRootPtr, pbRootEnd, &MndxHeader, sizeof(FILE_MNDX_HEADER));
-        if (pbRootPtr == NULL)
+        if(pbRootPtr == NULL)
             return NULL;
 
         // Check signature and version
-        if (MndxHeader.Signature != CASC_MNDX_ROOT_SIGNATURE || MndxHeader.FormatVersion > 2 || MndxHeader.FormatVersion < 1)
+        if(MndxHeader.Signature != CASC_MNDX_ROOT_SIGNATURE || MndxHeader.FormatVersion > 2 || MndxHeader.FormatVersion < 1)
             return NULL;
 
         // Passed
@@ -2665,14 +2665,14 @@ struct TMndxHandler
             // Insert new package to the array
             assert(Search.nIndex < nPackageCount);
             pPackage = (PMNDX_PACKAGE)Packages.InsertAt(Search.nIndex);
-            if (pPackage != NULL)
+            if(pPackage != NULL)
             {
                 // The package mut not be initialized yet
                 assert(pPackage->szFileName == NULL);
 
                 // Allocate space for the file name
                 pPackage->szFileName = CASC_ALLOC<char>(Search.cchFoundPath + 1);
-                if (pPackage->szFileName == NULL)
+                if(pPackage->szFileName == NULL)
                     return ERROR_NOT_ENOUGH_MEMORY;
 
                 // Fill the package structure
@@ -2765,7 +2765,7 @@ struct TMndxHandler
             if(pMarFile->GetFileNameCount(&FileNameCount) == ERROR_SUCCESS && FileNameCount == MndxInfo.FileNameCount)
             {
                 CKeyEntriesSize = MndxInfo.CKeyEntriesCount * MndxInfo.CKeyEntrySize;
-                if ((pbRootFile + MndxInfo.CKeyEntriesOffset + CKeyEntriesSize) <= pbRootEnd)
+                if((pbRootFile + MndxInfo.CKeyEntriesOffset + CKeyEntriesSize) <= pbRootEnd)
                 {
                     pCKeyEntries = (PMNDX_CKEY_ENTRY)(pbRootFile + MndxInfo.CKeyEntriesOffset);
                     dwErrCode = ERROR_SUCCESS;
@@ -2789,17 +2789,17 @@ struct TMndxHandler
                 // Get the remaining file name groups
                 for(i = 0; i < MndxInfo.CKeyEntriesCount; i++, pRootEntry++)
                 {
-                    if (nFileNameIndex > MndxInfo.FileNameCount)
+                    if(nFileNameIndex > MndxInfo.FileNameCount)
                         break;
 
-                    if (pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY)
+                    if(pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY)
                     {
                         FileNameIndexToCKeyIndex[nFileNameIndex++] = pRootEntry + 1;
                     }
                 }
 
                 // Verify the final number of file names
-                if ((nFileNameIndex - 1) != MndxInfo.FileNameCount)
+                if((nFileNameIndex - 1) != MndxInfo.FileNameCount)
                     dwErrCode = ERROR_BAD_FORMAT;
             }
             else
@@ -2837,7 +2837,7 @@ struct TMndxHandler
             assert(Search.cchFoundPath < MAX_PATH);
 
             // The found file name index must fall into range of file names
-            if (Search.nIndex < MndxInfo.FileNameCount)
+            if(Search.nIndex < MndxInfo.FileNameCount)
             {
                 // Retrieve the first-in-group CKey entry of that name
                 pRootEntry = FileNameIndexToCKeyIndex[Search.nIndex];
@@ -2847,13 +2847,13 @@ struct TMndxHandler
                 {
                     // Find the appropriate CKey entry in the central storage
                     pCKeyEntry = FindCKeyEntry_CKey(hs, pRootEntry->CKey);
-                    if (pCKeyEntry != NULL)
+                    if(pCKeyEntry != NULL)
                     {
                         size_t nPackageIndex = pRootEntry->Flags & 0x00FFFFFF;
 
                         // Retrieve the package for this entry
                         pPackage = (PMNDX_PACKAGE)Packages.ItemAt(nPackageIndex);
-                        if (pPackage != NULL)
+                        if(pPackage != NULL)
                         {
                             // Sanity check
                             assert(pPackage->nIndex == nPackageIndex);
@@ -2867,7 +2867,7 @@ struct TMndxHandler
                     }
 
                     // Is this the last-in-group entry?
-                    if (pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY)
+                    if(pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY)
                         break;
                     pRootEntry++;
                 }
@@ -2889,18 +2889,18 @@ struct TMndxHandler
         assert((pPackage->nLength + 1 + pSearch->cchFoundPath + 1) < cchBuffer);
 
         // Copy the package name
-        if ((szBuffer + pPackage->nLength) < szBufferEnd)
+        if((szBuffer + pPackage->nLength) < szBufferEnd)
         {
             memcpy(szBuffer, pPackage->szFileName, pPackage->nLength);
             szBuffer += pPackage->nLength;
         }
 
         // Append slash
-        if ((szBuffer + 1) < szBufferEnd)
+        if((szBuffer + 1) < szBufferEnd)
             *szBuffer++ = '/';
 
         // Append file name
-        if ((szBuffer + pSearch->cchFoundPath) < szBufferEnd)
+        if((szBuffer + pSearch->cchFoundPath) < szBufferEnd)
         {
             memcpy(szBuffer, pSearch->szFoundPath, pSearch->cchFoundPath);
             szBuffer += pSearch->cchFoundPath;
@@ -2938,7 +2938,7 @@ struct TRootHandler_MNDX : public TFileTreeRoot
 
         // Load and parse the entire MNDX structure
         dwErrCode = Handler.Load(MndxHeader, pbRootFile, pbRootEnd);
-        if (dwErrCode == ERROR_SUCCESS)
+        if(dwErrCode == ERROR_SUCCESS)
         {
             // Search all file names and insert them into the file tree
             dwErrCode = Handler.LoadFileNames(hs, FileTree);
@@ -2951,11 +2951,12 @@ struct TRootHandler_MNDX : public TFileTreeRoot
 //-----------------------------------------------------------------------------
 // Public functions - MNDX info
 
-DWORD RootHandler_CreateMNDX(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+DWORD RootHandler_CreateMNDX(TCascStorage * hs, CASC_BLOB & RootFile)
 {
     TRootHandler_MNDX * pRootHandler = NULL;
     FILE_MNDX_HEADER MndxHeader;
-    LPBYTE pbRootEnd = pbRootFile + cbRootFile;
+    LPBYTE pbRootFile = RootFile.pbData;
+    LPBYTE pbRootEnd = RootFile.End();
     DWORD dwErrCode = ERROR_BAD_FORMAT;
 
     // Verify the header of the ROOT file
diff --git a/dep/CascLib/src/CascRootFile_OW.cpp b/dep/CascLib/src/CascRootFile_OW.cpp
index b270ec76206..b1fbd5b9fec 100644
--- a/dep/CascLib/src/CascRootFile_OW.cpp
+++ b/dep/CascLib/src/CascRootFile_OW.cpp
@@ -175,7 +175,7 @@ struct TCmfFile
         {
             PCMF_HEADER_V3 pHeader3 = (PCMF_HEADER_V3)pbCmfData;
             
-            if ((LPBYTE)(pHeader3 + 1) > pbCmfEnd)
+            if((LPBYTE)(pHeader3 + 1) > pbCmfEnd)
                 return NULL;
 
             BuildVersion = pHeader3->BuildVersion;
@@ -559,7 +559,7 @@ struct TRootHandler_OW : public TFileTreeRoot
 // Public functions
 
 // TODO: There is way more files in the Overwatch CASC storage than present in the ROOT file.
-DWORD RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+DWORD RootHandler_CreateOverwatch(TCascStorage * hs, CASC_BLOB & RootFile)
 {
     TRootHandler_OW * pRootHandler = NULL;
     CASC_CSV Csv(0, true);
@@ -567,7 +567,7 @@ DWORD RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cb
     DWORD dwErrCode;
 
     // Load the ROOT file
-    dwErrCode = Csv.Load(pbRootFile, cbRootFile);
+    dwErrCode = Csv.Load(RootFile.pbData, RootFile.cbData);
     if(dwErrCode == ERROR_SUCCESS)
     {
         // Retrieve the indices of the file name and MD5 columns
@@ -578,11 +578,11 @@ DWORD RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cb
         if(Indices[0] != CSV_INVALID_INDEX && Indices[1] != CSV_INVALID_INDEX)
         {
             pRootHandler = new TRootHandler_OW();
-            if (pRootHandler != NULL)
+            if(pRootHandler != NULL)
             {
                 // Load the root directory. If load failed, we free the object
                 dwErrCode = pRootHandler->Load(hs, Csv, Indices[0], Indices[1]);
-                if (dwErrCode != ERROR_SUCCESS)
+                if(dwErrCode != ERROR_SUCCESS)
                 {
                     delete pRootHandler;
                     pRootHandler = NULL;
diff --git a/dep/CascLib/src/CascRootFile_TVFS.cpp b/dep/CascLib/src/CascRootFile_TVFS.cpp
index 5c099ad3460..52408bf6660 100644
--- a/dep/CascLib/src/CascRootFile_TVFS.cpp
+++ b/dep/CascLib/src/CascRootFile_TVFS.cpp
@@ -36,8 +36,18 @@
 // Local structures
 
 // In-memory layout of the TVFS file header
-typedef struct _TVFS_DIRECTORY_HEADER
+struct TVFS_DIRECTORY_HEADER
 {
+    TVFS_DIRECTORY_HEADER()
+    {
+        memset(this, 0, sizeof(TVFS_DIRECTORY_HEADER) - FIELD_OFFSET(TVFS_DIRECTORY_HEADER, Data));
+    }
+
+    LPBYTE DataAt(DWORD dwOffset)
+    {
+        return Data.pbData + dwOffset;
+    }
+
     DWORD Signature;                                // Must be CASC_TVFS_ROOT_SIGNATURE
     BYTE  FormatVersion;                            // Version of the format. Should be 1.
     BYTE  HeaderSize;                               // Size of the header, in bytes
@@ -59,9 +69,8 @@ typedef struct _TVFS_DIRECTORY_HEADER
     DWORD  CftOffsSize;                             // Byte length of the offset in the Content File Table entry
     DWORD  EstOffsSize;                             // Byte length of the offset in the Encoding Specifier Table entry
 
-    LPBYTE pbDirectoryData;                         // Pointer to the begin of directory data
-    LPBYTE pbDirectoryEnd;                          // Pointer to the end of directory data
-
+    CASC_BLOB Data;                                 // The complete directory data
+    
 //  LPBYTE pbPathFileTable;                         // Begin and end of the path table
 //  LPBYTE pbPathTableEnd;
 
@@ -71,7 +80,7 @@ typedef struct _TVFS_DIRECTORY_HEADER
 //  LPBYTE pbCftFileTable;                          // Begin and end of the content file table
 //  LPBYTE pbCftTableEnd;
 
-} TVFS_DIRECTORY_HEADER, *PTVFS_DIRECTORY_HEADER;
+};
 
 /*
 // Minimum size of a valid path table entry. 1 byte + 1-byte name + 1 byte + DWORD
@@ -157,12 +166,15 @@ struct TRootHandler_TVFS : public TFileTreeRoot
         return true;
     }
 
-    static DWORD CaptureDirectoryHeader(TVFS_DIRECTORY_HEADER & DirHeader, LPBYTE pbDataPtr, LPBYTE pbDataEnd)
+    static DWORD CaptureDirectoryHeader(TVFS_DIRECTORY_HEADER & DirHeader, CASC_BLOB & Data)
     {
-        // Fill the header structure with zeros
-        memset(&DirHeader, 0, sizeof(TVFS_DIRECTORY_HEADER));
-        DirHeader.pbDirectoryData = pbDataPtr;
-        DirHeader.pbDirectoryEnd = pbDataEnd;
+        LPBYTE pbDataPtr = NULL;
+        LPBYTE pbDataEnd = NULL;
+
+        // Extract the data out of the buffer
+        DirHeader.Data.MoveFrom(Data);
+        pbDataPtr = DirHeader.Data.pbData;
+        pbDataEnd = DirHeader.Data.End();
 
         // Capture the signature
         pbDataPtr = CaptureInteger32(pbDataPtr, pbDataEnd, &DirHeader.Signature);
@@ -189,7 +201,7 @@ struct TRootHandler_TVFS : public TFileTreeRoot
         DirHeader.VfsTableSize    = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.VfsTableSize));
         DirHeader.CftTableOffset  = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.CftTableOffset));
         DirHeader.CftTableSize    = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.CftTableSize));
-        DirHeader.MaxDepth        = (USHORT)ConvertBytesToInteger_2((LPBYTE)(&DirHeader.MaxDepth));
+        DirHeader.MaxDepth        = ConvertBytesToInteger_2((LPBYTE)(&DirHeader.MaxDepth));
         DirHeader.EstTableOffset  = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.EstTableOffset));
         DirHeader.EstTableSize    = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.EstTableSize));
 
@@ -220,7 +232,7 @@ struct TRootHandler_TVFS : public TFileTreeRoot
 
     LPBYTE CaptureVfsSpanCount(TVFS_DIRECTORY_HEADER & DirHeader, DWORD dwVfsOffset, DWORD & SpanCount)
     {
-        LPBYTE pbVfsFileTable = DirHeader.pbDirectoryData + DirHeader.VfsTableOffset;
+        LPBYTE pbVfsFileTable = DirHeader.DataAt(DirHeader.VfsTableOffset);
         LPBYTE pbVfsFileEntry = pbVfsFileTable + dwVfsOffset;
         LPBYTE pbVfsFileEnd = pbVfsFileTable + DirHeader.VfsTableSize;
 
@@ -239,7 +251,7 @@ struct TRootHandler_TVFS : public TFileTreeRoot
         LPBYTE pbCftFileTable;
         LPBYTE pbCftFileEntry;
         LPBYTE pbCftFileEnd;
-        LPBYTE pbVfsFileTable = DirHeader.pbDirectoryData + DirHeader.VfsTableOffset;
+        LPBYTE pbVfsFileTable = DirHeader.DataAt(DirHeader.VfsTableOffset);
         LPBYTE pbVfsFileEnd = pbVfsFileTable + DirHeader.VfsTableSize;
         size_t ItemSize = sizeof(DWORD) + sizeof(DWORD) + DirHeader.CftOffsSize;
 
@@ -260,7 +272,7 @@ struct TRootHandler_TVFS : public TFileTreeRoot
             //
 
             // Resolve the Container File Table entry
-            pbCftFileTable = DirHeader.pbDirectoryData + DirHeader.CftTableOffset;
+            pbCftFileTable = DirHeader.DataAt(DirHeader.CftTableOffset);
             pbCftFileEntry = pbCftFileTable + dwCftOffset;
             pbCftFileEnd = pbCftFileTable + DirHeader.CftTableSize;
 
@@ -380,10 +392,12 @@ struct TRootHandler_TVFS : public TFileTreeRoot
     DWORD IsVfsSubDirectory(TCascStorage * hs,  TVFS_DIRECTORY_HEADER & DirHeader, TVFS_DIRECTORY_HEADER & SubHeader, LPBYTE EKey, DWORD dwFileSize)
     {
         PCASC_CKEY_ENTRY pCKeyEntry;
-        LPBYTE pbVfsData = NULL;
-        DWORD cbVfsData = dwFileSize;
+        CASC_BLOB VfsData;
         DWORD dwErrCode = ERROR_BAD_FORMAT;
 
+        // Keep compiler happy
+        CASCLIB_UNUSED(dwFileSize);
+
         // Verify whether the EKey is in the list of VFS root files
         if(IsVfsFileEKey(hs, EKey, DirHeader.EKeySize))
         {
@@ -391,17 +405,16 @@ struct TRootHandler_TVFS : public TFileTreeRoot
             if((pCKeyEntry = FindCKeyEntry_EKey(hs, EKey)) != NULL)
             {
                 // Load the entire file into memory
-                pbVfsData = LoadInternalFileToMemory(hs, pCKeyEntry, &cbVfsData);
-                if(pbVfsData && cbVfsData)
+                dwErrCode = LoadInternalFileToMemory(hs, pCKeyEntry, VfsData);
+                if(dwErrCode == ERROR_SUCCESS && VfsData.cbData)
                 {
                     // Capture the file folder. This also serves as test
-                    dwErrCode = CaptureDirectoryHeader(SubHeader, pbVfsData, pbVfsData + cbVfsData);
+                    dwErrCode = CaptureDirectoryHeader(SubHeader, VfsData);
                     if(dwErrCode == ERROR_SUCCESS)
                         return dwErrCode;
 
                     // Clear the captured header
                     memset(&SubHeader, 0, sizeof(TVFS_DIRECTORY_HEADER));
-                    CASC_FREE(pbVfsData);
                 }
             }
         }
@@ -533,11 +546,8 @@ struct TRootHandler_TVFS : public TFileTreeRoot
                             assert(pCKeyEntry->ContentSize == SpanEntry.ContentSize);
                             FileTree.InsertByName(pCKeyEntry, PathBuffer);
 
-                            // Parse the subdir
+                            // Parse the subdir. On error, stop the parsing
                             dwErrCode = ParseDirectoryData(hs, SubHeader, PathBuffer);
-                            CASC_FREE(SubHeader.pbDirectoryData);
-
-                            // On error, stop the parsing
                             if(dwErrCode != ERROR_SUCCESS)
                                 return dwErrCode;
                         }
@@ -652,7 +662,7 @@ struct TRootHandler_TVFS : public TFileTreeRoot
 
     DWORD ParseDirectoryData(TCascStorage * hs, TVFS_DIRECTORY_HEADER & DirHeader, CASC_PATH<char> & PathBuffer)
     {
-        LPBYTE pbRootDirectory = DirHeader.pbDirectoryData + DirHeader.PathTableOffset;
+        LPBYTE pbRootDirectory = DirHeader.DataAt(DirHeader.PathTableOffset);
         LPBYTE pbRootDirPtr = pbRootDirectory;
         LPBYTE pbRootDirEnd = pbRootDirPtr + DirHeader.PathTableSize;
         DWORD dwNodeValue = 0;
@@ -766,14 +776,14 @@ struct TRootHandler_TVFS : public TFileTreeRoot
 //-----------------------------------------------------------------------------
 // Public functions - TVFS root
 
-DWORD RootHandler_CreateTVFS(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+DWORD RootHandler_CreateTVFS(TCascStorage * hs, CASC_BLOB & RootFile)
 {
     TRootHandler_TVFS * pRootHandler = NULL;
     TVFS_DIRECTORY_HEADER RootHeader;
     DWORD dwErrCode;
 
     // Capture the entire root directory
-    dwErrCode = TRootHandler_TVFS::CaptureDirectoryHeader(RootHeader, pbRootFile, pbRootFile + cbRootFile);
+    dwErrCode = TRootHandler_TVFS::CaptureDirectoryHeader(RootHeader, RootFile);
     if(dwErrCode == ERROR_SUCCESS)
     {
         // Allocate the root handler object
diff --git a/dep/CascLib/src/CascRootFile_Text.cpp b/dep/CascLib/src/CascRootFile_Text.cpp
index 655080bd2ee..ba4de629b5a 100644
--- a/dep/CascLib/src/CascRootFile_Text.cpp
+++ b/dep/CascLib/src/CascRootFile_Text.cpp
@@ -25,7 +25,7 @@ struct TRootHandler_SC1 : public TFileTreeRoot
         dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY);
     }
 
-    static bool IsRootFile(LPBYTE pbRootFile, DWORD cbRootFile)
+    static bool IsRootFile(LPBYTE pbRootFile, size_t cbRootFile)
     {
         CASC_CSV Csv(1, false);
         size_t nColumns;
@@ -36,7 +36,7 @@ struct TRootHandler_SC1 : public TFileTreeRoot
         {
             // There must be 2 or 3 elements
             nColumns = Csv[CSV_ZERO].GetColumnCount();
-            if (nColumns == 2 || nColumns == 3)
+            if(nColumns == 2 || nColumns == 3)
             {
                 const CASC_CSV_COLUMN & FileName = Csv[CSV_ZERO][CSV_ZERO];
                 const CASC_CSV_COLUMN & CKeyStr = Csv[CSV_ZERO][1];
@@ -49,7 +49,7 @@ struct TRootHandler_SC1 : public TFileTreeRoot
         return bResult;
     }
 
-    DWORD Load(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+    DWORD Load(TCascStorage * hs, LPBYTE pbRootFile, size_t cbRootFile)
     {
         PCASC_CKEY_ENTRY pCKeyEntry;
         CASC_CSV Csv(0, false);
@@ -93,20 +93,20 @@ struct TRootHandler_SC1 : public TFileTreeRoot
 // locales/zhCN/Assets/sound/terran/ghost/tghdth01.wav|6637ed776bd22089e083b8b0b2c0374c
 //
 
-DWORD RootHandler_CreateStarcraft1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
+DWORD RootHandler_CreateStarcraft1(TCascStorage * hs, CASC_BLOB & RootFile)
 {
     TRootHandler_SC1 * pRootHandler = NULL;
     DWORD dwErrCode = ERROR_BAD_FORMAT;
 
     // Verify whether this looks like a Starcraft I root file
-    if(TRootHandler_SC1::IsRootFile(pbRootFile, cbRootFile))
+    if(TRootHandler_SC1::IsRootFile(RootFile.pbData, RootFile.cbData))
     {
         // Allocate the root handler object
         pRootHandler = new TRootHandler_SC1();
         if(pRootHandler != NULL)
         {
             // Load the root directory. If load failed, we free the object
-            dwErrCode = pRootHandler->Load(hs, pbRootFile, cbRootFile);
+            dwErrCode = pRootHandler->Load(hs, RootFile.pbData, RootFile.cbData);
             if(dwErrCode != ERROR_SUCCESS)
             {
                 delete pRootHandler;
diff --git a/dep/CascLib/src/CascRootFile_WoW.cpp b/dep/CascLib/src/CascRootFile_WoW.cpp
index e5d0d0426ed..5b5375bcc7b 100644
--- a/dep/CascLib/src/CascRootFile_WoW.cpp
+++ b/dep/CascLib/src/CascRootFile_WoW.cpp
@@ -367,7 +367,7 @@ struct TRootHandler_WoW : public TFileTreeRoot
 
         // Load the locale as-is
         dwErrCode = ParseWowRootFile_Level2(hs, pbRootPtr, pbRootEnd, dwLocaleMask, false, bAudioLocale);
-        if (dwErrCode != ERROR_SUCCESS)
+        if(dwErrCode != ERROR_SUCCESS)
             return dwErrCode;
 
         // If we wanted enGB, we also load enUS for the missing files
@@ -386,9 +386,13 @@ struct TRootHandler_WoW : public TFileTreeRoot
         DWORD dwErrCode;
 
         dwErrCode = ParseWowRootFile_Level1(hs, pbRootPtr, pbRootEnd, dwLocaleMask, 0);
-        if (dwErrCode == ERROR_SUCCESS)
+        if(dwErrCode == ERROR_SUCCESS)
             dwErrCode = ParseWowRootFile_Level1(hs, pbRootPtr, pbRootEnd, dwLocaleMask, 1);
 
+#ifdef _DEBUG
+        // Dump the array of the file data IDs
+        //FileTree.DumpFileDataIds("e:\\file-data-ids.bin");
+#endif
         return dwErrCode;
     }
 
@@ -466,12 +470,13 @@ struct TRootHandler_WoW : public TFileTreeRoot
 //-----------------------------------------------------------------------------
 // Public functions
 
-DWORD RootHandler_CreateWoW(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask)
+DWORD RootHandler_CreateWoW(TCascStorage * hs, CASC_BLOB & RootFile, DWORD dwLocaleMask)
 {
     TRootHandler_WoW * pRootHandler = NULL;
     FILE_ROOT_HEADER_82 RootHeader;
     ROOT_FORMAT RootFormat = RootFormatWoW6x;
-    LPBYTE pbRootEnd = pbRootFile + cbRootFile;
+    LPBYTE pbRootFile = RootFile.pbData;
+    LPBYTE pbRootEnd = RootFile.End();
     LPBYTE pbRootPtr;
     DWORD FileCounterHashless = 0;
     DWORD dwErrCode = ERROR_BAD_FORMAT;
diff --git a/dep/CascLib/src/common/Array.h b/dep/CascLib/src/common/Array.h
index 832a230a8ed..b46f257e8a4 100644
--- a/dep/CascLib/src/common/Array.h
+++ b/dep/CascLib/src/common/Array.h
@@ -42,8 +42,11 @@ class CASC_ARRAY
     // Creates an array with a custom element size
     int Create(size_t ItemSize, size_t ItemCountMax)
     {
+        // Sanity check
+        assert(ItemCountMax != 0);
+
         // Create the array
-        if ((m_pItemArray = CASC_ALLOC<BYTE>(ItemSize * ItemCountMax)) == NULL)
+        if((m_pItemArray = CASC_ALLOC<BYTE>(ItemSize * ItemCountMax)) == NULL)
             return ERROR_NOT_ENOUGH_MEMORY;
 
         m_ItemCountMax = ItemCountMax;
@@ -58,7 +61,7 @@ class CASC_ARRAY
         void * pNewItems;
 
         // Try to enlarge the buffer, if needed
-        if (!EnlargeArray(m_ItemCount + NewItemCount, bEnlargeAllowed))
+        if(!EnlargeArray(m_ItemCount + NewItemCount, bEnlargeAllowed))
             return NULL;
         pNewItems = m_pItemArray + (m_ItemCount * m_ItemSize);
 
@@ -75,7 +78,7 @@ class CASC_ARRAY
         void * pNewItem = Insert(NewItemCount, bEnlargeAllowed);
 
         // Copy the item(s) to the array, if any
-        if (pNewItem && NewItems)
+        if(pNewItem && NewItems)
             memcpy(pNewItem, NewItems, (NewItemCount * m_ItemSize));
         return pNewItem;
     }
@@ -108,7 +111,7 @@ class CASC_ARRAY
         m_ItemCount = CASCLIB_MAX(m_ItemCount, ItemIndex+1);
 
         // If we inserted an item past the current end, we need to clear the items in-between
-        if (pbNewItem > pbLastItem)
+        if(pbNewItem > pbLastItem)
         {
             memset(pbLastItem, 0, (pbNewItem - pbLastItem));
             m_ItemCount = ItemIndex + 1;
@@ -167,6 +170,24 @@ class CASC_ARRAY
         m_ItemCountMax = m_ItemCount = m_ItemSize = 0;
     }
 
+#ifdef _DEBUG
+    size_t BytesAllocated()
+    {
+        return m_ItemCountMax * m_ItemSize;
+    }
+
+    void Dump(const char * szFileName)
+    {
+        FILE * fp;
+
+        if((fp = fopen(szFileName, "wb")) != NULL)
+        {
+            fwrite(m_pItemArray, m_ItemSize, m_ItemCount, fp);
+            fclose(fp);
+        }
+    }
+#endif
+
     protected:
 
     bool EnlargeArray(size_t NewItemCount, bool bEnlargeAllowed)
@@ -179,7 +200,7 @@ class CASC_ARRAY
         assert(m_ItemCountMax != 0);
 
         // Shall we enlarge the table?
-        if (NewItemCount > m_ItemCountMax)
+        if(NewItemCount > m_ItemCountMax)
         {
             // Deny enlarge if not allowed
             if(bEnlargeAllowed == false)
@@ -192,7 +213,7 @@ class CASC_ARRAY
 
             // Allocate new table
             NewItemArray = CASC_REALLOC(m_pItemArray, (ItemCountMax * m_ItemSize));
-            if (NewItemArray == NULL)
+            if(NewItemArray == NULL)
                 return false;
 
             // Set the new table size
diff --git a/dep/CascLib/src/common/ArraySparse.h b/dep/CascLib/src/common/ArraySparse.h
new file mode 100644
index 00000000000..eb7d478cf3e
--- /dev/null
+++ b/dep/CascLib/src/common/ArraySparse.h
@@ -0,0 +1,286 @@
+/*****************************************************************************/
+/* ArraySparse.h                          Copyright (c) Ladislav Zezula 2022 */
+/*---------------------------------------------------------------------------*/
+/* This is somewhat more effective version of CASC_ARRAY, used for mapping   */
+/* of uint32_t -> pointer. Works better when there are large gaps in seqs    */
+/* of the source integers and when there is large gap at the beginning       */
+/* of the array.                                                             */
+/*                                                                           */
+/* This ofject works as multi-level table, where each byte from the mapping  */
+/* integer is an index to the appropriate sub-table                          */
+/*                                                                           */
+/* Example: Mapping of 11223344 -> POINTER                                   */
+/*                                                                           */
+/* The source uint_32_t is divided into 4 bytes. Each byte is an index to    */
+/* the corresponding level-N sub-table                                       */
+/*                                                                           */
+/*  [*] 0x11223344 -> {0x11, 0x22, 0x33, 0x44}                               */
+/*                                                                           */
+/* 0x11 is the index to the level-0 table. Contains pointer to level-1 table */
+/* 0x22 is the index to the level-1 table. Contains pointer to level-2 table */
+/* 0x33 is the index to the level-2 table. Contains pointer to level-3 table */
+/* 0x44 is the index to the level-3 table. Contains the result POINTER       */
+/*---------------------------------------------------------------------------*/
+/*   Date    Ver   Who  Comment                                              */
+/* --------  ----  ---  -------                                              */
+/* 14.12.22  1.00  Lad  Created                                              */
+/*****************************************************************************/
+
+#ifndef __CASC_SPARSE_ARRAY_H__
+#define __CASC_SPARSE_ARRAY_H__
+
+//-----------------------------------------------------------------------------
+// Structure of the 256-item sub-table. Each table item contains either
+// pointer to the lower sub-table (if present) or the pointer to the target item
+
+struct CASC_ARRAY_256
+{
+    CASC_ARRAY_256()
+    {
+        memset(Pointers, 0, sizeof(Pointers));
+    }
+
+    CASC_ARRAY_256 * GetLowerLevel(size_t nIndex)
+    {
+        return (CASC_ARRAY_256 *)(Pointers[nIndex & 0xFF]);
+    }
+
+    CASC_ARRAY_256 ** SubTable(size_t ItemIndex, size_t nLevel)
+    {
+        // Calculate the bit shift for getting the level index
+        size_t nShift = 0x20 - (nLevel * 8);
+        size_t nIndex = (ItemIndex >> nShift) & 0xFF;
+
+        // Return reference to the item
+        return (CASC_ARRAY_256 **)(&Pointers[nIndex]);
+    }
+
+    void Reset(size_t nLevel)
+    {
+        CASC_ARRAY_256 * pLower;
+
+        // For levels 0, 1, 2, free the sub-items, if any
+        if(nLevel < 3)
+        {
+            for(size_t i = 0; i < _countof(Pointers); i++)
+            {
+                if((pLower = GetLowerLevel(i)) != NULL)
+                {
+                    pLower->Reset(nLevel + 1);
+                }
+            }
+        }
+
+        // Set all pointers to NULL for level 3
+        else
+        {
+            memset(Pointers, 0, sizeof(CASC_ARRAY_256));
+        }
+    }
+
+    void Free(size_t nLevel)
+    {
+        CASC_ARRAY_256 * pLower;
+
+        // For levels 0, 1, 2, free the sub-items, if any
+        if(nLevel < 3)
+        {
+            for(size_t i = 0; i < _countof(Pointers); i++)
+            {
+                if((pLower = GetLowerLevel(i)) != NULL)
+                {
+                    pLower->Free(nLevel + 1);
+                    delete pLower;
+                }
+            }
+        }
+
+        // Set all pointers to NULL
+        memset(Pointers, 0, sizeof(CASC_ARRAY_256));
+    }
+
+    void * Pointers[0x100];
+};
+
+//-----------------------------------------------------------------------------
+// Interface to the sparse array class
+
+class CASC_SPARSE_ARRAY
+{
+    public:
+
+    CASC_SPARSE_ARRAY()
+    {
+        m_LevelsAllocated = 0;
+        m_ItemCount = 0;
+        m_pLevel0 = NULL;
+    }
+
+    ~CASC_SPARSE_ARRAY()
+    {
+        Free();
+    }
+
+    // Creates an array with a custom element type
+    template<typename TYPE>
+    DWORD Create(size_t /* ItemCountMax */)
+    {
+        if((m_pLevel0 = new CASC_ARRAY_256()) != NULL)
+        {
+            m_LevelsAllocated++;
+            return ERROR_SUCCESS;
+        }
+        return ERROR_NOT_ENOUGH_MEMORY;
+    }
+
+    // Returns pointer to the cell given index
+    void ** ItemAt(size_t ItemIndex)
+    {
+        CASC_ARRAY_256 * pLevelN;
+
+        // The index must be 32-bit only
+        assert((DWORD)(ItemIndex) == ItemIndex);
+
+        // Get the level-0 index
+        if((pLevelN = m_pLevel0) != NULL)
+        {
+            if((pLevelN = GetLowerLevelTable(pLevelN, ItemIndex, 1)) != NULL)
+            {
+                if((pLevelN = GetLowerLevelTable(pLevelN, ItemIndex, 2)) != NULL)
+                {
+                    if((pLevelN = GetLowerLevelTable(pLevelN, ItemIndex, 3)) != NULL)
+                    {
+                        return &pLevelN->Pointers[ItemIndex & 0xFF];
+                    }
+                }
+            }
+        }
+
+        // Not present
+        return NULL;
+    }
+
+    // Inserts an item at a given index and returns pointer to its cell
+    void ** InsertAt(size_t ItemIndex)
+    {
+        CASC_ARRAY_256 * pLevelN;
+
+        // The index must be 32-bit only
+        assert((DWORD)(ItemIndex) == ItemIndex);
+
+        // Get the level-0 index
+        if((pLevelN = m_pLevel0) != NULL)
+        {
+            if((pLevelN = EnsureLowerLevelTable(pLevelN, ItemIndex, 1)) != NULL)
+            {
+                if((pLevelN = EnsureLowerLevelTable(pLevelN, ItemIndex, 2)) != NULL)
+                {
+                    if((pLevelN = EnsureLowerLevelTable(pLevelN, ItemIndex, 3)) != NULL)
+                    {
+                        // Increment the max index and return the pointer to the appropriate cell
+                        if(ItemIndex >= m_ItemCount)
+                            m_ItemCount = ItemIndex + 1;
+                        return &pLevelN->Pointers[ItemIndex & 0xFF];
+                    }
+                }
+            }
+        }
+
+        // Not enough memory
+        return NULL;
+    }
+
+    // Invalidates the entire array, but keeps memory allocated
+    void Reset()
+    {
+        if(m_pLevel0 != NULL)
+        {
+            m_pLevel0->Reset(0);
+        }
+    }
+
+    // Frees the array
+    void Free()
+    {
+        if(m_pLevel0 != NULL)
+        {
+            m_pLevel0->Free(0);
+            delete m_pLevel0;
+        }
+    }
+
+    size_t ItemCount()
+    {
+        return m_ItemCount;
+    }
+
+    size_t ItemCountMax()
+    {
+        return 0xFFFFFFFF;
+    }
+
+    size_t ItemSize()
+    {
+        return sizeof(void *);
+    }
+
+    bool IsInitialized()
+    {
+        return (m_pLevel0 != NULL);
+    }
+
+#ifdef _DEBUG
+    size_t BytesAllocated()
+    {
+        return m_LevelsAllocated * sizeof(CASC_ARRAY_256);
+    }
+
+    void Dump(const char * szFileName)
+    {
+        FILE * fp;
+        size_t * RefItem;
+        size_t Item;
+
+        if((fp = fopen(szFileName, "wb")) != NULL)
+        {
+            for(size_t i = 0; i < m_ItemCount; i++)
+            {
+                RefItem = (size_t *)ItemAt(i);
+                Item = (RefItem != NULL) ? RefItem[0] : 0;
+                fwrite(&Item, ItemSize(), 1, fp);
+            }
+            fclose(fp);
+        }
+    }
+#endif
+
+    protected:
+
+    CASC_ARRAY_256 * GetLowerLevelTable(CASC_ARRAY_256 * pTable, size_t ItemIndex, size_t nLevel)
+    {
+        CASC_ARRAY_256 ** SubTable = pTable->SubTable(ItemIndex, nLevel);
+
+        // Get the n-th item from the table
+        return SubTable[0];
+    }
+
+    CASC_ARRAY_256 * EnsureLowerLevelTable(CASC_ARRAY_256 * pTable, size_t ItemIndex, size_t nLevel)
+    {
+        CASC_ARRAY_256 ** SubTable = pTable->SubTable(ItemIndex, nLevel);
+
+        // Is there an item?
+        if(SubTable[0] == NULL)
+        {
+            SubTable[0] = new CASC_ARRAY_256();
+            m_LevelsAllocated++;
+        }
+        return SubTable[0];
+    }
+
+    // Level-0 subitem table
+    CASC_ARRAY_256 * m_pLevel0;                 // Array of level 0 of pointers
+    size_t m_LevelsAllocated;                   // Number of CASC_ARRAY_256's allocated (for debugging purposes)
+    size_t m_ItemCount;                         // The number of items inserted
+};
+
+#endif // __CASC_SPARSE_ARRAY_H__
diff --git a/dep/CascLib/src/common/Common.cpp b/dep/CascLib/src/common/Common.cpp
index ac06e8df53e..63fb4301d57 100644
--- a/dep/CascLib/src/common/Common.cpp
+++ b/dep/CascLib/src/common/Common.cpp
@@ -69,7 +69,7 @@ unsigned char AsciiToHexTable[128] =
     0xFF, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
 };
 
 unsigned char IntToHexChar[] = "0123456789abcdef";
@@ -229,10 +229,10 @@ void CascStrCopy(char * szTarget, size_t cchTarget, const char * szSource, size_
 {
     size_t cchToCopy;
 
-    if (cchTarget > 0)
+    if(cchTarget > 0)
     {
         // Make sure we know the length
-        if (cchSource == -1)
+        if(cchSource == -1)
             cchSource = strlen(szSource);
         cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource);
 
@@ -246,10 +246,10 @@ void CascStrCopy(char * szTarget, size_t cchTarget, const wchar_t * szSource, si
 {
     size_t cchToCopy;
 
-    if (cchTarget > 0)
+    if(cchTarget > 0)
     {
         // Make sure we know the length
-        if (cchSource == -1)
+        if(cchSource == -1)
             cchSource = wcslen(szSource);
         cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource);
 
@@ -262,10 +262,10 @@ void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const char * szSource, si
 {
     size_t cchToCopy;
 
-    if (cchTarget > 0)
+    if(cchTarget > 0)
     {
         // Make sure we know the length
-        if (cchSource == -1)
+        if(cchSource == -1)
             cchSource = strlen(szSource);
         cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource);
 
@@ -278,10 +278,10 @@ void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const wchar_t * szSource,
 {
     size_t cchToCopy;
 
-    if (cchTarget > 0)
+    if(cchTarget > 0)
     {
         // Make sure we know the length
-        if (cchSource == -1)
+        if(cchSource == -1)
             cchSource = wcslen(szSource);
         cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource);
 
@@ -293,46 +293,58 @@ void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const wchar_t * szSource,
 //-----------------------------------------------------------------------------
 // Safe version of s(w)printf
 
-size_t CascStrPrintf(char * buffer, size_t nCount, const char * format, ...)
+size_t CascStrPrintfV(char * buffer, size_t nCount, const char * format, va_list argList)
 {
     char * buffend;
-    va_list argList;
 
-    // Start the argument list
-    va_start(argList, format);
-    
 #ifdef CASCLIB_PLATFORM_WINDOWS
     StringCchVPrintfExA(buffer, nCount, &buffend, NULL, 0, format, argList);
-//  buffend = buffer + vsnprintf(buffer, nCount, format, argList);
 #else
     buffend = buffer + vsnprintf(buffer, nCount, format, argList);
 #endif
-    
-    // End the argument list
-    va_end(argList);
+
     return (buffend - buffer);
 }
 
-size_t CascStrPrintf(wchar_t * buffer, size_t nCount, const wchar_t * format, ...)
+size_t CascStrPrintf(char * buffer, size_t nCount, const char * format, ...)
 {
-    wchar_t * buffend;
     va_list argList;
+    size_t length;
 
     // Start the argument list
     va_start(argList, format);
+    length = CascStrPrintfV(buffer, nCount, format, argList);
+    va_end(argList);
+
+    return length;
+}
+
+size_t CascStrPrintfV(wchar_t * buffer, size_t nCount, const wchar_t * format, va_list argList)
+{
+    wchar_t * buffend;
 
 #ifdef CASCLIB_PLATFORM_WINDOWS
     StringCchVPrintfExW(buffer, nCount, &buffend, NULL, 0, format, argList);
-//  buffend = buffer + vswprintf(buffer, nCount, format, argList);
 #else
     buffend = buffer + vswprintf(buffer, nCount, format, argList);
 #endif
 
-    // End the argument list
-    va_end(argList);
     return (buffend - buffer);
 }
 
+size_t CascStrPrintf(wchar_t * buffer, size_t nCount, const wchar_t * format, ...)
+{
+    va_list argList;
+    size_t length;
+
+    // Start the argument list
+    va_start(argList, format);
+    length = CascStrPrintfV(buffer, nCount, format, argList);
+    va_end(argList);
+
+    return length;
+}
+
 //-----------------------------------------------------------------------------
 // String allocation
 
@@ -413,74 +425,7 @@ LPTSTR CascNewStrA2T(LPCSTR szString, size_t nCharsToReserve)
 }
 
 //-----------------------------------------------------------------------------
-// String merging
-
-LPTSTR GetLastPathPart(LPTSTR szWorkPath)
-{
-    size_t nLength = _tcslen(szWorkPath);
-
-    // Go one character back
-    if(nLength > 0)
-        nLength--;
-
-    // Cut ending (back)slashes, if any
-    while(nLength > 0 && (szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/')))
-        nLength--;
-
-    // Cut the last path part
-    while(nLength > 0)
-    {
-        // End of path?
-        if(szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/'))
-        {
-            return szWorkPath + nLength;
-        }
-
-        // Go one character back
-        nLength--;
-    }
-
-    return NULL;
-}
-
-bool CutLastPathPart(LPTSTR szWorkPath)
-{
-    // Get the last part of the path
-    szWorkPath = GetLastPathPart(szWorkPath);
-    if(szWorkPath == NULL)
-        return false;
-
-    szWorkPath[0] = 0;
-    return true;
-}
-
-size_t CombinePath(LPTSTR szBuffer, size_t nMaxChars, va_list argList)
-{
-    CASC_PATH<TCHAR> Path(PATH_SEP_CHAR);
-    LPCTSTR szFragment;
-    bool bWithSeparator = false;
-
-    // Combine all parts of the path here
-    while((szFragment = va_arg(argList, LPTSTR)) != NULL)
-    {
-        Path.AppendString(szFragment, bWithSeparator);
-        bWithSeparator = true;
-    }
-
-    return Path.Copy(szBuffer, nMaxChars);
-}
-
-size_t CombinePath(LPTSTR szBuffer, size_t nMaxChars, ...)
-{
-    va_list argList;
-    size_t nLength;
-
-    va_start(argList, nMaxChars);
-    nLength = CombinePath(szBuffer, nMaxChars, argList);
-    va_end(argList);
-
-    return nLength;
-}
+// String normalization
 
 size_t NormalizeFileName(const unsigned char * NormTable, char * szNormName, const char * szFileName, size_t cchMaxChars)
 {
diff --git a/dep/CascLib/src/common/Common.h b/dep/CascLib/src/common/Common.h
index 3fbbf0d842c..5abc5c77b9a 100644
--- a/dep/CascLib/src/common/Common.h
+++ b/dep/CascLib/src/common/Common.h
@@ -124,7 +124,7 @@ typedef CASC_CKEY_ENTRY *PCASC_CKEY_ENTRY;
 
 extern unsigned char AsciiToLowerTable_Slash[256];
 extern unsigned char AsciiToUpperTable_BkSlash[256];
-extern unsigned char AsciiToHexTable[0x80];
+extern unsigned char AsciiToHexTable[128];
 extern unsigned char IntToHexChar[];
 
 //-----------------------------------------------------------------------------
@@ -186,7 +186,7 @@ inline DWORD Rol32(DWORD dwValue, DWORD dwRolCount)
 //-----------------------------------------------------------------------------
 // Big endian number manipulation
 
-inline DWORD ConvertBytesToInteger_2(LPBYTE ValueAsBytes)
+inline USHORT ConvertBytesToInteger_2(LPBYTE ValueAsBytes)
 {
     USHORT Value = 0;
 
@@ -325,7 +325,9 @@ void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const wchar_t * szSource,
 //-----------------------------------------------------------------------------
 // Safe version of s(w)printf
 
+size_t CascStrPrintfV(char * buffer, size_t nCount, const char * format, va_list argList);
 size_t CascStrPrintf(char * buffer, size_t nCount, const char * format, ...);
+size_t CascStrPrintfV(wchar_t * buffer, size_t nCount, const wchar_t * format, va_list argList);
 size_t CascStrPrintf(wchar_t * buffer, size_t nCount, const wchar_t * format, ...);
 
 //-----------------------------------------------------------------------------
@@ -337,11 +339,6 @@ wchar_t * CascNewStr(const wchar_t * szString, size_t nCharsToReserve = 0);
 LPSTR  CascNewStrT2A(LPCTSTR szString, size_t nCharsToReserve = 0);
 LPTSTR CascNewStrA2T(LPCSTR szString, size_t nCharsToReserve = 0);
 
-size_t CombinePath(LPTSTR szBuffer, size_t nMaxChars, va_list argList);
-size_t CombinePath(LPTSTR szBuffer, size_t nMaxChars, ...);
-LPTSTR GetLastPathPart(LPTSTR szWorkPath);
-bool CutLastPathPart(LPTSTR szWorkPath);
-
 size_t NormalizeFileName_UpperBkSlash(char * szNormName, const char * szFileName, size_t cchMaxChars);
 size_t NormalizeFileName_LowerSlash(char * szNormName, const char * szFileName, size_t cchMaxChars);
 
@@ -351,6 +348,12 @@ ULONGLONG CalcFileNameHash(const char * szFileName);
 //-----------------------------------------------------------------------------
 // String conversion functions
 
+template <typename xchar>
+bool IsHexadecimalDigit(xchar ch)
+{
+    return ((ch < sizeof(AsciiToHexTable)) && (AsciiToHexTable[ch] != 0xFF));
+}
+
 template <typename xchar, typename INTXX>
 DWORD ConvertStringToInt(const xchar * szString, size_t nMaxDigits, INTXX & RefValue, const xchar ** PtrStringEnd = NULL)
 {
@@ -448,34 +451,75 @@ xchar * StringFromBinary(LPBYTE pbBinary, size_t cbBinary, xchar * szBuffer)
 //-----------------------------------------------------------------------------
 // Structures for data blobs
 
-struct QUERY_KEY
+struct CASC_BLOB
 {
-    QUERY_KEY()
+    CASC_BLOB()
     {
-        pbData = NULL;
-        cbData = 0;
+        Reset();
     }
 
-    ~QUERY_KEY()
+    ~CASC_BLOB()
     {
-        CASC_FREE(pbData);
-        cbData = 0;
+        Free();
+    }
+
+    void MoveFrom(CASC_BLOB & Source)
+    {
+        // Free current data, if any
+        Free();
+
+        // Take the source data
+        pbData = Source.pbData;
+        cbData = Source.cbData;
+
+        // Reset the source data without freeing
+        Source.Reset();
     }
 
     DWORD SetData(const void * pv, size_t cb)
     {
-        if((pbData = CASC_ALLOC<BYTE>(cb)) == NULL)
+        if(SetSize(cb) != ERROR_SUCCESS)
             return ERROR_NOT_ENOUGH_MEMORY;
 
         memcpy(pbData, pv, cb);
+        return ERROR_SUCCESS;
+    }
+
+    DWORD SetSize(size_t cb)
+    {
+        Free();
+
+        // Always leave one extra byte for NUL character
+        if((pbData = CASC_ALLOC<BYTE>(cb + 1)) == NULL)
+            return ERROR_NOT_ENOUGH_MEMORY;
+
         cbData = cb;
         return ERROR_SUCCESS;
     }
 
+    void Reset()
+    {
+        pbData = NULL;
+        cbData = 0;
+    }
+
+    void Free()
+    {
+        if(pbData != NULL)
+            CASC_FREE(pbData);
+        pbData = NULL;
+        cbData = 0;
+    }
+
+    LPBYTE End() const
+    {
+        return pbData + cbData;
+    }
+
     LPBYTE pbData;
     size_t cbData;
 };
-typedef QUERY_KEY *PQUERY_KEY;
+typedef CASC_BLOB *PCASC_BLOB;
 
 //-----------------------------------------------------------------------------
 // File name utilities
@@ -526,22 +570,11 @@ bool CascCheckWildCard(const char * szString, const char * szWildCard);
 //-----------------------------------------------------------------------------
 // Hashing functions
 
-ULONGLONG HashStringJenkins(const char * szFileName);
-
 bool CascIsValidMD5(LPBYTE pbMd5);
 void CascCalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash);
 bool CascVerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5);
 
 //-----------------------------------------------------------------------------
-// Scanning a directory
-
-typedef bool (*INDEX_FILE_FOUND)(LPCTSTR szFileName, void * pvContext);
-
-bool DirectoryExists(LPCTSTR szDirectory);
-
-int ScanIndexDirectory(LPCTSTR szIndexPath, INDEX_FILE_FOUND pfnOnFileFound, void * pvContext);
-
-//-----------------------------------------------------------------------------
 // Argument structure versioning
 // Safely retrieves field value from a structure
 // intended for cases where users upgrade CascLib by simply dropping in a new .dll without recompiling their app
diff --git a/dep/CascLib/src/common/Csv.cpp b/dep/CascLib/src/common/Csv.cpp
index 589c711571a..ba333399479 100644
--- a/dep/CascLib/src/common/Csv.cpp
+++ b/dep/CascLib/src/common/Csv.cpp
@@ -42,7 +42,7 @@ static char * NextColumn_Default(void * /* pvUserData */, char * szColumn)
         szColumn++;
 
     // Terminate the column
-    if (szColumn[0] == '|')
+    if(szColumn[0] == '|')
     {
         *szColumn++ = 0;
         return szColumn;
@@ -158,7 +158,6 @@ CASC_CSV::CASC_CSV(size_t nLinesMax, bool bHasHeader)
     m_pvUserData = NULL;
     m_szCsvFile = NULL;
     m_szCsvPtr = NULL;
-    m_nCsvFile = 0;
     m_nLines = 0;
     m_bHasHeader = bHasHeader;
 
@@ -185,8 +184,9 @@ CASC_CSV::CASC_CSV(size_t nLinesMax, bool bHasHeader)
 CASC_CSV::~CASC_CSV()
 {
     if(m_pLines != NULL)
+    {
         delete[] m_pLines;
-    CASC_FREE(m_szCsvFile);
+    }
 }
 
 DWORD CASC_CSV::SetNextLineProc(CASC_CSV_NEXTPROC PfnNextLineProc, CASC_CSV_NEXTPROC PfnNextColProc, void * pvUserData)
@@ -206,24 +206,18 @@ DWORD CASC_CSV::SetNextLineProc(CASC_CSV_NEXTPROC PfnNextLineProc, CASC_CSV_NEXT
 
 DWORD CASC_CSV::Load(LPCTSTR szFileName)
 {
-    DWORD cbFileData = 0;
-    DWORD dwErrCode = ERROR_SUCCESS;
+    DWORD dwErrCode;
 
-    m_szCsvFile = (char *)LoadFileToMemory(szFileName, &cbFileData);
-    if (m_szCsvFile != NULL)
+    dwErrCode = LoadFileToMemory(szFileName, CsvFile);
+    if(dwErrCode == ERROR_SUCCESS)
     {
         // Assign the data to the CSV object
+        m_szCsvFile = (char *)CsvFile.pbData;
         m_szCsvPtr = m_szCsvFile;
-        m_nCsvFile = cbFileData;
 
         // Parse the data
         dwErrCode = ParseCsvData() ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
     }
-    else
-    {
-        dwErrCode = GetCascError();
-    }
-
     return dwErrCode;
 }
 
@@ -231,19 +225,16 @@ DWORD CASC_CSV::Load(LPBYTE pbData, size_t cbData)
 {
     DWORD dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
 
-    m_szCsvFile = CASC_ALLOC<char>(cbData + 1);
-    if (m_szCsvFile != NULL)
+    if((dwErrCode = CsvFile.SetData(pbData, cbData)) == ERROR_SUCCESS)
     {
         // Copy the entire data and terminate them with zero
-        memcpy(m_szCsvFile, pbData, cbData);
-        m_szCsvFile[cbData] = 0;
+        m_szCsvFile = (char *)CsvFile.pbData;
+        m_szCsvFile[CsvFile.cbData] = 0;
         m_szCsvPtr = m_szCsvFile;
-        m_nCsvFile = cbData;
 
         // Parse the data
         dwErrCode = ParseCsvData() ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
     }
-
     return dwErrCode;
 }
 
@@ -303,7 +294,7 @@ bool CASC_CSV::LoadNextLine(CASC_CSV_LINE & Line)
         m_szCsvPtr = PfnNextLine(m_pvUserData, m_szCsvPtr);
 
         // Initialize the line
-        if (Line.SetLine(this, szCsvLine))
+        if(Line.SetLine(this, szCsvLine))
             return true;
     }
 
@@ -320,7 +311,7 @@ bool CASC_CSV::ParseCsvData()
     if(m_bHasHeader)
     {
         // Load the current line to the header
-        if (!LoadNextLine(Header))
+        if(!LoadNextLine(Header))
             return false;
 
         // Initialize the hash table
@@ -345,14 +336,14 @@ bool CASC_CSV::ParseCsvData()
 
 const CASC_CSV_COLUMN & CASC_CSV::operator[](const char * szColumnName) const
 {
-    if (m_pLines == NULL || m_nLines == 0)
+    if(m_pLines == NULL || m_nLines == 0)
         return NullColumn;
     return m_pLines[0][GetColumnIndex(szColumnName)];
 }
 
 const CASC_CSV_LINE & CASC_CSV::operator[](size_t nIndex) const
 {
-    if (m_pLines == NULL || nIndex >= m_nLines)
+    if(m_pLines == NULL || nIndex >= m_nLines)
         return NullLine;
     return m_pLines[nIndex];
 }
diff --git a/dep/CascLib/src/common/Csv.h b/dep/CascLib/src/common/Csv.h
index 8df99c63456..1878344b24c 100644
--- a/dep/CascLib/src/common/Csv.h
+++ b/dep/CascLib/src/common/Csv.h
@@ -113,11 +113,11 @@ class CASC_CSV
 
     CASC_CSV_LINE * m_pLines;
     CASC_CSV_LINE Header;
+    CASC_BLOB CsvFile;
     BYTE HashTable[CSV_HASH_TABLE_SIZE];
     void * m_pvUserData;
     char * m_szCsvFile;
     char * m_szCsvPtr;
-    size_t m_nCsvFile;
     size_t m_nLinesMax;
     size_t m_nLines;
     bool m_bHasHeader;
diff --git a/dep/CascLib/src/common/Directory.cpp b/dep/CascLib/src/common/Directory.cpp
index efabda45171..cef7dfa6319 100644
--- a/dep/CascLib/src/common/Directory.cpp
+++ b/dep/CascLib/src/common/Directory.cpp
@@ -52,37 +52,47 @@ bool MakeDirectory(LPCTSTR szDirectory)
 #endif
 }
 
-int ScanIndexDirectory(
-    LPCTSTR szIndexPath,
-    INDEX_FILE_FOUND pfnOnFileFound,
+DWORD ScanDirectory(
+    LPCTSTR szDirectory,
+    DIRECTORY_CALLBACK PfnFolderCallback,
+    DIRECTORY_CALLBACK PfnFileCallback,
     void * pvContext)
 {
 #ifdef CASCLIB_PLATFORM_WINDOWS
 
+    CASC_PATH<TCHAR> SearchMask(szDirectory, _T("*"), NULL);
     WIN32_FIND_DATA wf;
     HANDLE hFind;
-    TCHAR szSearchMask[MAX_PATH];
-
-    // Prepare the search mask
-    CombinePath(szSearchMask, _countof(szSearchMask), szIndexPath, _T("*"), NULL);
 
     // Prepare directory search
-    hFind = FindFirstFile(szSearchMask, &wf);
+    hFind = FindFirstFile(SearchMask, &wf);
     if(hFind != INVALID_HANDLE_VALUE)
     {
         // Skip the first file as it's always just "." or ".."
         while(FindNextFile(hFind, &wf))
         {
-            // If the found object is a file, pass it to the handler
-            if(!(wf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+            // If we found a folder, we call the directory callback
+            if(wf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+            {
+                if(PfnFolderCallback != NULL)
+                {
+                    if(!PfnFolderCallback(wf.cFileName, pvContext))
+                        break;
+                }
+            }
+            else
             {
-                // Let the callback scan the file name
-                pfnOnFileFound(wf.cFileName, pvContext);
+                if(PfnFileCallback != NULL)
+                {
+                    if(!PfnFileCallback(wf.cFileName, pvContext))
+                        break;
+                }
             }
         }
 
         // Close the search handle
         FindClose(hFind);
+        return ERROR_SUCCESS;
     }
 
 #else // CASCLIB_PLATFORM_WINDOWS
@@ -90,21 +100,39 @@ int ScanIndexDirectory(
     struct dirent * dir_entry;
     DIR * dir;
 
-    dir = opendir(szIndexPath);
-    if(dir != NULL)
+    // Prepare directory search
+    if((dir = opendir(szDirectory)) != NULL)
     {
+        // Read (the next) directory entry
         while((dir_entry = readdir(dir)) != NULL)
         {
-            if(dir_entry->d_type != DT_DIR)
+            if(dir_entry->d_type == DT_DIR)
+            {
+                if(PfnFolderCallback != NULL)
+                {
+                    if(!PfnFolderCallback(dir_entry->d_name, pvContext))
+                    {
+                        break;
+                    }
+                }
+            }
+            else
             {
-                pfnOnFileFound(dir_entry->d_name, pvContext);
+                if(PfnFileCallback != NULL)
+                {
+                    if(!PfnFileCallback(dir_entry->d_name, pvContext))
+                    {
+                        break;
+                    }
+                }
             }
         }
 
         closedir(dir);
+        return ERROR_SUCCESS;
     }
 
 #endif
 
-    return ERROR_SUCCESS;
+    return ERROR_PATH_NOT_FOUND;
 }
diff --git a/dep/CascLib/src/common/Directory.h b/dep/CascLib/src/common/Directory.h
index 30c7e384284..f2f0d5e4c65 100644
--- a/dep/CascLib/src/common/Directory.h
+++ b/dep/CascLib/src/common/Directory.h
@@ -14,13 +14,21 @@
 //-----------------------------------------------------------------------------
 // Scanning a directory
 
-bool DirectoryExists(LPCTSTR szDirectory);
+// If the callback returns false, the directory enumeration stops
+typedef bool (*DIRECTORY_CALLBACK)(LPCTSTR szPathName, void * pvContext);
 
-bool MakeDirectory(LPCTSTR szDirectory);
+bool DirectoryExists(
+    LPCTSTR szDirectory
+    );
+
+bool MakeDirectory(
+    LPCTSTR szDirectory
+    );
 
-int ScanIndexDirectory(
-    LPCTSTR szIndexPath,
-    INDEX_FILE_FOUND pfnOnFileFound,
+DWORD ScanDirectory(
+    LPCTSTR szDirectory,
+    DIRECTORY_CALLBACK PfnFolderCallback,       // Can be NULL if the caller doesn't care about folders
+    DIRECTORY_CALLBACK PfnFileCallback,         // Can be NULL if the caller doesn't care about files
     void * pvContext
     );
 
diff --git a/dep/CascLib/src/common/FileStream.cpp b/dep/CascLib/src/common/FileStream.cpp
index 622af421a82..7151ca9f36d 100644
--- a/dep/CascLib/src/common/FileStream.cpp
+++ b/dep/CascLib/src/common/FileStream.cpp
@@ -672,20 +672,22 @@ static DWORD BaseHttp_ParseURL(TFileStream * pStream, LPCTSTR szFileName, int *
 
 static bool BaseHttp_Download(TFileStream * pStream)
 {
+    CASC_MIME_RESPONSE MimeResponse;
+    CASC_BLOB FileData;
     CASC_MIME Mime;
     const char * request_mask = "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: Keep-Alive\r\n\r\n";
     char * server_response;
     char * fileName = pStream->Base.Socket.fileName;
     char request[0x100];
-    size_t response_length = 0;
     size_t request_length = 0;
-    DWORD dwErrCode;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // If we already have the data, it's success
     if(pStream->Base.Socket.fileData == NULL)
     {
         // Reset the file data length as well
         pStream->Base.Socket.fileDataLength = 0;
+        dwErrCode = ERROR_BAD_FORMAT;
 
         // Construct the request, either HTTP or Ribbit (https://wowdev.wiki/Ribbit).
         // Note that Ribbit requests don't start with slash
@@ -698,31 +700,31 @@ static bool BaseHttp_Download(TFileStream * pStream)
 
         // Send the request and receive decoded response
         request_length = CascStrPrintf(request, _countof(request), request_mask, fileName, pStream->Base.Socket.hostName);
-        server_response = pStream->Base.Socket.pSocket->ReadResponse(request, request_length, &response_length);
+        server_response = pStream->Base.Socket.pSocket->ReadResponse(request, request_length, MimeResponse);
         if(server_response != NULL)
         {
-            // Check for non-zero data
-            if(response_length != 0)
+            // Decode the MIME document
+            if((dwErrCode = Mime.Load(server_response, MimeResponse)) == ERROR_SUCCESS)
             {
-                // Decode the MIME document
-                if((dwErrCode = Mime.Load(server_response, response_length)) == ERROR_SUCCESS)
+                // Move the data from MIME to HTTP stream
+                if((dwErrCode = Mime.GiveAway(FileData)) == ERROR_SUCCESS)
                 {
-                    // Move the data from MIME to HTTP stream
-                    pStream->Base.Socket.fileData = Mime.GiveAway(&pStream->Base.Socket.fileDataLength);
+                    pStream->Base.Socket.fileData = FileData.pbData;
+                    pStream->Base.Socket.fileDataLength = FileData.cbData;
+                    pStream->Base.Socket.fileDataPos = 0;
+                    FileData.Reset();
                 }
             }
-            else
-            {
-                SetCascError(ERROR_BAD_FORMAT);
-            }
 
             // Free the buffer
             CASC_FREE(server_response);
         }
     }
 
-    // If we have data loaded, return true
-    return (pStream->Base.Socket.fileData != NULL);
+    // Process error codes
+    if(dwErrCode != ERROR_SUCCESS)
+        SetCascError(dwErrCode);
+    return (dwErrCode == ERROR_SUCCESS);
 }
 
 static bool BaseHttp_Open(TFileStream * pStream, LPCTSTR szFileName, DWORD dwStreamFlags)
diff --git a/dep/CascLib/src/common/FileTree.cpp b/dep/CascLib/src/common/FileTree.cpp
index 490698122e5..fa21863c5e9 100644
--- a/dep/CascLib/src/common/FileTree.cpp
+++ b/dep/CascLib/src/common/FileTree.cpp
@@ -177,7 +177,7 @@ bool CASC_FILE_TREE::RebuildNameMaps()
     if(NameMap.Create(nMaxItems, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_NODE, FileNameHash)) != ERROR_SUCCESS)
         return false;
 
-    // Reset the entire array, but keep the buffer allocated
+    // Reset the entire array, but buffers allocated
     FileDataIds.Reset();
 
     // Parse all items and insert them to the map
@@ -393,13 +393,22 @@ PCASC_FILE_NODE CASC_FILE_TREE::ItemAt(size_t nItemIndex)
 
 PCASC_FILE_NODE CASC_FILE_TREE::PathAt(char * szBuffer, size_t cchBuffer, size_t nItemIndex)
 {
+    PCASC_FILE_NODE * RefFileNode;
     PCASC_FILE_NODE pFileNode = NULL;
 
     // If we have FileDataId, then we need to enumerate the files by FileDataId
     if(FileDataIds.IsInitialized())
-        pFileNode = *(PCASC_FILE_NODE *)FileDataIds.ItemAt(nItemIndex);
+    {
+        RefFileNode = (PCASC_FILE_NODE *)FileDataIds.ItemAt(nItemIndex);
+        if(RefFileNode != NULL)
+        {
+            pFileNode = *(PCASC_FILE_NODE *)FileDataIds.ItemAt(nItemIndex);
+        }
+    }
     else
+    {
         pFileNode = (PCASC_FILE_NODE)NodeTable.ItemAt(nItemIndex);
+    }
 
     // Construct the entire path
     PathAt(szBuffer, cchBuffer, pFileNode);
diff --git a/dep/CascLib/src/common/FileTree.h b/dep/CascLib/src/common/FileTree.h
index 38bc4e07e9f..69a2c15c496 100644
--- a/dep/CascLib/src/common/FileTree.h
+++ b/dep/CascLib/src/common/FileTree.h
@@ -82,6 +82,13 @@ class CASC_FILE_TREE
     // Retrieve the maximum FileDataId ever inserted
     DWORD GetNextFileDataId();
 
+#ifdef _DEBUG
+    void DumpFileDataIds(const char * szFileName)
+    {
+        FileDataIds.Dump(szFileName);
+    }
+#endif
+
     protected:
 
     PCASC_FILE_NODE InsertNew(PCASC_CKEY_ENTRY pCKeyEntry);
@@ -95,7 +102,8 @@ class CASC_FILE_TREE
     CASC_ARRAY NodeTable;                           // Dynamic array that holds all CASC_FILE_NODEs
     CASC_ARRAY NameTable;                           // Dynamic array that holds all node names
 
-    CASC_ARRAY FileDataIds;                         // Dynamic array that maps FileDataId -> CASC_FILE_NODE
+    CASC_SPARSE_ARRAY FileDataIds;                  // Dynamic array that maps FileDataId -> CASC_FILE_NODE
+    //CASC_ARRAY FileDataIds;                         // Dynamic array that maps FileDataId -> CASC_FILE_NODE
     CASC_MAP NameMap;                               // Map of FileNameHash -> CASC_FILE_NODE
 
     size_t FileDataIdOffset;                        // If nonzero, this is the offset of the "FileDataId" field in the CASC_FILE_NODE
diff --git a/dep/CascLib/src/common/ListFile.cpp b/dep/CascLib/src/common/ListFile.cpp
index a91922cd9b1..4545ada62e9 100644
--- a/dep/CascLib/src/common/ListFile.cpp
+++ b/dep/CascLib/src/common/ListFile.cpp
@@ -303,14 +303,14 @@ LPBYTE ListFile_GetData(void * pvListFile, PDWORD PtrDataSize)
     DWORD cbData = 0;
 
     // Get data from the list file cache
-    if (pvListFile != NULL)
+    if(pvListFile != NULL)
     {
         pbData = (LPBYTE)pCache->pBegin;
         cbData = (DWORD)(pCache->pEnd - pCache->pBegin);
     }
 
     // Give the data to the caller
-    if (PtrDataSize != NULL)
+    if(PtrDataSize != NULL)
         PtrDataSize[0] = cbData;
     return pbData;
 }
diff --git a/dep/CascLib/src/common/Mime.cpp b/dep/CascLib/src/common/Mime.cpp
index faa3402d832..5aa7401ff24 100644
--- a/dep/CascLib/src/common/Mime.cpp
+++ b/dep/CascLib/src/common/Mime.cpp
@@ -37,45 +37,90 @@ static size_t DecodeValueInt32(const char * string, const char * string_end)
     return result;
 }
 
-size_t CASC_MIME_HTTP::IsDataComplete(const char * response, size_t response_length, size_t * ptr_content_length)
+static const char * GetContentLengthValue(const char * response, const char * end)
 {
-    const char * content_length_ptr;
-    const char * content_begin_ptr;
+    const char * ptr;
 
-    // Do not parse the HTTP response multiple times
-    if((http_flags & HTTP_HEADER_COMPLETE) == 0 && response_length > 8)
+    if((ptr = strstr(response, "Content-Length: ")) != NULL && ptr < end)
+        return ptr;
+    if((ptr = strstr(response, "content-length: ")) != NULL && ptr < end)
+        return ptr;
+    return NULL;
+}
+
+bool CASC_MIME_RESPONSE::ParseResponse(const char * response, size_t length, bool final)
+{
+    const char * ptr;
+
+    // Only parse the data if there was an increment
+    if(length > response_length)
     {
-        // Check the begin of the response
-        if(!strncmp(response, "HTTP/1.1", 8))
+        // Set the header offset
+        header_offset = 0;
+
+        // Check for the complete header
+        if(header_length == CASC_INVALID_SIZE_T)
         {
-            // Check if there's begin of the content
-            if((content_begin_ptr = strstr(response, "\r\n\r\n")) != NULL)
+            if((ptr = strstr(response, "\r\n\r\n")) != NULL)
             {
-                // HTTP responses contain "Content-Length: %u\n\r"
-                if((content_length_ptr = strstr(response, "Content-Length: ")) == NULL)
-                    content_length_ptr = strstr(response, "content-length: ");
-                if(content_length_ptr != NULL)
-                {
-                    // The content length info must be before the actual content
-                    if(content_length_ptr < content_begin_ptr)
-                    {
-                        // Fill the HTTP info cache
-                        content_offset = (content_begin_ptr + 4) - response;
-                        content_length = DecodeValueInt32(content_length_ptr + 16, content_begin_ptr);
-                        total_length = content_offset + content_length;
-                        http_flags = HTTP_HEADER_COMPLETE;
-                    }
-                }
+                header_length = (ptr - response) - header_offset;
+                content_offset = header_length + 4;
             }
         }
+
+        // Determine the presence of the HTTP field
+        if(http_presence == FieldPresenceUnknown && header_length != CASC_INVALID_SIZE_T)
+        {
+            const char * http_ptr = (response + header_offset);
+
+            if(!_strnicmp(http_ptr, "HTTP/1.1 ", 9))
+            {
+                http_presence = FieldPresencePresent;
+                http_code = DecodeValueInt32(response + 9, response + 13);
+            }
+            else
+            {
+                http_presence = FieldPresenceNotPresent;
+            }
+        }
+
+        // Determine the presence of content length
+        if(clength_presence == FieldPresenceUnknown && header_length != CASC_INVALID_SIZE_T)
+        {
+            const char * clength_ptr = GetContentLengthValue(response + header_offset, response + header_length);
+
+            if(clength_ptr != NULL)
+            {
+                content_length = DecodeValueInt32(clength_ptr + 16, response + header_length);
+                clength_presence = FieldPresencePresent;
+            }
+            else
+            {
+                clength_presence = FieldPresenceNotPresent;
+            }
+        }
+
+        // Update the length
+        response_length = length;
+    }
+
+    // If this is a final response parsing we calculate the content length
+    if(content_length == CASC_INVALID_SIZE_T && final == true && (content_offset + 2) < length)
+    {
+        // The field must end with \r\n (0D 0A)
+        const char * end_ptr = (response + length - 2);
+
+        // Is the MIME data terminated with "\r\n"?
+        if(end_ptr[0] == 0x0D && end_ptr[1] == 0x0A)
+        {
+            content_length = (response + length - 2) - (response + content_offset);
+        }
     }
 
-    // Update flags
-    if((http_flags & HTTP_HEADER_COMPLETE) && (ptr_content_length != NULL))
-        ptr_content_length[0] = content_length;
-    if(total_length == response_length)
-        http_flags |= HTTP_DATA_COMPLETE;
-    return http_flags;
+    // Determine if we are finished or not
+    if(header_length != CASC_INVALID_SIZE_T && content_length != CASC_INVALID_SIZE_T)
+        return (length >= content_offset + content_length);
+    return false;
 }
 
 //-----------------------------------------------------------------------------
@@ -141,33 +186,27 @@ CASC_MIME_ELEMENT::~CASC_MIME_ELEMENT()
     if(folder.pNext != NULL)
         delete folder.pNext;
     folder.pNext = NULL;
-
-    // Free the data
-    if(data.begin != NULL)
-        CASC_FREE(data.begin);
-    data.begin = NULL;
 }
 
-unsigned char * CASC_MIME_ELEMENT::GiveAway(size_t * ptr_data_length)
+DWORD CASC_MIME_ELEMENT::GiveAway(CASC_BLOB & target)
 {
-    unsigned char * give_away_data = data.begin;
-    size_t give_away_length = data.length;
-
-    // Clear the data (DO NOT FREE)
-    data.begin = NULL;
-    data.length = 0;
+    if(data.pbData && data.cbData)
+    {
+        target.MoveFrom(data);
+        return ERROR_SUCCESS;
+    }
+    return ERROR_HANDLE_EOF;
+}
 
-    // Copy the data to local buffer
-    if(ptr_data_length != NULL)
-        ptr_data_length[0] = give_away_length;
-    return give_away_data;
+DWORD CASC_MIME_ELEMENT::LoadSingle(char * data_ptr, size_t data_length)
+{
+    return data.SetData(data_ptr, data_length);
 }
 
 DWORD CASC_MIME_ELEMENT::Load(char * mime_data_begin, char * mime_data_end, const char * boundary_ptr)
 {
     CASC_MIME_ENCODING Encoding = MimeEncodingTextPlain;
     CASC_MIME_BLOB mime_data(mime_data_begin, mime_data_end);
-    CASC_MIME_HTTP HttpInfo;
     size_t length_begin;
     size_t length_end;
     char * mime_line;
@@ -176,18 +215,6 @@ DWORD CASC_MIME_ELEMENT::Load(char * mime_data_begin, char * mime_data_end, cons
     DWORD dwErrCode = ERROR_SUCCESS;
     bool mime_version = false;
 
-    // Diversion for HTTP: No need to parse the entire headers and stuff.
-    // Just give the data right away
-    if(HttpInfo.IsDataComplete(mime_data_begin, (mime_data_end - mime_data_begin)))
-    {
-        if((data.begin = CASC_ALLOC<BYTE>(HttpInfo.content_length)) == NULL)
-            return ERROR_NOT_ENOUGH_MEMORY;
-        
-        memcpy(data.begin, mime_data_begin + HttpInfo.content_offset, HttpInfo.content_length);
-        data.length = HttpInfo.content_length;
-        return ERROR_SUCCESS;
-    }
-
     // Reset the boundary
     boundary[0] = 0;
 
@@ -298,9 +325,7 @@ DWORD CASC_MIME_ELEMENT::Load(char * mime_data_begin, char * mime_data_end, cons
         else
         {
             CASC_MIME_BLOB content(mime_data.ptr, NULL);
-            unsigned char * data_buffer;
-            size_t data_length = 0;
-            size_t raw_length;
+            CASC_BLOB data_buffer;
 
             // If we have boundary pointer, we need to cut the data up to the boundary end.
             // Otherwise, we decode the data to the end of the document
@@ -323,47 +348,26 @@ DWORD CASC_MIME_ELEMENT::Load(char * mime_data_begin, char * mime_data_end, cons
                     return ERROR_BAD_FORMAT;
             }
 
-            // Allocate buffer for decoded data.
-            // Make it the same size like source data plus zero at the end
-            raw_length = (content.end - content.ptr);
-            data_buffer = CASC_ALLOC<unsigned char>(raw_length);
-            if(data_buffer != NULL)
+            // Decode the data
+            switch(Encoding)
             {
-                // Decode the data
-                switch(Encoding)
-                {
-                    case MimeEncodingTextPlain:
-                        dwErrCode = DecodeTextPlain(content.ptr, content.end, data_buffer, &data_length);
-                        break;
+                case MimeEncodingTextPlain:
+                    dwErrCode = DecodeTextPlain(content.ptr, content.end, data);
+                    break;
 
-                    case MimeEncodingQuotedPrintable:
-                        dwErrCode = DecodeQuotedPrintable(content.ptr, content.end, data_buffer, &data_length);
-                        break;
+                case MimeEncodingQuotedPrintable:
+                    dwErrCode = DecodeQuotedPrintable(content.ptr, content.end, data);
+                    break;
 
-                    case MimeEncodingBase64:
-                        dwErrCode = DecodeBase64(content.ptr, content.end, data_buffer, &data_length);
-                        break;
+                case MimeEncodingBase64:
+                    dwErrCode = DecodeBase64(content.ptr, content.end, data);
+                    break;
                     
-                    default:;
-                        // to remove warning
-                }
-
-                // If failed, free the buffer back
-                if(dwErrCode != ERROR_SUCCESS)
-                {
-                    CASC_FREE(data_buffer);
-                    data_buffer = NULL;
-                    data_length = 0;
-                }
-            }
-            else
-            {
-                dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
+                default:
+                    dwErrCode = ERROR_NOT_SUPPORTED;
+                    assert(false);
+                    break;
             }
-
-            // Put the data there, even if they are invalid
-            data.begin = data_buffer;
-            data.length = data_length;
         }
     }
     else
@@ -400,15 +404,15 @@ void CASC_MIME_ELEMENT::Print(size_t nLevel, size_t nIndex)
     {
         char data_printable[0x20] = {0};
 
-        for(size_t i = 0; (i < data.length && i < _countof(data_printable) - 1); i++)
+        for(size_t i = 0; (i < data.cbData && i < _countof(data_printable) - 1); i++)
         {
-            if(0x20 <= data.begin[i] && data.begin[i] <= 0x7F)
-                data_printable[i] = data.begin[i];
+            if(0x20 <= data.pbData[i] && data.pbData[i] <= 0x7F)
+                data_printable[i] = data.pbData[i];
             else
                 data_printable[i] = '.';
         }
 
-        printf("Data item (%u bytes): \"%s\"\n", (int)data.length, data_printable);
+        printf("Data item (%u bytes): \"%s\"\n", (int)data.cbData, data_printable);
     }
 
     // Do we have a next element?
@@ -481,127 +485,124 @@ bool CASC_MIME_ELEMENT::ExtractBoundary(const char * line)
     return false;
 }
 
-DWORD CASC_MIME_ELEMENT::DecodeTextPlain(char * content_begin, char * content_end, unsigned char * data_buffer, size_t * ptr_length)
+DWORD CASC_MIME_ELEMENT::DecodeTextPlain(char * content_begin, char * content_end, CASC_BLOB & output)
 {
-    size_t data_length = (size_t)(content_end - content_begin);
-
-    // Sanity checks
-    assert(content_begin && content_end);
-    assert(content_end > content_begin);
-
-    // Plain copy
-    memcpy(data_buffer, content_begin, data_length);
-
-    // Give the result
-    if(ptr_length != NULL)
-        ptr_length[0] = data_length;
-    return ERROR_SUCCESS;
+    return output.SetData(content_begin, (content_end - content_begin));
 }
 
 
-DWORD CASC_MIME_ELEMENT::DecodeQuotedPrintable(char * content_begin, char * content_end, unsigned char * data_buffer, size_t * ptr_length)
+DWORD CASC_MIME_ELEMENT::DecodeQuotedPrintable(char * content_begin, char * content_end, CASC_BLOB & output)
 {
-    unsigned char * save_data_buffer = data_buffer;
-    char * content_ptr;
     DWORD dwErrCode;
 
     // Sanity checks
     assert(content_begin && content_end);
     assert(content_end > content_begin);
 
-    // Decode the data
-    for(content_ptr = content_begin; content_ptr < content_end; )
+    // Allocate space for the output
+    if((dwErrCode = output.SetSize(content_end - content_begin)) == ERROR_SUCCESS)
     {
-        // If the data begins with '=', there is either newline or 2-char hexa number
-        if(content_ptr[0] == '=')
+        unsigned char * output_ptr = output.pbData;
+        char * content_ptr;
+
+        // Decode the data
+        for(content_ptr = content_begin; content_ptr < content_end; )
         {
-            // Is there a newline after the equal sign?
-            if(content_ptr[1] == 0x0D && content_ptr[2] == 0x0A)
+            // If the data begins with '=', there is either newline or 2-char hexa number
+            if(content_ptr[0] == '=')
             {
+                // Is there a newline after the equal sign?
+                if(content_ptr[1] == 0x0D && content_ptr[2] == 0x0A)
+                {
+                    content_ptr += 3;
+                    continue;
+                }
+
+                // Is there hexa number after the equal sign?
+                dwErrCode = BinaryFromString(content_ptr + 1, 2, output_ptr);
+                if(dwErrCode != ERROR_SUCCESS)
+                    return dwErrCode;
+
                 content_ptr += 3;
+                output_ptr++;
                 continue;
             }
-
-            // Is there hexa number after the equal sign?
-            dwErrCode = BinaryFromString(content_ptr + 1, 2, data_buffer);
-            if(dwErrCode != ERROR_SUCCESS)
-                return dwErrCode;
-
-            content_ptr += 3;
-            data_buffer++;
-            continue;
-        }
-        else
-        {
-            *data_buffer++ = (unsigned char)(*content_ptr++);
+            else
+            {
+                *output_ptr++ = (unsigned char)(*content_ptr++);
+            }
         }
-    }
 
-    if(ptr_length != NULL)
-        ptr_length[0] = (size_t)(data_buffer - save_data_buffer);
-    return ERROR_SUCCESS;
+        // Set the real length
+        output.cbData = (size_t)(output_ptr - output.pbData);
+    }
+    return dwErrCode;
 }
 
-DWORD CASC_MIME_ELEMENT::DecodeBase64(char * content_begin, char * content_end, unsigned char * data_buffer, size_t * ptr_length)
+DWORD CASC_MIME_ELEMENT::DecodeBase64(char * content_begin, char * content_end, CASC_BLOB & output)
 {
-    unsigned char * save_data_buffer = data_buffer;
+    DWORD dwErrCode;
     DWORD BitBuffer = 0;
     DWORD BitCount = 0;
     BYTE OneByte;
 
-    // One time preparation of the conversion table
-    if(CascBase64ToBits[0] == 0)
+    if((dwErrCode = output.SetSize(content_end - content_begin)) == ERROR_SUCCESS)
     {
-        // Fill the entire table with 0xFF to mark invalid characters
-        memset(CascBase64ToBits, BASE64_INVALID_CHAR, sizeof(CascBase64ToBits));
-
-        // Set all whitespace characters
-        for(BYTE i = 1; i <= 0x20; i++)
-            CascBase64ToBits[i] = BASE64_WHITESPACE_CHAR;
+        unsigned char * output_ptr = output.pbData;
 
-        // Set all valid characters
-        for(BYTE i = 0; CascBase64Table[i] != 0; i++)
+        // One time preparation of the conversion table
+        if(CascBase64ToBits[0] == 0)
         {
-            OneByte = CascBase64Table[i];
-            CascBase64ToBits[OneByte] = i;
-        }
-    }
+            // Fill the entire table with 0xFF to mark invalid characters
+            memset(CascBase64ToBits, BASE64_INVALID_CHAR, sizeof(CascBase64ToBits));
 
-    // Do the decoding
-    while(content_begin < content_end && content_begin[0] != '=')
-    {
-        // Check for end of string
-        if(content_begin[0] > sizeof(CascBase64ToBits))
-            return ERROR_BAD_FORMAT;
-        if((OneByte = CascBase64ToBits[*content_begin++]) == BASE64_INVALID_CHAR)
-            return ERROR_BAD_FORMAT;
-        if(OneByte == BASE64_WHITESPACE_CHAR)
-            continue;
+            // Set all whitespace characters
+            for(BYTE i = 1; i <= 0x20; i++)
+                CascBase64ToBits[i] = BASE64_WHITESPACE_CHAR;
 
-        // Put the 6 bits into the bit buffer
-        BitBuffer = (BitBuffer << 6) | OneByte;
-        BitCount += 6;
+            // Set all valid characters
+            for(BYTE i = 0; CascBase64Table[i] != 0; i++)
+            {
+                OneByte = CascBase64Table[i];
+                CascBase64ToBits[OneByte] = i;
+            }
+        }
 
-        // Flush all values
-        while(BitCount >= 8)
+        // Do the decoding
+        while(content_begin < content_end && content_begin[0] != '=')
         {
-            // Decrement the bit count in the bit buffer
-            BitCount -= 8;
+            // Check for end of string
+            if(content_begin[0] > sizeof(CascBase64ToBits))
+                return ERROR_BAD_FORMAT;
+            if((OneByte = CascBase64ToBits[*content_begin++]) == BASE64_INVALID_CHAR)
+                return ERROR_BAD_FORMAT;
+            if(OneByte == BASE64_WHITESPACE_CHAR)
+                continue;
+
+            // Put the 6 bits into the bit buffer
+            BitBuffer = (BitBuffer << 6) | OneByte;
+            BitCount += 6;
 
-            // The byte is the upper 8 bits of the bit buffer
-            OneByte = (BYTE)(BitBuffer >> BitCount);
-            BitBuffer = BitBuffer % (1 << BitCount);
+            // Flush all values
+            while(BitCount >= 8)
+            {
+                // Decrement the bit count in the bit buffer
+                BitCount -= 8;
+
+                // The byte is the upper 8 bits of the bit buffer
+                OneByte = (BYTE)(BitBuffer >> BitCount);
+                BitBuffer = BitBuffer % (1 << BitCount);
 
-            // Put the byte value. The buffer can not overflow,
-            // because it is guaranteed to be equal to the length of the base64 string
-            *data_buffer++ = OneByte;
+                // Put the byte value. The buffer can not overflow,
+                // because it is guaranteed to be equal to the length of the base64 string
+                *output_ptr++ = OneByte;
+            }
         }
-    }
 
-    // Return the decoded length
-    if(ptr_length != NULL)
-        ptr_length[0] = (data_buffer - save_data_buffer);
-    return ERROR_SUCCESS;
+        // Set the decoded length
+        output.cbData = (output_ptr - output.pbData);
+    }
+    return dwErrCode;
 }
 
 //-----------------------------------------------------------------------------
@@ -613,62 +614,57 @@ CASC_MIME::CASC_MIME()
 CASC_MIME::~CASC_MIME()
 {}
 
-unsigned char * CASC_MIME::GiveAway(size_t * ptr_data_length)
+DWORD CASC_MIME::GiveAway(CASC_BLOB & target)
 {
-    CASC_MIME_ELEMENT * pElement = &root;
-    unsigned char * data;
+    CASC_MIME_ELEMENT * pElement;
 
     // 1) Give the data from the root
-    if((data = root.GiveAway(ptr_data_length)) != NULL)
-        return data;
+    if(root.GiveAway(target) == ERROR_SUCCESS)
+        return ERROR_SUCCESS;
 
     // 2) If we have children, then give away from the first child
-    pElement = root.GetChild();
-    if(pElement && (data = pElement->GiveAway(ptr_data_length)) != NULL)
-        return data;
-
-    // Return NULL
-    if(ptr_data_length != NULL)
-        ptr_data_length[0] = 0;
-    return NULL;
-}
+    if((pElement = root.GetChild()) != NULL)
+        return pElement->GiveAway(target);
 
-DWORD CASC_MIME::Load(char * data, size_t length)
-{
-    // Clear the root element
-    memset(&root, 0, sizeof(CASC_MIME_ELEMENT));
-
-    //FILE * fp = fopen("E:\\html_response.txt", "wb");
-    //if(fp != NULL)
-    //{
-    //    fwrite(data, 1, length, fp);
-    //    fclose(fp);
-    //}
-
-    // Load the root element
-    return root.Load(data, data + length);
+    return ERROR_CAN_NOT_COMPLETE;
 }
 
-DWORD CASC_MIME::Load(LPCTSTR szFileName)
+DWORD CASC_MIME::Load(char * data, CASC_MIME_RESPONSE & MimeResponse)
 {
-    char * szFileData;
-    DWORD cbFileData = 0;
-    DWORD dwErrCode = ERROR_SUCCESS;
+    // Avoid parsing empty responses
+    if(MimeResponse.response_length == 0)
+        return ERROR_BAD_FORMAT;
+    if(MimeResponse.header_offset == CASC_INVALID_SIZE_T || MimeResponse.header_length == CASC_INVALID_SIZE_T)
+        return ERROR_BAD_FORMAT;
+    if(MimeResponse.content_offset == CASC_INVALID_SIZE_T || MimeResponse.content_offset == 0)
+        return ERROR_BAD_FORMAT;
+    if(MimeResponse.content_length == CASC_INVALID_SIZE_T || MimeResponse.content_length == 0)
+        return ERROR_BAD_FORMAT;
+
+    // Avoid parsing responses where the data are incomplete
+    // Example: http://level3.blizzard.com/tpr/wow/data/c6/50/c650c203d52b9e5bdcf1d4b2b8b5bd16.index
+    if(MimeResponse.response_length < (MimeResponse.content_offset + MimeResponse.content_length))
+        return ERROR_BAD_FORMAT;
+
+    // Debug: dump the MIME data to file
+#ifdef _DEBUG
+    //CascDumpData("E:\\mime_raw_data.txt", data, MimeResponse.response_length);
+#endif
 
-    // Note that LoadFileToMemory allocated one byte more and puts zero at the end
-    // Thus, we can treat it as zero-terminated string
-    szFileData = (char *)LoadFileToMemory(szFileName, &cbFileData);
-    if(szFileData != NULL)
+    // Special handling of HTTP responses
+    if(MimeResponse.http_presence == FieldPresencePresent)
     {
-        dwErrCode = Load(szFileData, cbFileData);
-        CASC_FREE(szFileData);
-    }
-    else
-    {
-        dwErrCode = GetCascError();
+        // Avoid parsing of failed HTTP requests
+        if(MimeResponse.http_code != 200)
+            return ERROR_FILE_NOT_FOUND;
+
+        // Directly setup the root item
+        return root.LoadSingle(data + MimeResponse.content_offset, MimeResponse.content_length);
     }
 
-    return dwErrCode;
+    // Load the root element
+    memset(&root, 0, sizeof(CASC_MIME_ELEMENT));
+    return root.Load(data, data + MimeResponse.response_length);
 }
 
 #ifdef _DEBUG
diff --git a/dep/CascLib/src/common/Mime.h b/dep/CascLib/src/common/Mime.h
index dc7db517179..9142c33bfd3 100644
--- a/dep/CascLib/src/common/Mime.h
+++ b/dep/CascLib/src/common/Mime.h
@@ -16,7 +16,7 @@
 
 #define MAX_LENGTH_BOUNDARY 128
 
-// Flags returned by CASC_MIME_HTTP::IsDataComplete()
+// Flags returned by CASC_MIME_HTTP::GetHttpReplyFlags()
 #define HTTP_HEADER_COMPLETE    0x01            // HTML header is complete
 #define HTTP_DATA_COMPLETE      0x02            // HTML data is complete
 
@@ -28,22 +28,37 @@ enum CASC_MIME_ENCODING
     MimeEncodingMax
 };
 
+enum CASC_PRESENCE
+{
+    FieldPresenceUnknown,
+    FieldPresencePresent,
+    FieldPresenceNotPresent
+};
+
 //-----------------------------------------------------------------------------
 // Structure for caching parsed HTTP response information
 
-struct CASC_MIME_HTTP
+struct CASC_MIME_RESPONSE
 {
-    CASC_MIME_HTTP()
+    CASC_MIME_RESPONSE()
     {
-        total_length = content_offset = content_length = http_flags = 0;
+        header_offset = header_length = CASC_INVALID_SIZE_T;
+        content_offset = content_length = CASC_INVALID_SIZE_T;
+        http_code = CASC_INVALID_SIZE_T;
+        clength_presence = http_presence = FieldPresenceUnknown;
+        response_length = 0;
     }
 
-    size_t IsDataComplete(const char * response, size_t response_length, size_t * ptr_content_length = NULL);
+    bool ParseResponse(const char * response, size_t length, bool final = false);
 
-    size_t content_length;              // Parsed value of "Content-Length"
-    size_t content_offset;              // Offset of the HTTP data, relative to the begin of the response
-    size_t total_length;                // Expected total length of the HTTP response (content_offset + content_size)
-    size_t http_flags;                  // Nonzero if this is an already parsed HTTP response
+    size_t response_length;             // Previous length of the response
+    size_t header_offset;               // Offset of the response header, usually 0
+    size_t header_length;               // Length of the header, if known
+    size_t content_offset;              // Offset of the content
+    size_t content_length;              // Length of the content, if known
+    size_t http_code;                   // HTTP code, if present
+    CASC_PRESENCE clength_presence;     // State of the "content length" field
+    CASC_PRESENCE http_presence;        // Presence of the "HTTP" field
 };
 
 //-----------------------------------------------------------------------------
@@ -70,8 +85,9 @@ class CASC_MIME_ELEMENT
     CASC_MIME_ELEMENT();
     ~CASC_MIME_ELEMENT();
 
-    unsigned char * GiveAway(size_t * ptr_data_length);
+    DWORD GiveAway(CASC_BLOB & target);
 
+    DWORD LoadSingle(char * data, size_t data_length);
     DWORD Load(char * mime_data_begin, char * mime_data_end, const char * boundary_ptr = NULL);
 
     CASC_MIME_ELEMENT * GetChild()  { return folder.pChild; }
@@ -86,9 +102,9 @@ class CASC_MIME_ELEMENT
     bool   ExtractEncoding(const char * line, CASC_MIME_ENCODING & Encoding);
     bool   ExtractBoundary(const char * line);
 
-    DWORD DecodeTextPlain(char * content_begin, char * content_end, unsigned char * data_ptr, size_t * ptr_length);
-    DWORD DecodeQuotedPrintable(char * content_begin, char * content_end, unsigned char * data_ptr, size_t * ptr_length);
-    DWORD DecodeBase64(char * content_begin, char * content_end, unsigned char * data_ptr, size_t * ptr_length);
+    DWORD DecodeTextPlain(char * content_begin, char * content_end, CASC_BLOB & output);
+    DWORD DecodeQuotedPrintable(char * content_begin, char * content_end, CASC_BLOB & output);
+    DWORD DecodeBase64(char * content_begin, char * content_end, CASC_BLOB & output);
 
     struct
     {
@@ -96,12 +112,7 @@ class CASC_MIME_ELEMENT
         CASC_MIME_ELEMENT * pNext;      // Pointer to the next-in-folder element
     } folder;
 
-    struct
-    {
-        unsigned char * begin;
-        size_t length;
-    } data;
-
+    CASC_BLOB data;
     char boundary[MAX_LENGTH_BOUNDARY];
 };
 
@@ -112,10 +123,9 @@ class CASC_MIME
     CASC_MIME();
     ~CASC_MIME();
 
-    unsigned char * GiveAway(size_t * ptr_data_length);
+    DWORD GiveAway(CASC_BLOB & target);
 
-    DWORD Load(char * data, size_t length);
-    DWORD Load(LPCTSTR fileName);
+    DWORD Load(char * data, CASC_MIME_RESPONSE & MimeResponse);
 
 #ifdef _DEBUG
     void Print();
diff --git a/dep/CascLib/src/common/Path.h b/dep/CascLib/src/common/Path.h
index 56489c5f4d9..082ce6ea61c 100644
--- a/dep/CascLib/src/common/Path.h
+++ b/dep/CascLib/src/common/Path.h
@@ -17,13 +17,20 @@
 template <typename xchar>
 struct CASC_PATH
 {
-    CASC_PATH(int chSeparator = PATH_SEP_CHAR)
+    CASC_PATH(const xchar * szRoot, ...)
     {
-        m_szBufferBegin = m_szBufferPtr = m_Buffer;
-        m_szBufferEnd = m_szBufferBegin + _countof(m_Buffer);
-        m_chSeparator = (xchar)chSeparator;
-        m_bLocalCache = 0;
-        m_Buffer[0] = 0;
+        va_list argList;
+
+        Initialize(PATH_SEP_CHAR);
+        
+        va_start(argList, szRoot);
+        Create(szRoot, argList);
+        va_end(argList);
+    }
+
+    CASC_PATH(xchar chSeparator = PATH_SEP_CHAR)
+    {
+        Initialize(chSeparator);
     }
 
     ~CASC_PATH()
@@ -34,10 +41,53 @@ struct CASC_PATH
         }
     }
 
-    // LPCTSTR szPath = Path;
-    operator const xchar *() const
+    void Create(const xchar * szRoot, ...)
     {
-        return m_szBufferBegin;
+        va_list argList;
+
+        va_start(argList, szRoot);
+        Create(szRoot, argList);
+        va_end(argList);
+    }
+
+    void Create(const xchar * szRoot, va_list argList)
+    {
+        const xchar * szPathPart;
+
+        // Fill-in the root path
+        SetPathRoot(szRoot);
+
+        // Append all parts until there is NULL
+        while((szPathPart = va_arg(argList, const xchar *)) != NULL)
+        {
+            AppendString(szPathPart, true);
+        }
+    }
+
+    bool CutLastPart()
+    {
+        xchar * szBufferPtr;
+
+        // Cut ending (back)slashes, if any
+        while((m_szBufferPtr > m_szBufferBegin) && (m_szBufferPtr[-1] == _T('\\') || m_szBufferPtr[-1] == _T('/')))
+            m_szBufferPtr--;
+        szBufferPtr = m_szBufferPtr - 1;
+
+        // Cut the last path part
+        while(szBufferPtr > m_szBufferBegin)
+        {
+            // End of path?
+            if(szBufferPtr[0] == _T('\\') || szBufferPtr[0] == _T('/'))
+            {
+                m_szBufferPtr = szBufferPtr;
+                m_szBufferPtr[0] = 0;
+                return true;
+            }
+
+            // Go one character back
+            szBufferPtr--;
+        }
+        return false;
     }
 
     void SetLocalCaching(int bLocalCache)
@@ -50,11 +100,22 @@ struct CASC_PATH
         return (m_bLocalCache != 0);
     }
 
+    // LPCTSTR szPath = Path;
+    operator const xchar * () const
+    {
+        return m_szBufferBegin;
+    }
+
     // LPTSTR szPath = Path.New();
-    xchar * New()
+    xchar * New(bool bCutLastPart = false)
     {
         xchar * szNewStr;
 
+        if(bCutLastPart)
+        {
+            CutLastPart();
+        }
+
         if((szNewStr = CASC_ALLOC<xchar>(Length() + 1)) != NULL)
         {
             memcpy(szNewStr, m_szBufferBegin, Length() * sizeof(xchar));
@@ -77,12 +138,11 @@ struct CASC_PATH
             m_szBufferPtr[0] = 0;
             return true;
         }
-
         return false;
     }
 
-    // Path.Copy(szBuffer, _countof(szBuffer));
-    bool Copy(xchar * szBuffer, size_t cchBuffer)
+    // Path.CopyTo(szBuffer, _countof(szBuffer));
+    bool CopyTo(xchar * szBuffer, size_t cchBuffer)
     {
         if((Length() + 1) > cchBuffer)
             return false;
@@ -183,6 +243,15 @@ struct CASC_PATH
 
     protected:
 
+    void Initialize(xchar chSeparator)
+    {
+        m_szBufferBegin = m_szBufferPtr = m_Buffer;
+        m_szBufferEnd = m_szBufferBegin + _countof(m_Buffer);
+        m_chSeparator = chSeparator;
+        m_bLocalCache = 0;
+        m_Buffer[0] = 0;
+    }
+
     xchar * m_szBufferBegin;
     xchar * m_szBufferPtr;
     xchar * m_szBufferEnd;
diff --git a/dep/CascLib/src/common/RootHandler.cpp b/dep/CascLib/src/common/RootHandler.cpp
index fa34346b9ce..95fa106e1bd 100644
--- a/dep/CascLib/src/common/RootHandler.cpp
+++ b/dep/CascLib/src/common/RootHandler.cpp
@@ -87,7 +87,7 @@ PCASC_CKEY_ENTRY TFileTreeRoot::Search(TCascSearch * pSearch, PCASC_FIND_DATA pF
             if(!(pFileNode->Flags & CFN_FLAG_FOLDER))
             {
                 // Check the wildcard
-                if (CascCheckWildCard(pFindData->szFileName, pSearch->szMask))
+                if(CascCheckWildCard(pFindData->szFileName, pSearch->szMask))
                 {
                     // Retrieve the extra values (FileDataId, file size and locale flags)
                     FileTree.GetExtras(pFileNode, &pFindData->dwFileDataId, &pFindData->dwLocaleFlags, &pFindData->dwContentFlags);
diff --git a/dep/CascLib/src/common/Sockets.cpp b/dep/CascLib/src/common/Sockets.cpp
index cf3ffe9d0b1..bb490505b15 100644
--- a/dep/CascLib/src/common/Sockets.cpp
+++ b/dep/CascLib/src/common/Sockets.cpp
@@ -24,21 +24,16 @@ CASC_SOCKET_CACHE SocketCache;
 // CASC_SOCKET functions
 
 // Guarantees that there is zero terminator after the response
-char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, size_t * PtrLength)
+char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, CASC_MIME_RESPONSE & MimeResponse)
 {
-    CASC_MIME_HTTP HttpInfo;
     char * server_response = NULL;
-    size_t content_length = 0;
     size_t total_received = 0;
     size_t buffer_length = BUFFER_INITIAL_SIZE;
     size_t buffer_delta = BUFFER_INITIAL_SIZE;
-    size_t http_flags = 0;
     DWORD dwErrCode = ERROR_SUCCESS;
     int bytes_received = 0;
 
     // Pre-set the result length
-    if(PtrLength != NULL)
-        PtrLength[0] = 0;
     if(request_length == 0)
         request_length = strlen(request);
 
@@ -59,9 +54,10 @@ char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, si
     }
 
     // Allocate buffer for server response. Allocate one extra byte for zero terminator
-    if((server_response = CASC_ALLOC<char>(buffer_length + 1)) != NULL)
+    if((server_response = CASC_ALLOC_ZERO<char>(buffer_length + 1)) != NULL)
     {
-        while((http_flags & HTTP_DATA_COMPLETE) == 0)
+        // Keep working until the response parser says it's finished
+        for(;;)
         {
             // Reallocate the buffer size, if needed
             if(total_received == buffer_length)
@@ -80,7 +76,10 @@ char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, si
             // Return value 0 means "connection closed", -1 means an error
             bytes_received = recv(sock, server_response + total_received, (int)(buffer_length - total_received), 0);
             if(bytes_received <= 0)
+            {
+                MimeResponse.ParseResponse(server_response, total_received, true);
                 break;
+            }
 
             // Verify buffer overflow
             if((total_received + bytes_received) < total_received)
@@ -93,23 +92,29 @@ char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, si
             total_received += bytes_received;
             server_response[total_received] = 0;
 
-            // On a HTTP protocol, we need to check whether we received all data
-            http_flags = HttpInfo.IsDataComplete(server_response, total_received, &content_length);
-            if(http_flags & HTTP_HEADER_COMPLETE)
+            // Parse the MIME response
+            if(MimeResponse.ParseResponse(server_response, total_received, false))
+                break;
+
+            // If we know the content length (HTTP only), we temporarily increment
+            // the buffer delta. This will make next reallocation to make buffer
+            // large enough to prevent abundant reallocations and memory memcpy's
+            if(MimeResponse.clength_presence == FieldPresencePresent && MimeResponse.content_length != CASC_INVALID_SIZE_T)
             {
+                // Calculate the final length of the buffer, including the terminating EOLs
+                size_t content_end = MimeResponse.content_offset + MimeResponse.content_length + 2;
+
                 // Check for maximum file size
-                if(content_length > CASC_MAX_ONLINE_FILE_SIZE)
+                if(content_end > CASC_MAX_ONLINE_FILE_SIZE)
                 {
                     dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
                     break;
                 }
 
-                // If we just retrieved the content length, we temporarily increment
-                // the buffer delta. This will make next reallocation to make buffer
-                // large enough to prevent abundant reallocations and memory memcpy's
-                if(content_length > buffer_length)
+                // Estimate the total buffer size
+                if(content_end > buffer_length)
                 {
-                    buffer_delta = (HttpInfo.content_offset + content_length) - buffer_length;
+                    buffer_delta = content_end - buffer_length;
                 }
             }
         }
@@ -127,8 +132,6 @@ char * CASC_SOCKET::ReadResponse(const char * request, size_t request_length, si
     }
 
     // Give the result to the caller
-    if(PtrLength != NULL)
-        PtrLength[0] = total_received;
     return server_response;
 }
 
diff --git a/dep/CascLib/src/common/Sockets.h b/dep/CascLib/src/common/Sockets.h
index 5d1aa677f85..c821748802b 100644
--- a/dep/CascLib/src/common/Sockets.h
+++ b/dep/CascLib/src/common/Sockets.h
@@ -48,7 +48,7 @@ class CASC_SOCKET
 {
     public:
 
-    char * ReadResponse(const char * request, size_t request_length = 0, size_t * PtrLength = NULL);
+    char * ReadResponse(const char * request, size_t request_length, CASC_MIME_RESPONSE & MimeResponse);
     DWORD AddRef();
     void Release();
 
diff --git a/dep/CascLib/src/jenkins/lookup3.c b/dep/CascLib/src/jenkins/lookup3.c
index 8035dc4655a..cb217e738e2 100644
--- a/dep/CascLib/src/jenkins/lookup3.c
+++ b/dep/CascLib/src/jenkins/lookup3.c
@@ -69,6 +69,12 @@ on 1 byte), but shoehorning those bytes into integers efficiently is messy.
 #define hashmask(n) (hashsize(n)-1)
 #define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
 
+/* Fixup some warnings in MS Visual C++ */
+#ifdef _MSC_VER
+#pragma warning(disable: 4127)              // warning C4127: conditional expression is constant
+#pragma warning(disable: 4101)              // warning C4101: 'k8': unreferenced local variable
+#endif
+
 /*
 -------------------------------------------------------------------------------
 mix -- mix 3 32-bit values reversibly.
diff --git a/dep/PackageList.txt b/dep/PackageList.txt
index eef3d00f8a0..393ff763644 100644
--- a/dep/PackageList.txt
+++ b/dep/PackageList.txt
@@ -63,7 +63,7 @@ catch2
 
 CascLib (An open-source implementation of library for reading CASC storage from Blizzard games since 2014)
   https://github.com/ladislav-zezula/CascLib
-  Version: 136c6e05537bd7123620ddb28671d1f2cf060e0b
+  Version: a5080b5794027a25d98aa6024b2bef17d06fe0ea
 
 rapidjson (A fast JSON parser/generator for C++ with both SAX/DOM style API http://rapidjson.org/)
   https://github.com/Tencent/rapidjson