mozilla rel-257 sync with Catchup 2.53 part 1

rel-257/mozilla-esr60/patches/1336712-65a1.patch

@@ -1,86 +0,0 @@
-# HG changeset patch
-# User Chris Peterson <cpeterson@mozilla.com>
-# Date 1541718719 0
-# Node ID e006dd6e8fbd62dd57538294ac29e3489cb823ae
-# Parent  8da2ef9cfccf26b58ae73db01777ce8cabbf2541
-Bug 1336712 - toolkit: Drop test checks for OS X <= 10.8 and Windows XP. r=kmag
-
-Depends on D6584
-
-Differential Revision: https://phabricator.services.mozilla.com/D6585
-
-diff --git a/toolkit/content/aboutSupport.js b/toolkit/content/aboutSupport.js
---- a/toolkit/content/aboutSupport.js
-+++ b/toolkit/content/aboutSupport.js
-@@ -57,20 +57,16 @@ var snapshotFormatters = {
-       case 1:
-       case 2:
-       case 4:
-       case 6:
-       case 7:
-       case 8:
-         statusText = strings.GetStringFromName("multiProcessStatus." + data.autoStartStatus);
-         break;
--
--      case 10:
--        statusText = (Services.appinfo.OS == "Darwin" ? "OS X 10.6 - 10.8" : "Windows XP");
--        break;
-     }
- 
-     $("multiprocess-box").textContent = strings.formatStringFromName("multiProcessWindows",
-       [data.numRemoteWindows, data.numTotalWindows, statusText], 3);
- 
-     if (data.remoteAutoStart) {
-       $("contentprocesses-box").textContent = data.currentContentProcesses +
-                                               "/" +
-diff --git a/toolkit/content/tests/chrome/test_bug624329.xul b/toolkit/content/tests/chrome/test_bug624329.xul
---- a/toolkit/content/tests/chrome/test_bug624329.xul
-+++ b/toolkit/content/tests/chrome/test_bug624329.xul
-@@ -49,23 +49,21 @@ function childFocused() {
-     // maximizing the window is a simple way to ensure that the menu is near
-     // the right edge of the screen.
- 
-     listenOnce("resize", childResized);
-     win.maximize();
- }
- 
- function childResized() {
--    const isOSXLion = navigator.userAgent.includes("Mac OS X 10.7");
--    const isOSXMtnLion = navigator.userAgent.includes("Mac OS X 10.8");
-     const isOSXMavericks = navigator.userAgent.includes("Mac OS X 10.9");
-     const isOSXYosemite = navigator.userAgent.includes("Mac OS X 10.10");
--    if (isOSXLion || isOSXMtnLion || isOSXMavericks || isOSXYosemite) {
-+    if (isOSXMavericks || isOSXYosemite) {
-         todo_is(win.windowState, win.STATE_MAXIMIZED,
--                "A resize before being maximized breaks this test on 10.7 and 10.8 and 10.9 and 10.10");
-+                "A resize before being maximized breaks this test on 10.9 and 10.10");
-         finish();
-         return;
-     }
- 
-     is(win.windowState, win.STATE_MAXIMIZED,
-        "window should be maximized");
- 
-     isnot(win.innerWidth, 300,
-diff --git a/toolkit/locales/en-US/chrome/global/aboutSupport.properties b/toolkit/locales/en-US/chrome/global/aboutSupport.properties
---- a/toolkit/locales/en-US/chrome/global/aboutSupport.properties
-+++ b/toolkit/locales/en-US/chrome/global/aboutSupport.properties
-@@ -132,18 +132,16 @@ multiProcessWindows = %1$S/%2$S (%3$S)
- multiProcessStatus.0 = Enabled by user
- multiProcessStatus.1 = Enabled by default
- multiProcessStatus.2 = Disabled
- multiProcessStatus.4 = Disabled by accessibility tools
- multiProcessStatus.5 = Disabled by lack of graphics hardware acceleration on Mac OS X
- multiProcessStatus.6 = Disabled by unsupported text input
- multiProcessStatus.7 = Disabled by add-ons
- multiProcessStatus.8 = Disabled forcibly
--# No longer in use (bug 1296353) but we might bring this back.
--multiProcessStatus.9 = Disabled by graphics hardware acceleration on Windows XP
- multiProcessStatus.unknown = Unknown status
- 
- asyncPanZoom = Asynchronous Pan/Zoom
- apzNone = none
- wheelEnabled = wheel input enabled
- touchEnabled = touch input enabled
- dragEnabled = scrollbar drag enabled
- keyboardEnabled = keyboard enabled

rel-257/mozilla-esr60/patches/1437128-61a1.patch

@@ -1,44 +0,0 @@
-# HG changeset patch
-# User David Keeler <dkeeler@mozilla.com>
-# Date 1518207075 28800
-# Node ID faa9d965f89eca4a2fe8727149e6fa8d7a699604
-# Parent  b02b1b474565f8e2793e932be8abcf45d2405ac9
-bug 1437128 - enforce that NSS_Shutdown succeeds on debug, non-android platforms (to prevent NSS resource leaks) r=erahm
-
-diff --git a/xpcom/build/XPCOMInit.cpp b/xpcom/build/XPCOMInit.cpp
---- a/xpcom/build/XPCOMInit.cpp
-+++ b/xpcom/build/XPCOMInit.cpp
-@@ -985,26 +985,24 @@ nsresult ShutdownXPCOM(nsIServiceManager
-     sInitializedJS = false;
-   }
- 
-   // After all threads have been joined and the component manager has been shut
-   // down, any remaining objects that could be holding NSS resources (should)
-   // have been released, so we can safely shut down NSS.
-   if (NSS_IsInitialized()) {
-     SSL_ClearSessionCache();
--    // It would be nice to enforce that this succeeds, at least on debug builds.
--    // This would alert us to NSS resource leaks. Unfortunately there are some
--    // architectural roadblocks in the way. Some tests (e.g. pkix gtests) need
--    // to be re-worked to release their NSS resources when they're done. In the
--    // meantime, just emit a warning. Chasing down these leaks is tracked in
--    // bug 1230312.
-     if (NSS_Shutdown() != SECSuccess) {
--      NS_WARNING(
--          "NSS_Shutdown failed - some NSS resources are still in use "
--          "(see bugs 1417680 and 1230312)");
-+      // If you're seeing this crash and/or warning, some NSS resources are
-+      // still in use (see bugs 1417680 and 1230312).
-+#if defined(DEBUG) && !defined(ANDROID)
-+      MOZ_CRASH("NSS_Shutdown failed");
-+#else
-+      NS_WARNING("NSS_Shutdown failed");
-+#endif
-     }
-   }
- 
-   // Release our own singletons
-   // Do this _after_ shutting down the component manager, because the
-   // JS component loader will use XPConnect to call nsIModule::canUnload,
-   // and that will spin up the InterfaceInfoManager again -- bad mojo
-   XPTInterfaceInfoManager::FreeInterfaceInfoManager();

rel-257/mozilla-esr60/patches/1439450-64a1.patch

@@ -1,94 +0,0 @@
-# HG changeset patch
-# User Dimi Lee <dlee@mozilla.com>
-# Date 1539686161 0
-# Node ID 37d138b1e58b9c45ee3baef530bb133597b14eb3
-# Parent  69de195e182f2774b0d8d393c852e7cf8d8df8ff
-Bug 1439450 - Ignore has_first_value() check in ProtocolParser. r=francois
-
-Sometimes the protocol buffer data (RiceEncodingData) sent by Google's Safe Browsing server has the following properties:
-
-1. |has_first_value| is false
-2. |num_entries| > 0
-
-In this case, we can still parse the data and apply partial update correctly by assuming that the first value is equal to 0.
-
-Differential Revision: https://phabricator.services.mozilla.com/D6393
-
-diff --git a/toolkit/components/url-classifier/ProtocolParser.cpp b/toolkit/components/url-classifier/ProtocolParser.cpp
---- a/toolkit/components/url-classifier/ProtocolParser.cpp
-+++ b/toolkit/components/url-classifier/ProtocolParser.cpp
-@@ -921,28 +921,29 @@ nsresult ProtocolParserProtobuf::Process
-     return rv;
-   }
- 
-   return NS_OK;
- }
- 
- static nsresult DoRiceDeltaDecode(const RiceDeltaEncoding& aEncoding,
-                                   nsTArray<uint32_t>& aDecoded) {
--  if (!aEncoding.has_first_value()) {
--    PARSER_LOG(("The encoding info is incomplete."));
--    return NS_ERROR_UC_PARSER_MISSING_PARAM;
--  }
-   if (aEncoding.num_entries() > 0 &&
-       (!aEncoding.has_rice_parameter() || !aEncoding.has_encoded_data())) {
-     PARSER_LOG(("Rice parameter or encoded data is missing."));
-     return NS_ERROR_UC_PARSER_MISSING_PARAM;
-+  } else if (aEncoding.num_entries() == 0 && !aEncoding.has_first_value()) {
-+    PARSER_LOG(("Missing first_value for an single-integer Rice encoding."));
-+    return NS_ERROR_UC_PARSER_MISSING_VALUE;
-   }
- 
-+  auto first_value = aEncoding.has_first_value() ? aEncoding.first_value() : 0;
-+
-   PARSER_LOG(("* Encoding info:"));
--  PARSER_LOG(("  - First value: %" PRId64, aEncoding.first_value()));
-+  PARSER_LOG(("  - First value: %" PRId64, first_value));
-   PARSER_LOG(("  - Num of entries: %d", aEncoding.num_entries()));
-   PARSER_LOG(("  - Rice parameter: %d", aEncoding.rice_parameter()));
- 
-   // Set up the input buffer. Note that the bits should be read
-   // from LSB to MSB so that we in-place reverse the bits before
-   // feeding to the decoder.
-   auto encoded =
-       const_cast<RiceDeltaEncoding&>(aEncoding).mutable_encoded_data();
-@@ -953,17 +954,17 @@ static nsresult DoRiceDeltaDecode(const 
-   if (!aDecoded.SetLength(aEncoding.num_entries() + 1, mozilla::fallible)) {
-     NS_WARNING("Not enough memory to decode the RiceDelta input.");
-     return NS_ERROR_OUT_OF_MEMORY;
-   }
- 
-   // Decode!
-   bool rv = decoder.Decode(
-       aEncoding.rice_parameter(),
--      aEncoding.first_value(),  // first value.
-+      first_value,
-       aEncoding.num_entries(),  // # of entries (first value not included).
-       &aDecoded[0]);
- 
-   NS_ENSURE_TRUE(rv, NS_ERROR_UC_PARSER_DECODE_FAILURE);
- 
-   return NS_OK;
- }
- 
-diff --git a/xpcom/base/ErrorList.py b/xpcom/base/ErrorList.py
---- a/xpcom/base/ErrorList.py
-+++ b/xpcom/base/ErrorList.py
-@@ -1104,16 +1104,17 @@ with modules["URL_CLASSIFIER"]:
-     errors["NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND"] = FAILURE(8)
-     errors["NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE"] = FAILURE(9)
-     errors["NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK"] = FAILURE(10)
- 
-     # Specific errors while parsing pver2/pver4 responses
-     errors["NS_ERROR_UC_PARSER_MISSING_PARAM"] = FAILURE(12)
-     errors["NS_ERROR_UC_PARSER_DECODE_FAILURE"] = FAILURE(13)
-     errors["NS_ERROR_UC_PARSER_UNKNOWN_THREAT"] = FAILURE(14)
-+    errors["NS_ERROR_UC_PARSER_MISSING_VALUE"] = FAILURE(15)
- 
- 
- # =======================================================================
- # 43: NS_ERROR_MODULE_ERRORRESULT
- # =======================================================================
- with modules["ERRORRESULT"]:
-     # Represents a JS Value being thrown as an exception.
-     errors["NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION"] = FAILURE(1)

rel-257/mozilla-esr60/patches/1445969-61a1.patch

@@ -1,36 +0,0 @@
-# HG changeset patch
-# User Yan Or <yor@mozilla.com>
-# Date 1521581154 25200
-# Node ID 317c00f07c399fbe97abcea33029bc416e064347
-# Parent  6f4319fc1bd24a2b2be82a7375176397e1bbdfb6
-Bug 1445969 - removed obsolete code related to b2g r=sylvestre
-
-MozReview-Commit-ID: Hs3lI1nSKWi
-
-diff --git a/js/src/make-source-package.sh b/js/src/make-source-package.sh
---- a/js/src/make-source-package.sh
-+++ b/js/src/make-source-package.sh
-@@ -216,21 +216,17 @@ This release is based on a revision of M
- The changes in the patches/ directory were applied.
- 
- MDN hosts the latest SpiderMonkey ${MOZJS_MAJOR_VERSION} release notes:
-   https://developer.mozilla.org/en-US/docs/SpiderMonkey/${MOZJS_MAJOR_VERSION}
- README_EOF
-     fi
- 
-     # copy LICENSE
--    if [ -e ${TOPSRCDIR}/b2g/LICENSE ]; then
--        cp ${TOPSRCDIR}/b2g/LICENSE ${tgtpath}/
--    else
--        cp ${TOPSRCDIR}/LICENSE ${tgtpath}/
--    fi
-+    cp ${TOPSRCDIR}/LICENSE ${tgtpath}/
- 
-     # copy patches dir, if it currently exists in STAGING
-     if [ -d ${STAGING}/patches ]; then
-         cp -pPR ${STAGING}/patches ${tgtpath}
-     elif [ -d ${TOPSRCDIR}/patches ]; then
-         cp -pPR ${TOPSRCDIR}/patches ${tgtpath}
-     fi
- 
-

rel-257/mozilla-esr60/patches/1460316-62a1.patch

@@ -1,2432 +0,0 @@
-# HG changeset patch
-# User Ryan VanderMeulen <ryanvm@gmail.com>
-# Date 1525882588 14400
-# Node ID 5307919f68429d2e30066fff5e064ffc4caef9f8
-# Parent  f24907e6197691ee269c56b6d1c212ce32778685
-Bug 1460316 - Update lz4 to version 1.8.2. r=froydnj
-
-diff --git a/mfbt/lz4.c b/mfbt/lz4.c
---- a/mfbt/lz4.c
-+++ b/mfbt/lz4.c
-@@ -64,36 +64,40 @@
-  *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
-  * Method 2 : direct access. This method is portable but violate C standard.
-  *            It can generate buggy code on targets which assembly generation depends on alignment.
-  *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
-  * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
-  * Prefer these methods in priority order (0 > 1 > 2)
-  */
- #ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
--#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-+#  if defined(__GNUC__) && \
-+  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
-+  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
- #    define LZ4_FORCE_MEMORY_ACCESS 2
--#  elif defined(__INTEL_COMPILER) || defined(__GNUC__)
-+#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__)
- #    define LZ4_FORCE_MEMORY_ACCESS 1
- #  endif
- #endif
- 
- /*
-  * LZ4_FORCE_SW_BITCOUNT
-  * Define this parameter if your target system or compiler does not support hardware bit count
-  */
--#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for Windows CE does not support Hardware bit count */
-+#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
- #  define LZ4_FORCE_SW_BITCOUNT
- #endif
- 
- 
- 
- /*-************************************
- *  Dependency
- **************************************/
-+#define LZ4_STATIC_LINKING_ONLY
-+#define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
- #include "lz4.h"
- /* see also "memory routines" below */
- 
- 
- /*-************************************
- *  Compiler Options
- **************************************/
- #ifdef _MSC_VER    /* Visual Studio */
-@@ -141,28 +145,33 @@
- #endif
- 
- #if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
- #  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
- #else
- #  define expect(expr,value)    (expr)
- #endif
- 
-+#ifndef likely
- #define likely(expr)     expect((expr) != 0, 1)
-+#endif
-+#ifndef unlikely
- #define unlikely(expr)   expect((expr) != 0, 0)
-+#endif
- 
- 
- /*-************************************
- *  Memory routines
- **************************************/
- #include <stdlib.h>   /* malloc, calloc, free */
--#define ALLOCATOR(n,s) calloc(n,s)
--#define FREEMEM        free
-+#define ALLOC(s)          malloc(s)
-+#define ALLOC_AND_ZERO(s) calloc(1,s)
-+#define FREEMEM(p)        free(p)
- #include <string.h>   /* memset, memcpy */
--#define MEM_INIT       memset
-+#define MEM_INIT(p,v,s)   memset((p),(v),(s))
- 
- 
- /*-************************************
- *  Basic Types
- **************************************/
- #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
- # include <stdint.h>
-   typedef  uint8_t BYTE;
-@@ -265,30 +274,25 @@ static void LZ4_writeLE16(void* memPtr, 
-         LZ4_write16(memPtr, value);
-     } else {
-         BYTE* p = (BYTE*)memPtr;
-         p[0] = (BYTE) value;
-         p[1] = (BYTE)(value>>8);
-     }
- }
- 
--static void LZ4_copy8(void* dst, const void* src)
--{
--    memcpy(dst,src,8);
--}
--
- /* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
- LZ4_FORCE_O2_INLINE_GCC_PPC64LE
- void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
- {
-     BYTE* d = (BYTE*)dstPtr;
-     const BYTE* s = (const BYTE*)srcPtr;
-     BYTE* const e = (BYTE*)dstEnd;
- 
--    do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
-+    do { memcpy(d,s,8); d+=8; s+=8; } while (d<e);
- }
- 
- 
- /*-************************************
- *  Common Constants
- **************************************/
- #define MINMATCH 4
- 
-@@ -316,17 +320,17 @@ static const int LZ4_minLength = (MFLIMI
- #if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
- #  include <assert.h>
- #else
- #  ifndef assert
- #    define assert(condition) ((void)0)
- #  endif
- #endif
- 
--#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-+#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
- 
- #if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
- #  include <stdio.h>
- static int g_debuglog_enable = 1;
- #  define DEBUGLOG(l, ...) {                                  \
-                 if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-                     fprintf(stderr, __FILE__ ": ");           \
-                     fprintf(stderr, __VA_ARGS__);             \
-@@ -445,20 +449,43 @@ unsigned LZ4_count(const BYTE* pIn, cons
- **************************************/
- static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
- static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
- 
- 
- /*-************************************
- *  Local Structures and types
- **************************************/
--typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive;
--typedef enum { byPtr, byU32, byU16 } tableType_t;
-+typedef enum { notLimited = 0, limitedOutput = 1, fillOutput = 2 } limitedOutput_directive;
-+typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
- 
--typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;
-+/**
-+ * This enum distinguishes several different modes of accessing previous
-+ * content in the stream.
-+ *
-+ * - noDict        : There is no preceding content.
-+ * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
-+ *                   blob being compressed are valid and refer to the preceding
-+ *                   content (of length ctx->dictSize), which is available
-+ *                   contiguously preceding in memory the content currently
-+ *                   being compressed.
-+ * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
-+ *                   else in memory, starting at ctx->dictionary with length
-+ *                   ctx->dictSize.
-+ * - usingDictCtx  : Like usingExtDict, but everything concerning the preceding
-+ *                   content is in a separate context, pointed to by
-+ *                   ctx->dictCtx. ctx->dictionary, ctx->dictSize, and table
-+ *                   entries in the current context that refer to positions
-+ *                   preceding the beginning of the current compression are
-+ *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
-+ *                   ->dictSize describe the location and size of the preceding
-+ *                   content, and matches are found by looking in the ctx
-+ *                   ->dictCtx->hashTable.
-+ */
-+typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
- typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
- 
- typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
- typedef enum { full = 0, partial = 1 } earlyEnd_directive;
- 
- 
- /*-************************************
- *  Local Utils
-@@ -492,186 +519,373 @@ static U32 LZ4_hash5(U64 sequence, table
- }
- 
- LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
- {
-     if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-     return LZ4_hash4(LZ4_read32(p), tableType);
- }
- 
--static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)
-+static void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
- {
-     switch (tableType)
-     {
-+    default: /* fallthrough */
-+    case clearedTable: /* fallthrough */
-+    case byPtr: { /* illegal! */ assert(0); return; }
-+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
-+    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
-+    }
-+}
-+
-+static void LZ4_putPositionOnHash(const BYTE* p, U32 h,
-+                                  void* tableBase, tableType_t const tableType,
-+                            const BYTE* srcBase)
-+{
-+    switch (tableType)
-+    {
-+    case clearedTable: { /* illegal! */ assert(0); return; }
-     case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
-     case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
-     case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
-     }
- }
- 
- LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
- {
-     U32 const h = LZ4_hashPosition(p, tableType);
-     LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
- }
- 
--static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+/* LZ4_getIndexOnHash() :
-+ * Index of match position registered in hash table.
-+ * hash position must be calculated by using base+index, or dictBase+index.
-+ * Assumption 1 : only valid if tableType == byU32 or byU16.
-+ * Assumption 2 : h is presumed valid (within limits of hash table)
-+ */
-+static U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
- {
--    if (tableType == byPtr) { const BYTE** hashTable = (const BYTE**) tableBase; return hashTable[h]; }
--    if (tableType == byU32) { const U32* const hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }
--    { const U16* const hashTable = (U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
-+    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
-+    if (tableType == byU32) {
-+        const U32* const hashTable = (const U32*) tableBase;
-+        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
-+        return hashTable[h];
-+    }
-+    if (tableType == byU16) {
-+        const U16* const hashTable = (const U16*) tableBase;
-+        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
-+        return hashTable[h];
-+    }
-+    assert(0); return 0;  /* forbidden case */
- }
- 
--LZ4_FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+{
-+    if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
-+    if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; }
-+    { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
-+}
-+
-+LZ4_FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p,
-+                                             const void* tableBase, tableType_t tableType,
-+                                             const BYTE* srcBase)
- {
-     U32 const h = LZ4_hashPosition(p, tableType);
-     return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
- }
- 
-+LZ4_FORCE_INLINE void LZ4_prepareTable(
-+        LZ4_stream_t_internal* const cctx,
-+        const int inputSize,
-+        const tableType_t tableType) {
-+    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
-+     * therefore safe to use no matter what mode we're in. Otherwise, we figure
-+     * out if it's safe to leave as is or whether it needs to be reset.
-+     */
-+    if (cctx->tableType != clearedTable) {
-+        if (cctx->tableType != tableType
-+          || (tableType == byU16 && cctx->currentOffset + inputSize >= 0xFFFFU)
-+          || (tableType == byU32 && cctx->currentOffset > 1 GB)
-+          || tableType == byPtr
-+          || inputSize >= 4 KB)
-+        {
-+            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
-+            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
-+            cctx->currentOffset = 0;
-+            cctx->tableType = clearedTable;
-+        } else {
-+            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
-+        }
-+    }
-+
-+    /* Adding a gap, so all previous entries are > MAX_DISTANCE back, is faster
-+     * than compressing without a gap. However, compressing with
-+     * currentOffset == 0 is faster still, so we preserve that case.
-+     */
-+    if (cctx->currentOffset != 0 && tableType == byU32) {
-+        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
-+        cctx->currentOffset += 64 KB;
-+    }
-+
-+    /* Finally, clear history */
-+    cctx->dictCtx = NULL;
-+    cctx->dictionary = NULL;
-+    cctx->dictSize = 0;
-+}
- 
- /** LZ4_compress_generic() :
-     inlined, to ensure branches are decided at compilation time */
- LZ4_FORCE_INLINE int LZ4_compress_generic(
-                  LZ4_stream_t_internal* const cctx,
-                  const char* const source,
-                  char* const dest,
-                  const int inputSize,
-+                 int *inputConsumed, /* only written when outputLimited == fillOutput */
-                  const int maxOutputSize,
-                  const limitedOutput_directive outputLimited,
-                  const tableType_t tableType,
--                 const dict_directive dict,
-+                 const dict_directive dictDirective,
-                  const dictIssue_directive dictIssue,
-                  const U32 acceleration)
- {
-     const BYTE* ip = (const BYTE*) source;
--    const BYTE* base;
-+
-+    U32 const startIndex = cctx->currentOffset;
-+    const BYTE* base = (const BYTE*) source - startIndex;
-     const BYTE* lowLimit;
--    const BYTE* const lowRefLimit = ip - cctx->dictSize;
--    const BYTE* const dictionary = cctx->dictionary;
--    const BYTE* const dictEnd = dictionary + cctx->dictSize;
--    const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;
-+
-+    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
-+    const BYTE* const dictionary =
-+        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
-+    const U32 dictSize =
-+        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
-+    const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with index in current context */
-+
-+    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
-+    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
-+    const BYTE* const dictEnd = dictionary + dictSize;
-     const BYTE* anchor = (const BYTE*) source;
-     const BYTE* const iend = ip + inputSize;
--    const BYTE* const mflimit = iend - MFLIMIT;
-+    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
-     const BYTE* const matchlimit = iend - LASTLITERALS;
- 
-+    /* the dictCtx currentOffset is indexed on the start of the dictionary,
-+     * while a dictionary in the current context precedes the currentOffset */
-+    const BYTE* dictBase = dictDirective == usingDictCtx ?
-+        dictionary + dictSize - dictCtx->currentOffset :
-+        dictionary + dictSize - startIndex;
-+
-     BYTE* op = (BYTE*) dest;
-     BYTE* const olimit = op + maxOutputSize;
- 
-+    U32 offset = 0;
-     U32 forwardH;
- 
-+    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, tableType=%u", inputSize, tableType);
-     /* Init conditions */
-+    if (outputLimited == fillOutput && maxOutputSize < 1) return 0; /* Impossible to store anything */
-     if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;   /* Unsupported inputSize, too large (or negative) */
--    switch(dict)
--    {
--    case noDict:
--    default:
--        base = (const BYTE*)source;
--        lowLimit = (const BYTE*)source;
--        break;
--    case withPrefix64k:
--        base = (const BYTE*)source - cctx->currentOffset;
--        lowLimit = (const BYTE*)source - cctx->dictSize;
--        break;
--    case usingExtDict:
--        base = (const BYTE*)source - cctx->currentOffset;
--        lowLimit = (const BYTE*)source;
--        break;
-+    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;  /* Size too large (not within 64K limit) */
-+    if (tableType==byPtr) assert(dictDirective==noDict);      /* only supported use case with byPtr */
-+    assert(acceleration >= 1);
-+
-+    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
-+
-+    /* Update context state */
-+    if (dictDirective == usingDictCtx) {
-+        /* Subsequent linked blocks can't use the dictionary. */
-+        /* Instead, they use the block we just compressed. */
-+        cctx->dictCtx = NULL;
-+        cctx->dictSize = (U32)inputSize;
-+    } else {
-+        cctx->dictSize += (U32)inputSize;
-     }
--    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
--    if (inputSize<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
-+    cctx->currentOffset += (U32)inputSize;
-+    cctx->tableType = tableType;
-+
-+    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
- 
-     /* First Byte */
-     LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-     ip++; forwardH = LZ4_hashPosition(ip, tableType);
- 
-     /* Main Loop */
-     for ( ; ; ) {
--        ptrdiff_t refDelta = 0;
-         const BYTE* match;
-         BYTE* token;
- 
-         /* Find a match */
--        {   const BYTE* forwardIp = ip;
-+        if (tableType == byPtr) {
-+            const BYTE* forwardIp = ip;
-             unsigned step = 1;
-             unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
-             do {
-                 U32 const h = forwardH;
-                 ip = forwardIp;
-                 forwardIp += step;
-                 step = (searchMatchNb++ >> LZ4_skipTrigger);
- 
--                if (unlikely(forwardIp > mflimit)) goto _last_literals;
-+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-+                assert(ip < mflimitPlusOne);
- 
-                 match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
--                if (dict==usingExtDict) {
--                    if (match < (const BYTE*)source) {
--                        refDelta = dictDelta;
--                        lowLimit = dictionary;
--                    } else {
--                        refDelta = 0;
--                        lowLimit = (const BYTE*)source;
--                }   }
-                 forwardH = LZ4_hashPosition(forwardIp, tableType);
-                 LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
- 
--            } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0)
--                || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
--                || (LZ4_read32(match+refDelta) != LZ4_read32(ip)) );
-+            } while ( (match+MAX_DISTANCE < ip)
-+                   || (LZ4_read32(match) != LZ4_read32(ip)) );
-+
-+        } else {   /* byU32, byU16 */
-+
-+            const BYTE* forwardIp = ip;
-+            unsigned step = 1;
-+            unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
-+            do {
-+                U32 const h = forwardH;
-+                U32 const current = (U32)(forwardIp - base);
-+                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-+                assert(matchIndex <= current);
-+                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
-+                ip = forwardIp;
-+                forwardIp += step;
-+                step = (searchMatchNb++ >> LZ4_skipTrigger);
-+
-+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-+                assert(ip < mflimitPlusOne);
-+
-+                if (dictDirective == usingDictCtx) {
-+                    if (matchIndex < startIndex) {
-+                        /* there was no match, try the dictionary */
-+                        assert(tableType == byU32);
-+                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-+                        match = dictBase + matchIndex;
-+                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
-+                        lowLimit = dictionary;
-+                    } else {
-+                        match = base + matchIndex;
-+                        lowLimit = (const BYTE*)source;
-+                    }
-+                } else if (dictDirective==usingExtDict) {
-+                    if (matchIndex < startIndex) {
-+                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
-+                        assert(startIndex - matchIndex >= MINMATCH);
-+                        match = dictBase + matchIndex;
-+                        lowLimit = dictionary;
-+                    } else {
-+                        match = base + matchIndex;
-+                        lowLimit = (const BYTE*)source;
-+                    }
-+                } else {   /* single continuous memory segment */
-+                    match = base + matchIndex;
-+                }
-+                forwardH = LZ4_hashPosition(forwardIp, tableType);
-+                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-+
-+                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) continue;    /* match outside of valid area */
-+                assert(matchIndex < current);
-+                if ((tableType != byU16) && (matchIndex+MAX_DISTANCE < current)) continue;  /* too far */
-+                if (tableType == byU16) assert((current - matchIndex) <= MAX_DISTANCE);     /* too_far presumed impossible with byU16 */
-+
-+                if (LZ4_read32(match) == LZ4_read32(ip)) {
-+                    if (maybe_extMem) offset = current - matchIndex;
-+                    break;   /* match found */
-+                }
-+
-+            } while(1);
-         }
- 
-         /* Catch up */
--        while (((ip>anchor) & (match+refDelta > lowLimit)) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; }
-+        while (((ip>anchor) & (match > lowLimit)) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
- 
-         /* Encode Literals */
-         {   unsigned const litLength = (unsigned)(ip - anchor);
-             token = op++;
--            if ((outputLimited) &&  /* Check output buffer overflow */
-+            if ((outputLimited == limitedOutput) &&  /* Check output buffer overflow */
-                 (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)))
-                 return 0;
-+            if ((outputLimited == fillOutput) &&
-+                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
-+                op--;
-+                goto _last_literals;
-+            }
-             if (litLength >= RUN_MASK) {
-                 int len = (int)litLength-RUN_MASK;
-                 *token = (RUN_MASK<<ML_BITS);
-                 for(; len >= 255 ; len-=255) *op++ = 255;
-                 *op++ = (BYTE)len;
-             }
-             else *token = (BYTE)(litLength<<ML_BITS);
- 
-             /* Copy Literals */
-             LZ4_wildCopy(op, anchor, op+litLength);
-             op+=litLength;
-+            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-+                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
-         }
- 
- _next_match:
-+        /* at this stage, the following variables must be correctly set :
-+         * - ip : at start of LZ operation
-+         * - match : at start of previous pattern occurence; can be within current prefix, or within extDict
-+         * - offset : if maybe_ext_memSegment==1 (constant)
-+         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
-+         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
-+         */
-+
-+        if ((outputLimited == fillOutput) &&
-+            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
-+            /* the match was too close to the end, rewind and go to last literals */
-+            op = token;
-+            goto _last_literals;
-+        }
-+
-         /* Encode Offset */
--        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
-+        if (maybe_extMem) {   /* static test */
-+            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
-+            assert(offset <= MAX_DISTANCE && offset > 0);
-+            LZ4_writeLE16(op, (U16)offset); op+=2;
-+        } else  {
-+            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
-+            assert(ip-match <= MAX_DISTANCE);
-+            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
-+        }
- 
-         /* Encode MatchLength */
-         {   unsigned matchCode;
- 
--            if ((dict==usingExtDict) && (lowLimit==dictionary)) {
--                const BYTE* limit;
--                match += refDelta;
--                limit = ip + (dictEnd-match);
-+            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
-+              && (lowLimit==dictionary) /* match within extDict */ ) {
-+                const BYTE* limit = ip + (dictEnd-match);
-+                assert(dictEnd > match);
-                 if (limit > matchlimit) limit = matchlimit;
-                 matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-                 ip += MINMATCH + matchCode;
-                 if (ip==limit) {
--                    unsigned const more = LZ4_count(ip, (const BYTE*)source, matchlimit);
-+                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
-                     matchCode += more;
-                     ip += more;
-                 }
-+                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
-             } else {
-                 matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-                 ip += MINMATCH + matchCode;
-+                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
-             }
- 
--            if ( outputLimited &&    /* Check output buffer overflow */
--                (unlikely(op + (1 + LASTLITERALS) + (matchCode>>8) > olimit)) )
--                return 0;
-+            if ((outputLimited) &&    /* Check output buffer overflow */
-+                (unlikely(op + (1 + LASTLITERALS) + (matchCode>>8) > olimit)) ) {
-+                if (outputLimited == limitedOutput)
-+                  return 0;
-+                if (outputLimited == fillOutput) {
-+                    /* Match description too long : reduce it */
-+                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 2 - 1 - LASTLITERALS) * 255;
-+                    ip -= matchCode - newMatchCode;
-+                    matchCode = newMatchCode;
-+                }
-+            }
-             if (matchCode >= ML_MASK) {
-                 *token += ML_MASK;
-                 matchCode -= ML_MASK;
-                 LZ4_write32(op, 0xFFFFFFFF);
-                 while (matchCode >= 4*255) {
-                     op+=4;
-                     LZ4_write32(op, 0xFFFFFFFF);
-                     matchCode -= 4*255;
-@@ -680,94 +894,190 @@ LZ4_FORCE_INLINE int LZ4_compress_generi
-                 *op++ = (BYTE)(matchCode % 255);
-             } else
-                 *token += (BYTE)(matchCode);
-         }
- 
-         anchor = ip;
- 
-         /* Test end of chunk */
--        if (ip > mflimit) break;
-+        if (ip >= mflimitPlusOne) break;
- 
-         /* Fill table */
-         LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
- 
-         /* Test next position */
--        match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
--        if (dict==usingExtDict) {
--            if (match < (const BYTE*)source) {
--                refDelta = dictDelta;
--                lowLimit = dictionary;
--            } else {
--                refDelta = 0;
--                lowLimit = (const BYTE*)source;
--        }   }
--        LZ4_putPosition(ip, cctx->hashTable, tableType, base);
--        if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1)
--            && (match+MAX_DISTANCE>=ip)
--            && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) )
--        { token=op++; *token=0; goto _next_match; }
-+        if (tableType == byPtr) {
-+
-+            match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
-+            LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-+            if ( (match+MAX_DISTANCE >= ip)
-+              && (LZ4_read32(match) == LZ4_read32(ip)) )
-+            { token=op++; *token=0; goto _next_match; }
-+
-+        } else {   /* byU32, byU16 */
-+
-+            U32 const h = LZ4_hashPosition(ip, tableType);
-+            U32 const current = (U32)(ip-base);
-+            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-+            assert(matchIndex < current);
-+            if (dictDirective == usingDictCtx) {
-+                if (matchIndex < startIndex) {
-+                    /* there was no match, try the dictionary */
-+                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-+                    match = dictBase + matchIndex;
-+                    lowLimit = dictionary;   /* required for match length counter */
-+                    matchIndex += dictDelta;
-+                } else {
-+                    match = base + matchIndex;
-+                    lowLimit = (const BYTE*)source;  /* required for match length counter */
-+                }
-+            } else if (dictDirective==usingExtDict) {
-+                if (matchIndex < startIndex) {
-+                    match = dictBase + matchIndex;
-+                    lowLimit = dictionary;   /* required for match length counter */
-+                } else {
-+                    match = base + matchIndex;
-+                    lowLimit = (const BYTE*)source;   /* required for match length counter */
-+                }
-+            } else {   /* single memory segment */
-+                match = base + matchIndex;
-+            }
-+            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-+            assert(matchIndex < current);
-+            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
-+              && ((tableType==byU16) ? 1 : (matchIndex+MAX_DISTANCE >= current))
-+              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
-+                token=op++;
-+                *token=0;
-+                if (maybe_extMem) offset = current - matchIndex;
-+                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-+                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
-+                goto _next_match;
-+            }
-+        }
- 
-         /* Prepare next loop */
-         forwardH = LZ4_hashPosition(++ip, tableType);
-+
-     }
- 
- _last_literals:
-     /* Encode Last Literals */
--    {   size_t const lastRun = (size_t)(iend - anchor);
-+    {   size_t lastRun = (size_t)(iend - anchor);
-         if ( (outputLimited) &&  /* Check output buffer overflow */
--            ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) )
--            return 0;
-+            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
-+            if (outputLimited == fillOutput) {
-+                /* adapt lastRun to fill 'dst' */
-+                lastRun  = (olimit-op) - 1;
-+                lastRun -= (lastRun+240)/255;
-+            }
-+            if (outputLimited == limitedOutput)
-+                return 0;
-+        }
-         if (lastRun >= RUN_MASK) {
-             size_t accumulator = lastRun - RUN_MASK;
-             *op++ = RUN_MASK << ML_BITS;
-             for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-             *op++ = (BYTE) accumulator;
-         } else {
-             *op++ = (BYTE)(lastRun<<ML_BITS);
-         }
-         memcpy(op, anchor, lastRun);
-+        ip = anchor + lastRun;
-         op += lastRun;
-     }
- 
--    /* End */
--    return (int) (((char*)op)-dest);
-+    if (outputLimited == fillOutput) {
-+        *inputConsumed = (int) (((const char*)ip)-source);
-+    }
-+    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, (int)(((char*)op) - dest));
-+    return (int)(((char*)op) - dest);
- }
- 
- 
- int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
- {
-     LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-+    if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
-     LZ4_resetStream((LZ4_stream_t*)state);
-+    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-+        if (inputSize < LZ4_64Klimit) {
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
-+        } else {
-+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > MAX_DISTANCE)) ? byPtr : byU32;
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-+        }
-+    } else {
-+        if (inputSize < LZ4_64Klimit) {;
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
-+        } else {
-+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > MAX_DISTANCE)) ? byPtr : byU32;
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-+        }
-+    }
-+}
-+
-+/**
-+ * LZ4_compress_fast_extState_fastReset() :
-+ * A variant of LZ4_compress_fast_extState().
-+ *
-+ * Using this variant avoids an expensive initialization step. It is only safe
-+ * to call if the state buffer is known to be correctly initialized already
-+ * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
-+ * "correctly initialized").
-+ */
-+int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
-+{
-+    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-     if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
- 
--    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
--        if (inputSize < LZ4_64Klimit)
--            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited,                        byU16, noDict, noDictIssue, acceleration);
--        else
--            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-+    if (dstCapacity >= LZ4_compressBound(srcSize)) {
-+        if (srcSize < LZ4_64Klimit) {
-+            const tableType_t tableType = byU16;
-+            LZ4_prepareTable(ctx, srcSize, tableType);
-+            if (ctx->currentOffset) {
-+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
-+            } else {
-+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-+            }
-+        } else {
-+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > MAX_DISTANCE)) ? byPtr : byU32;
-+            LZ4_prepareTable(ctx, srcSize, tableType);
-+            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-+        }
-     } else {
--        if (inputSize < LZ4_64Klimit)
--            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput,                        byU16, noDict, noDictIssue, acceleration);
--        else
--            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-+        if (srcSize < LZ4_64Klimit) {
-+            const tableType_t tableType = byU16;
-+            LZ4_prepareTable(ctx, srcSize, tableType);
-+            if (ctx->currentOffset) {
-+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
-+            } else {
-+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-+            }
-+        } else {
-+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > MAX_DISTANCE)) ? byPtr : byU32;
-+            LZ4_prepareTable(ctx, srcSize, tableType);
-+            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-+        }
-     }
- }
- 
- 
- int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
- {
-+    int result;
- #if (LZ4_HEAPMODE)
--    void* ctxPtr = ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-+    LZ4_stream_t* ctxPtr = ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-+    if (ctxPtr == NULL) return 0;
- #else
-     LZ4_stream_t ctx;
--    void* const ctxPtr = &ctx;
-+    LZ4_stream_t* const ctxPtr = &ctx;
- #endif
--
--    int const result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
-+    result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
- 
- #if (LZ4_HEAPMODE)
-     FREEMEM(ctxPtr);
- #endif
-     return result;
- }
- 
- 
-@@ -780,201 +1090,46 @@ int LZ4_compress_default(const char* sou
- /* hidden debug function */
- /* strangely enough, gcc generates faster code when this function is uncommented, even if unused */
- int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
- {
-     LZ4_stream_t ctx;
-     LZ4_resetStream(&ctx);
- 
-     if (inputSize < LZ4_64Klimit)
--        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16,                        noDict, noDictIssue, acceleration);
-+        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16,                        noDict, noDictIssue, acceleration);
-     else
--        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-+        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
- }
- 
- 
--/*-******************************
--*  *_destSize() variant
--********************************/
--
--static int LZ4_compress_destSize_generic(
--                       LZ4_stream_t_internal* const ctx,
--                 const char* const src,
--                       char* const dst,
--                       int*  const srcSizePtr,
--                 const int targetDstSize,
--                 const tableType_t tableType)
--{
--    const BYTE* ip = (const BYTE*) src;
--    const BYTE* base = (const BYTE*) src;
--    const BYTE* lowLimit = (const BYTE*) src;
--    const BYTE* anchor = ip;
--    const BYTE* const iend = ip + *srcSizePtr;
--    const BYTE* const mflimit = iend - MFLIMIT;
--    const BYTE* const matchlimit = iend - LASTLITERALS;
--
--    BYTE* op = (BYTE*) dst;
--    BYTE* const oend = op + targetDstSize;
--    BYTE* const oMaxLit = op + targetDstSize - 2 /* offset */ - 8 /* because 8+MINMATCH==MFLIMIT */ - 1 /* token */;
--    BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
--    BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
--
--    U32 forwardH;
--
--
--    /* Init conditions */
--    if (targetDstSize < 1) return 0;                                     /* Impossible to store anything */
--    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;            /* Unsupported input size, too large (or negative) */
--    if ((tableType == byU16) && (*srcSizePtr>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
--    if (*srcSizePtr<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
--
--    /* First Byte */
--    *srcSizePtr = 0;
--    LZ4_putPosition(ip, ctx->hashTable, tableType, base);
--    ip++; forwardH = LZ4_hashPosition(ip, tableType);
--
--    /* Main Loop */
--    for ( ; ; ) {
--        const BYTE* match;
--        BYTE* token;
--
--        /* Find a match */
--        {   const BYTE* forwardIp = ip;
--            unsigned step = 1;
--            unsigned searchMatchNb = 1 << LZ4_skipTrigger;
--
--            do {
--                U32 h = forwardH;
--                ip = forwardIp;
--                forwardIp += step;
--                step = (searchMatchNb++ >> LZ4_skipTrigger);
--
--                if (unlikely(forwardIp > mflimit)) goto _last_literals;
--
--                match = LZ4_getPositionOnHash(h, ctx->hashTable, tableType, base);
--                forwardH = LZ4_hashPosition(forwardIp, tableType);
--                LZ4_putPositionOnHash(ip, h, ctx->hashTable, tableType, base);
--
--            } while ( ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
--                || (LZ4_read32(match) != LZ4_read32(ip)) );
--        }
--
--        /* Catch up */
--        while ((ip>anchor) && (match > lowLimit) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
--
--        /* Encode Literal length */
--        {   unsigned litLength = (unsigned)(ip - anchor);
--            token = op++;
--            if (op + ((litLength+240)/255) + litLength > oMaxLit) {
--                /* Not enough space for a last match */
--                op--;
--                goto _last_literals;
--            }
--            if (litLength>=RUN_MASK) {
--                unsigned len = litLength - RUN_MASK;
--                *token=(RUN_MASK<<ML_BITS);
--                for(; len >= 255 ; len-=255) *op++ = 255;
--                *op++ = (BYTE)len;
--            }
--            else *token = (BYTE)(litLength<<ML_BITS);
--
--            /* Copy Literals */
--            LZ4_wildCopy(op, anchor, op+litLength);
--            op += litLength;
--        }
--
--_next_match:
--        /* Encode Offset */
--        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
--
--        /* Encode MatchLength */
--        {   size_t matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
--
--            if (op + ((matchLength+240)/255) > oMaxMatch) {
--                /* Match description too long : reduce it */
--                matchLength = (15-1) + (oMaxMatch-op) * 255;
--            }
--            ip += MINMATCH + matchLength;
--
--            if (matchLength>=ML_MASK) {
--                *token += ML_MASK;
--                matchLength -= ML_MASK;
--                while (matchLength >= 255) { matchLength-=255; *op++ = 255; }
--                *op++ = (BYTE)matchLength;
--            }
--            else *token += (BYTE)(matchLength);
--        }
--
--        anchor = ip;
--
--        /* Test end of block */
--        if (ip > mflimit) break;
--        if (op > oMaxSeq) break;
--
--        /* Fill table */
--        LZ4_putPosition(ip-2, ctx->hashTable, tableType, base);
--
--        /* Test next position */
--        match = LZ4_getPosition(ip, ctx->hashTable, tableType, base);
--        LZ4_putPosition(ip, ctx->hashTable, tableType, base);
--        if ( (match+MAX_DISTANCE>=ip)
--            && (LZ4_read32(match)==LZ4_read32(ip)) )
--        { token=op++; *token=0; goto _next_match; }
--
--        /* Prepare next loop */
--        forwardH = LZ4_hashPosition(++ip, tableType);
--    }
--
--_last_literals:
--    /* Encode Last Literals */
--    {   size_t lastRunSize = (size_t)(iend - anchor);
--        if (op + 1 /* token */ + ((lastRunSize+240)/255) /* litLength */ + lastRunSize /* literals */ > oend) {
--            /* adapt lastRunSize to fill 'dst' */
--            lastRunSize  = (oend-op) - 1;
--            lastRunSize -= (lastRunSize+240)/255;
--        }
--        ip = anchor + lastRunSize;
--
--        if (lastRunSize >= RUN_MASK) {
--            size_t accumulator = lastRunSize - RUN_MASK;
--            *op++ = RUN_MASK << ML_BITS;
--            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
--            *op++ = (BYTE) accumulator;
--        } else {
--            *op++ = (BYTE)(lastRunSize<<ML_BITS);
--        }
--        memcpy(op, anchor, lastRunSize);
--        op += lastRunSize;
--    }
--
--    /* End */
--    *srcSizePtr = (int) (((const char*)ip)-src);
--    return (int) (((char*)op)-dst);
--}
--
--
-+/* Note!: This function leaves the stream in an unclean/broken state!
-+ * It is not safe to subsequently use the same state with a _fastReset() or
-+ * _continue() call without resetting it. */
- static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
- {
-     LZ4_resetStream(state);
- 
-     if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-         return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
-     } else {
--        if (*srcSizePtr < LZ4_64Klimit)
--            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16);
--        else
--            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr);
--    }
-+        if (*srcSizePtr < LZ4_64Klimit) {
-+            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, 1);
-+        } else {
-+            tableType_t const tableType = ((sizeof(void*)==4) && ((uptrval)src > MAX_DISTANCE)) ? byPtr : byU32;
-+            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, tableType, noDict, noDictIssue, 1);
-+    }   }
- }
- 
- 
- int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
- {
- #if (LZ4_HEAPMODE)
--    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-+    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-+    if (ctx == NULL) return 0;
- #else
-     LZ4_stream_t ctxBody;
-     LZ4_stream_t* ctx = &ctxBody;
- #endif
- 
-     int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
- 
- #if (LZ4_HEAPMODE)
-@@ -986,151 +1141,210 @@ int LZ4_compress_destSize(const char* sr
- 
- 
- /*-******************************
- *  Streaming functions
- ********************************/
- 
- LZ4_stream_t* LZ4_createStream(void)
- {
--    LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
-+    LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
-     LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
-+    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
-+    if (lz4s == NULL) return NULL;
-     LZ4_resetStream(lz4s);
-     return lz4s;
- }
- 
- void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
- {
--    DEBUGLOG(4, "LZ4_resetStream");
-+    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
-     MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
- }
- 
-+void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
-+    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
-+}
-+
- int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
- {
-     if (!LZ4_stream) return 0;   /* support free on NULL */
-+    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
-     FREEMEM(LZ4_stream);
-     return (0);
- }
- 
- 
- #define HASH_UNIT sizeof(reg_t)
- int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
- {
-     LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
-+    const tableType_t tableType = byU32;
-     const BYTE* p = (const BYTE*)dictionary;
-     const BYTE* const dictEnd = p + dictSize;
-     const BYTE* base;
- 
--    if ((dict->initCheck) || (dict->currentOffset > 1 GB))  /* Uninitialized structure, or reuse overflow */
--        LZ4_resetStream(LZ4_dict);
-+    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
-+
-+    /* It's necessary to reset the context,
-+     * and not just continue it with prepareTable()
-+     * to avoid any risk of generating overflowing matchIndex
-+     * when compressing using this dictionary */
-+    LZ4_resetStream(LZ4_dict);
-+
-+    /* We always increment the offset by 64 KB, since, if the dict is longer,
-+     * we truncate it to the last 64k, and if it's shorter, we still want to
-+     * advance by a whole window length so we can provide the guarantee that
-+     * there are only valid offsets in the window, which allows an optimization
-+     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
-+     * dictionary isn't a full 64k. */
-+
-+    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-+    base = dictEnd - 64 KB - dict->currentOffset;
-+    dict->dictionary = p;
-+    dict->dictSize = (U32)(dictEnd - p);
-+    dict->currentOffset += 64 KB;
-+    dict->tableType = tableType;
- 
-     if (dictSize < (int)HASH_UNIT) {
--        dict->dictionary = NULL;
--        dict->dictSize = 0;
-         return 0;
-     }
- 
--    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
--    dict->currentOffset += 64 KB;
--    base = p - dict->currentOffset;
--    dict->dictionary = p;
--    dict->dictSize = (U32)(dictEnd - p);
--    dict->currentOffset += dict->dictSize;
--
-     while (p <= dictEnd-HASH_UNIT) {
--        LZ4_putPosition(p, dict->hashTable, byU32, base);
-+        LZ4_putPosition(p, dict->hashTable, tableType, base);
-         p+=3;
-     }
- 
-     return dict->dictSize;
- }
- 
-+void LZ4_attach_dictionary(LZ4_stream_t *working_stream, const LZ4_stream_t *dictionary_stream) {
-+    if (dictionary_stream != NULL) {
-+        /* If the current offset is zero, we will never look in the
-+         * external dictionary context, since there is no value a table
-+         * entry can take that indicate a miss. In that case, we need
-+         * to bump the offset to something non-zero.
-+         */
-+        if (working_stream->internal_donotuse.currentOffset == 0) {
-+            working_stream->internal_donotuse.currentOffset = 64 KB;
-+        }
-+        working_stream->internal_donotuse.dictCtx = &(dictionary_stream->internal_donotuse);
-+    } else {
-+        working_stream->internal_donotuse.dictCtx = NULL;
-+    }
-+}
- 
--static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
-+
-+static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
- {
--    if ((LZ4_dict->currentOffset > 0x80000000) ||
--        ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) {   /* address space overflow */
-+    if (LZ4_dict->currentOffset + nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
-         /* rescale hash table */
-         U32 const delta = LZ4_dict->currentOffset - 64 KB;
-         const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-         int i;
-+        DEBUGLOG(4, "LZ4_renormDictT");
-         for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-             if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-             else LZ4_dict->hashTable[i] -= delta;
-         }
-         LZ4_dict->currentOffset = 64 KB;
-         if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-         LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-     }
- }
- 
- 
- int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
- {
-+    const tableType_t tableType = byU32;
-     LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
--    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-+    const BYTE* dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-+
-+    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i)", inputSize);
- 
--    const BYTE* smallest = (const BYTE*) source;
-     if (streamPtr->initCheck) return 0;   /* Uninitialized structure detected */
--    if ((streamPtr->dictSize>0) && (smallest>dictEnd)) smallest = dictEnd;
--    LZ4_renormDictT(streamPtr, smallest);
-+    LZ4_renormDictT(streamPtr, inputSize);   /* avoid index overflow */
-     if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
- 
-+    /* invalidate tiny dictionaries */
-+    if ( (streamPtr->dictSize-1 < 4)   /* intentional underflow */
-+      && (dictEnd != (const BYTE*)source) ) {
-+        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
-+        streamPtr->dictSize = 0;
-+        streamPtr->dictionary = (const BYTE*)source;
-+        dictEnd = (const BYTE*)source;
-+    }
-+
-     /* Check overlapping input/dictionary space */
-     {   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
-         if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-             streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-             if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-             if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-             streamPtr->dictionary = dictEnd - streamPtr->dictSize;
-         }
-     }
- 
-     /* prefix mode : source data follows dictionary */
-     if (dictEnd == (const BYTE*)source) {
--        int result;
-         if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
--            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
-+            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
-         else
--            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
--        streamPtr->dictSize += (U32)inputSize;
--        streamPtr->currentOffset += (U32)inputSize;
--        return result;
-+            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
-     }
- 
-     /* external dictionary mode */
-     {   int result;
--        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
--            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
--        else
--            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
-+        if (streamPtr->dictCtx) {
-+            /* We depend here on the fact that dictCtx'es (produced by
-+             * LZ4_loadDict) guarantee that their tables contain no references
-+             * to offsets between dictCtx->currentOffset - 64 KB and
-+             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
-+             * to use noDictIssue even when the dict isn't a full 64 KB.
-+             */
-+            if (inputSize > 4 KB) {
-+                /* For compressing large blobs, it is faster to pay the setup
-+                 * cost to copy the dictionary's tables into the active context,
-+                 * so that the compression loop is only looking into one table.
-+                 */
-+                memcpy(streamPtr, streamPtr->dictCtx, sizeof(LZ4_stream_t));
-+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-+            } else {
-+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
-+            }
-+        } else {
-+            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
-+            } else {
-+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-+            }
-+        }
-         streamPtr->dictionary = (const BYTE*)source;
-         streamPtr->dictSize = (U32)inputSize;
--        streamPtr->currentOffset += (U32)inputSize;
-         return result;
-     }
- }
- 
- 
--/* Hidden debug function, to force external dictionary mode */
--int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int inputSize)
-+/* Hidden debug function, to force-test external dictionary mode */
-+int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
- {
-     LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
-     int result;
--    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-+
-+    LZ4_renormDictT(streamPtr, srcSize);
- 
--    const BYTE* smallest = dictEnd;
--    if (smallest > (const BYTE*) source) smallest = (const BYTE*) source;
--    LZ4_renormDictT(streamPtr, smallest);
--
--    result = LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-+    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-+        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
-+    } else {
-+        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-+    }
- 
-     streamPtr->dictionary = (const BYTE*)source;
--    streamPtr->dictSize = (U32)inputSize;
--    streamPtr->currentOffset += (U32)inputSize;
-+    streamPtr->dictSize = (U32)srcSize;
- 
-     return result;
- }
- 
- 
- /*! LZ4_saveDict() :
-  *  If previously compressed data block is not guaranteed to remain available at its memory location,
-  *  save it into a safer place (char* safeBuffer).
-@@ -1191,51 +1405,82 @@ LZ4_FORCE_INLINE int LZ4_decompress_gene
- 
-     const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
-     const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
-     const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
- 
-     const int safeDecode = (endOnInput==endOnInputSize);
-     const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
- 
-+    /* Set up the "end" pointers for the shortcut. */
-+    const BYTE* const shortiend = iend - (endOnInput ? 14 : 8) /*maxLL*/ - 2 /*offset*/;
-+    const BYTE* const shortoend = oend - (endOnInput ? 14 : 8) /*maxLL*/ - 18 /*maxML*/;
-+
-+    DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i)", srcSize);
- 
-     /* Special cases */
-     if ((partialDecoding) && (oexit > oend-MFLIMIT)) oexit = oend-MFLIMIT;                      /* targetOutputSize too high => just decode everything */
-     if ((endOnInput) && (unlikely(outputSize==0))) return ((srcSize==1) && (*ip==0)) ? 0 : -1;  /* Empty output buffer */
-     if ((!endOnInput) && (unlikely(outputSize==0))) return (*ip==0?1:-1);
-+    if ((endOnInput) && unlikely(srcSize==0)) return -1;
- 
-     /* Main Loop : decode sequences */
-     while (1) {
--        size_t length;
-         const BYTE* match;
-         size_t offset;
- 
-         unsigned const token = *ip++;
-+        size_t length = token >> ML_BITS; /* literal length */
- 
--        /* shortcut for common case :
--         * in most circumstances, we expect to decode small matches (<= 18 bytes) separated by few literals (<= 14 bytes).
--         * this shortcut was tested on x86 and x64, where it improves decoding speed.
--         * it has not yet been benchmarked on ARM, Power, mips, etc. */
--        if (((ip + 14 /*maxLL*/ + 2 /*offset*/ <= iend)
--          & (op + 14 /*maxLL*/ + 18 /*maxML*/ <= oend))
--          & ((token < (15<<ML_BITS)) & ((token & ML_MASK) != 15)) ) {
--            size_t const ll = token >> ML_BITS;
--            size_t const off = LZ4_readLE16(ip+ll);
--            const BYTE* const matchPtr = op + ll - off;  /* pointer underflow risk ? */
--            if ((off >= 18) /* do not deal with overlapping matches */ & (matchPtr >= lowPrefix)) {
--                size_t const ml = (token & ML_MASK) + MINMATCH;
--                memcpy(op, ip, 16); op += ll; ip += ll + 2 /*offset*/;
--                memcpy(op, matchPtr, 18); op += ml;
-+        assert(!endOnInput || ip <= iend); /* ip < iend before the increment */
-+
-+        /* A two-stage shortcut for the most common case:
-+         * 1) If the literal length is 0..14, and there is enough space,
-+         * enter the shortcut and copy 16 bytes on behalf of the literals
-+         * (in the fast mode, only 8 bytes can be safely copied this way).
-+         * 2) Further if the match length is 4..18, copy 18 bytes in a similar
-+         * manner; but we ensure that there's enough space in the output for
-+         * those 18 bytes earlier, upon entering the shortcut (in other words,
-+         * there is a combined check for both stages).
-+         */
-+        if ( (endOnInput ? length != RUN_MASK : length <= 8)
-+            /* strictly "less than" on input, to re-enter the loop with at least one byte */
-+          && likely((endOnInput ? ip < shortiend : 1) & (op <= shortoend)) ) {
-+            /* Copy the literals */
-+            memcpy(op, ip, endOnInput ? 16 : 8);
-+            op += length; ip += length;
-+
-+            /* The second stage: prepare for match copying, decode full info.
-+             * If it doesn't work out, the info won't be wasted. */
-+            length = token & ML_MASK; /* match length */
-+            offset = LZ4_readLE16(ip); ip += 2;
-+            match = op - offset;
-+
-+            /* Do not deal with overlapping matches. */
-+            if ( (length != ML_MASK)
-+              && (offset >= 8)
-+              && (dict==withPrefix64k || match >= lowPrefix) ) {
-+                /* Copy the match. */
-+                memcpy(op + 0, match + 0, 8);
-+                memcpy(op + 8, match + 8, 8);
-+                memcpy(op +16, match +16, 2);
-+                op += length + MINMATCH;
-+                /* Both stages worked, load the next token. */
-                 continue;
-             }
-+
-+            /* The second stage didn't work out, but the info is ready.
-+             * Propel it right to the point of match copying. */
-+            goto _copy_match;
-         }
- 
-         /* decode literal length */
--        if ((length=(token>>ML_BITS)) == RUN_MASK) {
-+        if (length == RUN_MASK) {
-             unsigned s;
-+            if (unlikely(endOnInput ? ip >= iend-RUN_MASK : 0)) goto _output_error;   /* overflow detection */
-             do {
-                 s = *ip++;
-                 length += s;
-             } while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) & (s==255) );
-             if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) goto _output_error;   /* overflow detection */
-             if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) goto _output_error;   /* overflow detection */
-         }
- 
-@@ -1257,21 +1502,24 @@ LZ4_FORCE_INLINE int LZ4_decompress_gene
-             break;     /* Necessarily EOF, due to parsing restrictions */
-         }
-         LZ4_wildCopy(op, ip, cpy);
-         ip += length; op = cpy;
- 
-         /* get offset */
-         offset = LZ4_readLE16(ip); ip+=2;
-         match = op - offset;
-+
-+        /* get matchlength */
-+        length = token & ML_MASK;
-+
-+_copy_match:
-         if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
-         LZ4_write32(op, (U32)offset);   /* costs ~1%; silence an msan warning when offset==0 */
- 
--        /* get matchlength */
--        length = token & ML_MASK;
-         if (length == ML_MASK) {
-             unsigned s;
-             do {
-                 s = *ip++;
-                 if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
-                 length += s;
-             } while (s==255);
-             if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-@@ -1308,30 +1556,30 @@ LZ4_FORCE_INLINE int LZ4_decompress_gene
-         if (unlikely(offset<8)) {
-             op[0] = match[0];
-             op[1] = match[1];
-             op[2] = match[2];
-             op[3] = match[3];
-             match += inc32table[offset];
-             memcpy(op+4, match, 4);
-             match -= dec64table[offset];
--        } else { LZ4_copy8(op, match); match+=8; }
-+        } else { memcpy(op, match, 8); match+=8; }
-         op += 8;
- 
-         if (unlikely(cpy>oend-12)) {
-             BYTE* const oCopyLimit = oend-(WILDCOPYLENGTH-1);
-             if (cpy > oend-LASTLITERALS) goto _output_error;    /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-             if (op < oCopyLimit) {
-                 LZ4_wildCopy(op, match, oCopyLimit);
-                 match += oCopyLimit - op;
-                 op = oCopyLimit;
-             }
-             while (op<cpy) *op++ = *match++;
-         } else {
--            LZ4_copy8(op, match);
-+            memcpy(op, match, 8);
-             if (length>16) LZ4_wildCopy(op+8, match+8, cpy);
-         }
-         op = cpy;   /* correction */
-     }
- 
-     /* end of decoding */
-     if (endOnInput)
-        return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
-@@ -1339,226 +1587,329 @@ LZ4_FORCE_INLINE int LZ4_decompress_gene
-        return (int) (((const char*)ip)-src);   /* Nb of input bytes read */
- 
-     /* Overflow error detected */
- _output_error:
-     return (int) (-(((const char*)ip)-src))-1;
- }
- 
- 
-+/*===== Instantiate the API decoding functions. =====*/
-+
- LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
- {
--    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, full, 0, noDict, (BYTE*)dest, NULL, 0);
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
-+                                  endOnInputSize, full, 0, noDict,
-+                                  (BYTE*)dest, NULL, 0);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_safe_partial(const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize)
- {
--    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, partial, targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
-+                                  endOnInputSize, partial, targetOutputSize,
-+                                  noDict, (BYTE*)dest, NULL, 0);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
- {
--    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
-+    return LZ4_decompress_generic(source, dest, 0, originalSize,
-+                                  endOnOutputSize, full, 0, withPrefix64k,
-+                                  (BYTE*)dest - 64 KB, NULL, 0);
-+}
-+
-+/*===== Instantiate a few more decoding cases, used more than once. =====*/
-+
-+LZ4_FORCE_O2_GCC_PPC64LE /* Exported, an obsolete API function. */
-+int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                  endOnInputSize, full, 0, withPrefix64k,
-+                                  (BYTE*)dest - 64 KB, NULL, 0);
-+}
-+
-+/* Another obsolete API function, paired with the previous one. */
-+int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
-+{
-+    /* LZ4_decompress_fast doesn't validate match offsets,
-+     * and thus serves well with any prefixed dictionary. */
-+    return LZ4_decompress_fast(source, dest, originalSize);
-+}
-+
-+LZ4_FORCE_O2_GCC_PPC64LE
-+static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
-+                                               size_t prefixSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                  endOnInputSize, full, 0, noDict,
-+                                  (BYTE*)dest-prefixSize, NULL, 0);
- }
- 
-+LZ4_FORCE_O2_GCC_PPC64LE /* Exported under another name, for tests/fullbench.c */
-+#define LZ4_decompress_safe_extDict LZ4_decompress_safe_forceExtDict
-+int LZ4_decompress_safe_extDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
-+                                const void* dictStart, size_t dictSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                  endOnInputSize, full, 0, usingExtDict,
-+                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-+}
-+
-+LZ4_FORCE_O2_GCC_PPC64LE
-+static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
-+                                       const void* dictStart, size_t dictSize)
-+{
-+    return LZ4_decompress_generic(source, dest, 0, originalSize,
-+                                  endOnOutputSize, full, 0, usingExtDict,
-+                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-+}
-+
-+/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
-+ * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
-+ * These routines are used only once, in LZ4_decompress_*_continue().
-+ */
-+LZ4_FORCE_INLINE
-+int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
-+                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                  endOnInputSize, full, 0, usingExtDict,
-+                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-+}
-+
-+LZ4_FORCE_INLINE
-+int LZ4_decompress_fast_doubleDict(const char* source, char* dest, int originalSize,
-+                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-+{
-+    return LZ4_decompress_generic(source, dest, 0, originalSize,
-+                                  endOnOutputSize, full, 0, usingExtDict,
-+                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-+}
- 
- /*===== streaming decompression functions =====*/
- 
- LZ4_streamDecode_t* LZ4_createStreamDecode(void)
- {
--    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
-+    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
-     return lz4s;
- }
- 
- int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
- {
-     if (!LZ4_stream) return 0;   /* support free on NULL */
-     FREEMEM(LZ4_stream);
-     return 0;
- }
- 
--/*!
-- * LZ4_setStreamDecode() :
-- * Use this function to instruct where to find the dictionary.
-- * This function is not necessary if previous data is still available where it was decoded.
-- * Loading a size of 0 is allowed (same effect as no dictionary).
-- * Return : 1 if OK, 0 if error
-+/*! LZ4_setStreamDecode() :
-+ *  Use this function to instruct where to find the dictionary.
-+ *  This function is not necessary if previous data is still available where it was decoded.
-+ *  Loading a size of 0 is allowed (same effect as no dictionary).
-+ * @return : 1 if OK, 0 if error
-  */
- int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
- {
-     LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-     lz4sd->prefixSize = (size_t) dictSize;
-     lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-     lz4sd->externalDict = NULL;
-     lz4sd->extDictSize  = 0;
-     return 1;
- }
- 
-+/*! LZ4_decoderRingBufferSize() :
-+ *  when setting a ring buffer for streaming decompression (optional scenario),
-+ *  provides the minimum size of this ring buffer
-+ *  to be compatible with any source respecting maxBlockSize condition.
-+ *  Note : in a ring buffer scenario,
-+ *  blocks are presumed decompressed next to each other.
-+ *  When not enough space remains for next block (remainingSize < maxBlockSize),
-+ *  decoding resumes from beginning of ring buffer.
-+ * @return : minimum ring buffer size,
-+ *           or 0 if there is an error (invalid maxBlockSize).
-+ */
-+int LZ4_decoderRingBufferSize(int maxBlockSize)
-+{
-+    if (maxBlockSize < 0) return 0;
-+    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
-+    if (maxBlockSize < 16) maxBlockSize = 16;
-+    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
-+}
-+
- /*
- *_continue() :
-     These decoding functions allow decompression of multiple blocks in "streaming" mode.
-     Previously decoded blocks must still be available at the memory position where they were decoded.
-     If it's not possible, save the relevant part of decoded data into a safe buffer,
-     and indicate where it stands using LZ4_setStreamDecode()
- */
- LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
- {
-     LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-     int result;
- 
--    if (lz4sd->prefixEnd == (BYTE*)dest) {
--        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                        endOnInputSize, full, 0,
--                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-+    if (lz4sd->prefixSize == 0) {
-+        /* The first call, no dictionary yet. */
-+        assert(lz4sd->extDictSize == 0);
-+        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize = result;
-+        lz4sd->prefixEnd = (BYTE*)dest + result;
-+    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-+        /* They're rolling the current segment. */
-+        if (lz4sd->prefixSize >= 64 KB - 1)
-+            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-+        else if (lz4sd->extDictSize == 0)
-+            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
-+                                                         lz4sd->prefixSize);
-+        else
-+            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
-+                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-         if (result <= 0) return result;
-         lz4sd->prefixSize += result;
-         lz4sd->prefixEnd  += result;
-     } else {
-+        /* The buffer wraps around, or they're switching to another buffer. */
-         lz4sd->extDictSize = lz4sd->prefixSize;
-         lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
--        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                        endOnInputSize, full, 0,
--                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-+        result = LZ4_decompress_safe_extDict(source, dest, compressedSize, maxOutputSize,
-+                                             lz4sd->externalDict, lz4sd->extDictSize);
-         if (result <= 0) return result;
-         lz4sd->prefixSize = result;
-         lz4sd->prefixEnd  = (BYTE*)dest + result;
-     }
- 
-     return result;
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
- {
-     LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-     int result;
- 
--    if (lz4sd->prefixEnd == (BYTE*)dest) {
--        result = LZ4_decompress_generic(source, dest, 0, originalSize,
--                                        endOnOutputSize, full, 0,
--                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-+    if (lz4sd->prefixSize == 0) {
-+        assert(lz4sd->extDictSize == 0);
-+        result = LZ4_decompress_fast(source, dest, originalSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize = originalSize;
-+        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
-+    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-+        if (lz4sd->prefixSize >= 64 KB - 1 || lz4sd->extDictSize == 0)
-+            result = LZ4_decompress_fast(source, dest, originalSize);
-+        else
-+            result = LZ4_decompress_fast_doubleDict(source, dest, originalSize,
-+                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-         if (result <= 0) return result;
-         lz4sd->prefixSize += originalSize;
-         lz4sd->prefixEnd  += originalSize;
-     } else {
-         lz4sd->extDictSize = lz4sd->prefixSize;
-         lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
--        result = LZ4_decompress_generic(source, dest, 0, originalSize,
--                                        endOnOutputSize, full, 0,
--                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-+        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
-+                                             lz4sd->externalDict, lz4sd->extDictSize);
-         if (result <= 0) return result;
-         lz4sd->prefixSize = originalSize;
-         lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-     }
- 
-     return result;
- }
- 
- 
- /*
- Advanced decoding functions :
- *_usingDict() :
-     These decoding functions work the same as "_continue" ones,
-     the dictionary must be explicitly provided within parameters
- */
- 
--LZ4_FORCE_O2_GCC_PPC64LE
--LZ4_FORCE_INLINE int LZ4_decompress_usingDict_generic(const char* source, char* dest, int compressedSize, int maxOutputSize, int safe, const char* dictStart, int dictSize)
-+int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
- {
-     if (dictSize==0)
--        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
-+        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-     if (dictStart+dictSize == dest) {
--        if (dictSize >= (int)(64 KB - 1))
--            return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
--        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
-+        if (dictSize >= 64 KB - 1)
-+            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-+        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, dictSize);
-     }
--    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-+    return LZ4_decompress_safe_extDict(source, dest, compressedSize, maxOutputSize, dictStart, dictSize);
- }
- 
--LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
--{
--    return LZ4_decompress_usingDict_generic(source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
--}
--
--LZ4_FORCE_O2_GCC_PPC64LE
- int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
- {
--    return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0, dictStart, dictSize);
--}
--
--/* debug function */
--LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
--{
--    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-+    if (dictSize==0 || dictStart+dictSize == dest)
-+        return LZ4_decompress_fast(source, dest, originalSize);
-+    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, dictSize);
- }
- 
- 
- /*=*************************************************
- *  Obsolete Functions
- ***************************************************/
- /* obsolete compression functions */
--int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { return LZ4_compress_default(source, dest, inputSize, maxOutputSize); }
--int LZ4_compress(const char* source, char* dest, int inputSize) { return LZ4_compress_default(source, dest, inputSize, LZ4_compressBound(inputSize)); }
--int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1); }
--int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1); }
--int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, maxDstSize, 1); }
--int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize) { return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1); }
-+int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
-+{
-+    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
-+}
-+int LZ4_compress(const char* source, char* dest, int inputSize)
-+{
-+    return LZ4_compress_default(source, dest, inputSize, LZ4_compressBound(inputSize));
-+}
-+int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
-+{
-+    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
-+}
-+int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
-+{
-+    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
-+}
-+int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
-+{
-+    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
-+}
-+int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
-+{
-+    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
-+}
- 
- /*
--These function names are deprecated and should no longer be used.
-+These decompression functions are deprecated and should no longer be used.
- They are only provided here for compatibility with older user programs.
- - LZ4_uncompress is totally equivalent to LZ4_decompress_fast
- - LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
- */
--int LZ4_uncompress (const char* source, char* dest, int outputSize) { return LZ4_decompress_fast(source, dest, outputSize); }
--int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) { return LZ4_decompress_safe(source, dest, isize, maxOutputSize); }
--
-+int LZ4_uncompress (const char* source, char* dest, int outputSize)
-+{
-+    return LZ4_decompress_fast(source, dest, outputSize);
-+}
-+int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
-+{
-+    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
-+}
- 
- /* Obsolete Streaming functions */
- 
- int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
- 
--static void LZ4_init(LZ4_stream_t* lz4ds, BYTE* base)
--{
--    MEM_INIT(lz4ds, 0, sizeof(LZ4_stream_t));
--    lz4ds->internal_donotuse.bufferStart = base;
--}
--
- int LZ4_resetStreamState(void* state, char* inputBuffer)
- {
--    if ((((uptrval)state) & 3) != 0) return 1;   /* Error : pointer is not aligned on 4-bytes boundary */
--    LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer);
-+    (void)inputBuffer;
-+    LZ4_resetStream((LZ4_stream_t*)state);
-     return 0;
- }
- 
- void* LZ4_create (char* inputBuffer)
- {
--    LZ4_stream_t* lz4ds = (LZ4_stream_t*)ALLOCATOR(8, sizeof(LZ4_stream_t));
--    LZ4_init (lz4ds, (BYTE*)inputBuffer);
--    return lz4ds;
-+    (void)inputBuffer;
-+    return LZ4_createStream();
- }
- 
--char* LZ4_slideInputBuffer (void* LZ4_Data)
-+char* LZ4_slideInputBuffer (void* state)
- {
--    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)LZ4_Data)->internal_donotuse;
--    int dictSize = LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)ctx->bufferStart, 64 KB);
--    return (char*)(ctx->bufferStart + dictSize);
--}
--
--/* Obsolete streaming decompression functions */
--
--int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
--{
--    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
--}
--
--int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
--{
--    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
-+    /* avoid const char * -> char * conversion warning */
-+    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
- }
- 
- #endif   /* LZ4_COMMONDEFS_ONLY */
-diff --git a/mfbt/lz4.h b/mfbt/lz4.h
---- a/mfbt/lz4.h
-+++ b/mfbt/lz4.h
-@@ -88,98 +88,97 @@ extern "C" {
- #  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
- #else
- #  define LZ4LIB_API LZ4LIB_VISIBILITY
- #endif
- 
- /*------   Version   ------*/
- #define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
- #define LZ4_VERSION_MINOR    8    /* for new (non-breaking) interface capabilities */
--#define LZ4_VERSION_RELEASE  1    /* for tweaks, bug-fixes, or development */
-+#define LZ4_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */
- 
- #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
- 
- #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
- #define LZ4_QUOTE(str) #str
- #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
- #define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
- 
--LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; to be used when checking dll version */
--LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; to be used when checking dll version */
-+LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; useful to check dll version */
-+LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; unseful to check dll version */
- 
- 
- /*-************************************
- *  Tuning parameter
- **************************************/
- /*!
-  * LZ4_MEMORY_USAGE :
-  * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
-  * Increasing memory usage improves compression ratio
-- * Reduced memory usage can improve speed, due to cache effect
-+ * Reduced memory usage may improve speed, thanks to cache effect
-  * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
-  */
- #ifndef LZ4_MEMORY_USAGE
- # define LZ4_MEMORY_USAGE 14
- #endif
- 
- /*-************************************
- *  Simple Functions
- **************************************/
- /*! LZ4_compress_default() :
-     Compresses 'srcSize' bytes from buffer 'src'
-     into already allocated 'dst' buffer of size 'dstCapacity'.
-     Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
-     It also runs faster, so it's a recommended setting.
--    If the function cannot compress 'src' into a limited 'dst' budget,
-+    If the function cannot compress 'src' into a more limited 'dst' budget,
-     compression stops *immediately*, and the function result is zero.
--    As a consequence, 'dst' content is not valid.
--    This function never writes outside 'dst' buffer, nor read outside 'source' buffer.
--        srcSize : supported max value is LZ4_MAX_INPUT_VALUE
--        dstCapacity : full or partial size of buffer 'dst' (which must be already allocated)
-+    Note : as a consequence, 'dst' content is not valid.
-+    Note 2 : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
-+        srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
-+        dstCapacity : size of buffer 'dst' (which must be already allocated)
-         return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
-                   or 0 if compression fails */
- LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
- 
- /*! LZ4_decompress_safe() :
-     compressedSize : is the exact complete size of the compressed block.
-     dstCapacity : is the size of destination buffer, which must be already allocated.
-     return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
-              If destination buffer is not large enough, decoding will stop and output an error code (negative value).
-              If the source stream is detected malformed, the function will stop decoding and return a negative result.
--             This function is protected against buffer overflow exploits, including malicious data packets.
--             It never writes outside output buffer, nor reads outside input buffer.
-+             This function is protected against malicious data packets.
- */
- LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
- 
- 
- /*-************************************
- *  Advanced Functions
- **************************************/
- #define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
- #define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
- 
- /*!
- LZ4_compressBound() :
-     Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
-     This function is primarily useful for memory allocation purposes (destination buffer size).
-     Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
--    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
-+    Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
-         inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-         return : maximum output size in a "worst case" scenario
--              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
-+              or 0, if input size is incorrect (too large or negative)
- */
- LZ4LIB_API int LZ4_compressBound(int inputSize);
- 
- /*!
- LZ4_compress_fast() :
--    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
-+    Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
-     The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-     It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-     An acceleration value of "1" is the same as regular LZ4_compress_default()
--    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
-+    Values <= 0 will be replaced by ACCELERATION_DEFAULT (currently == 1, see lz4.c).
- */
- LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
- 
- 
- /*!
- LZ4_compress_fast_extState() :
-     Same compression function, just using an externally allocated memory space to store compression state.
-     Use LZ4_sizeofState() to know how much memory must be allocated,
-@@ -200,47 +199,51 @@ LZ4_compress_destSize() :
-                       New value is necessarily <= old value.
-         return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
-                  or 0 if compression fails
- */
- LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
- 
- 
- /*!
--LZ4_decompress_fast() : (unsafe!!)
--    originalSize : is the original uncompressed size
--    return : the number of bytes read from the source buffer (in other words, the compressed size)
--             If the source stream is detected malformed, the function will stop decoding and return a negative result.
--             Destination buffer must be already allocated. Its size must be >= 'originalSize' bytes.
--    note : This function respects memory boundaries for *properly formed* compressed data.
--           It is a bit faster than LZ4_decompress_safe().
--           However, it does not provide any protection against intentionally modified data stream (malicious input).
--           Use this function in trusted environment only (data to decode comes from a trusted source).
-+LZ4_decompress_fast() : **unsafe!**
-+This function is a bit faster than LZ4_decompress_safe(),
-+but it may misbehave on malformed input because it doesn't perform full validation of compressed data.
-+    originalSize : is the uncompressed size to regenerate
-+                   Destination buffer must be already allocated, and its size must be >= 'originalSize' bytes.
-+    return : number of bytes read from source buffer (== compressed size).
-+             If the source stream is detected malformed, the function stops decoding and return a negative result.
-+    note : This function is only usable if the originalSize of uncompressed data is known in advance.
-+           The caller should also check that all the compressed input has been consumed properly,
-+           i.e. that the return value matches the size of the buffer with compressed input.
-+           The function never writes past the output buffer.  However, since it doesn't know its 'src' size,
-+           it may read past the intended input.  Also, because match offsets are not validated during decoding,
-+           reads from 'src' may underflow.  Use this function in trusted environment **only**.
- */
- LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
- 
- /*!
- LZ4_decompress_safe_partial() :
-     This function decompress a compressed block of size 'srcSize' at position 'src'
-     into destination buffer 'dst' of size 'dstCapacity'.
-     The function will decompress a minimum of 'targetOutputSize' bytes, and stop after that.
--    However, it's not accurate, and may write more than 'targetOutputSize' (but <= dstCapacity).
-+    However, it's not accurate, and may write more than 'targetOutputSize' (but always <= dstCapacity).
-    @return : the number of bytes decoded in the destination buffer (necessarily <= dstCapacity)
--       Note : this number can be < 'targetOutputSize' should the compressed block contain less data.
--             Always control how many bytes were decoded.
--             If the source stream is detected malformed, the function will stop decoding and return a negative result.
--             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets.
-+        Note : this number can also be < targetOutputSize, if compressed block contains less data.
-+            Therefore, always control how many bytes were decoded.
-+            If source stream is detected malformed, function returns a negative result.
-+            This function is protected against malicious data packets.
- */
- LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
- 
- 
- /*-*********************************************
- *  Streaming Compression Functions
- ***********************************************/
--typedef union LZ4_stream_u LZ4_stream_t;   /* incomplete type (defined later) */
-+typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
- 
- /*! LZ4_createStream() and LZ4_freeStream() :
-  *  LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
-  *  LZ4_freeStream() releases its memory.
-  */
- LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
- LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
- 
-@@ -254,134 +257,253 @@ LZ4LIB_API void LZ4_resetStream (LZ4_str
-  *  Use this function to load a static dictionary into LZ4_stream_t.
-  *  Any previous data will be forgotten, only 'dictionary' will remain in memory.
-  *  Loading a size of 0 is allowed, and is the same as reset.
-  * @return : dictionary size, in bytes (necessarily <= 64 KB)
-  */
- LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
- 
- /*! LZ4_compress_fast_continue() :
-- *  Compress content into 'src' using data from previously compressed blocks, improving compression ratio.
-+ *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
-  *  'dst' buffer must be already allocated.
-  *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
-  *
-- *  Important : Up to 64KB of previously compressed data is assumed to remain present and unmodified in memory !
-- *  Special 1 : If input buffer is a double-buffer, it can have any size, including < 64 KB.
-- *  Special 2 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
-+ *  Important : The previous 64KB of compressed data is assumed to remain present and unmodified in memory!
-+ *
-+ *  Special 1 : When input is a double-buffer, they can have any size, including < 64 KB.
-+ *              Make sure that buffers are separated by at least one byte.
-+ *              This way, each block only depends on previous block.
-+ *  Special 2 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
-  *
-  * @return : size of compressed block
-- *           or 0 if there is an error (typically, compressed data cannot fit into 'dst')
-+ *           or 0 if there is an error (typically, cannot fit into 'dst').
-  *  After an error, the stream status is invalid, it can only be reset or freed.
-  */
- LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
- 
- /*! LZ4_saveDict() :
-- *  If previously compressed data block is not guaranteed to remain available at its current memory location,
-+ *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
-  *  save it into a safer place (char* safeBuffer).
-- *  Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(), dictionary is immediately usable.
-- *  @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
-+ *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
-+ *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
-+ * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
-  */
--LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
-+LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
- 
- 
- /*-**********************************************
- *  Streaming Decompression Functions
- *  Bufferless synchronous API
- ************************************************/
--typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* incomplete type (defined later) */
-+typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
- 
- /*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
-- *  creation / destruction of streaming decompression tracking structure.
-- *  A tracking structure can be re-used multiple times sequentially. */
-+ *  creation / destruction of streaming decompression tracking context.
-+ *  A tracking context can be re-used multiple times.
-+ */
- LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
- LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
- 
- /*! LZ4_setStreamDecode() :
-- *  An LZ4_streamDecode_t structure can be allocated once and re-used multiple times.
-+ *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
-  *  Use this function to start decompression of a new stream of blocks.
-- *  A dictionary can optionnally be set. Use NULL or size 0 for a simple reset order.
-+ *  A dictionary can optionnally be set. Use NULL or size 0 for a reset order.
-+ *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
-  * @return : 1 if OK, 0 if error
-  */
- LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
- 
-+/*! LZ4_decoderRingBufferSize() : v1.8.2
-+ *  Note : in a ring buffer scenario (optional),
-+ *  blocks are presumed decompressed next to each other
-+ *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
-+ *  at which stage it resumes from beginning of ring buffer.
-+ *  When setting such a ring buffer for streaming decompression,
-+ *  provides the minimum size of this ring buffer
-+ *  to be compatible with any source respecting maxBlockSize condition.
-+ * @return : minimum ring buffer size,
-+ *           or 0 if there is an error (invalid maxBlockSize).
-+ */
-+LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
-+#define LZ4_DECODER_RING_BUFFER_SIZE(mbs) (65536 + 14 + (mbs))  /* for static allocation; mbs presumed valid */
-+
- /*! LZ4_decompress_*_continue() :
-  *  These decoding functions allow decompression of consecutive blocks in "streaming" mode.
-  *  A block is an unsplittable entity, it must be presented entirely to a decompression function.
-- *  Decompression functions only accept one block at a time.
-- *  Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB).
-+ *  Decompression functions only accepts one block at a time.
-+ *  The last 64KB of previously decoded data *must* remain available and unmodified at the memory position where they were decoded.
-+ *  If less than 64KB of data has been decoded, all the data must be present.
-  *
-- *  Special : if application sets a ring buffer for decompression, it must respect one of the following conditions :
-- *  - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
-- *    In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
-- *  - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
-- *    maxBlockSize is implementation dependent. It's the maximum size of any single block.
-+ *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
-+ *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
-+ *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
-+ *    In which case, encoding and decoding buffers do not need to be synchronized.
-+ *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
-+ *  - Synchronized mode :
-+ *    Decompression buffer size is _exactly_ the same as compression buffer size,
-+ *    and follows exactly same update rule (block boundaries at same positions),
-+ *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
-+ *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
-+ *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
-  *    In which case, encoding and decoding buffers do not need to be synchronized,
-  *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
-- *  - _At least_ 64 KB + 8 bytes + maxBlockSize.
-- *    In which case, encoding and decoding buffers do not need to be synchronized,
-- *    and encoding ring buffer can have any size, including larger than decoding buffer.
-- *  Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
-- *  and indicate where it is saved using LZ4_setStreamDecode() before decompressing next block.
-+ *
-+ *  Whenever these conditions are not possible,
-+ *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
-+ *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
- */
- LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity);
- LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
- 
- 
- /*! LZ4_decompress_*_usingDict() :
-  *  These decoding functions work the same as
-  *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
-  *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
-+ *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
-  */
- LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize);
- LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
- 
- 
- /*^**********************************************
-  * !!!!!!   STATIC LINKING ONLY   !!!!!!
-  ***********************************************/
-+
-+/*-************************************
-+ *  Unstable declarations
-+ **************************************
-+ * Declarations in this section should be considered unstable.
-+ * Use at your own peril, etc., etc.
-+ * They may be removed in the future.
-+ * Their signatures may change.
-+ **************************************/
-+
-+#ifdef LZ4_STATIC_LINKING_ONLY
-+
-+/*! LZ4_resetStream_fast() :
-+ *  Use this, like LZ4_resetStream(), to prepare a context for a new chain of
-+ *  calls to a streaming API (e.g., LZ4_compress_fast_continue()).
-+ *
-+ *  Note:
-+ *  Using this in advance of a non- streaming-compression function is redundant,
-+ *  and potentially bad for performance, since they all perform their own custom
-+ *  reset internally.
-+ *
-+ *  Differences from LZ4_resetStream():
-+ *  When an LZ4_stream_t is known to be in a internally coherent state,
-+ *  it can often be prepared for a new compression with almost no work, only
-+ *  sometimes falling back to the full, expensive reset that is always required
-+ *  when the stream is in an indeterminate state (i.e., the reset performed by
-+ *  LZ4_resetStream()).
-+ *
-+ *  LZ4_streams are guaranteed to be in a valid state when:
-+ *  - returned from LZ4_createStream()
-+ *  - reset by LZ4_resetStream()
-+ *  - memset(stream, 0, sizeof(LZ4_stream_t)), though this is discouraged
-+ *  - the stream was in a valid state and was reset by LZ4_resetStream_fast()
-+ *  - the stream was in a valid state and was then used in any compression call
-+ *    that returned success
-+ *  - the stream was in an indeterminate state and was used in a compression
-+ *    call that fully reset the state (e.g., LZ4_compress_fast_extState()) and
-+ *    that returned success
-+ *
-+ *  When a stream isn't known to be in a valid state, it is not safe to pass to
-+ *  any fastReset or streaming function. It must first be cleansed by the full
-+ *  LZ4_resetStream().
-+ */
-+LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
-+
-+/*! LZ4_compress_fast_extState_fastReset() :
-+ *  A variant of LZ4_compress_fast_extState().
-+ *
-+ *  Using this variant avoids an expensive initialization step. It is only safe
-+ *  to call if the state buffer is known to be correctly initialized already
-+ *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly
-+ *  initialized"). From a high level, the difference is that this function
-+ *  initializes the provided state with a call to something like
-+ *  LZ4_resetStream_fast() while LZ4_compress_fast_extState() starts with a
-+ *  call to LZ4_resetStream().
-+ */
-+LZ4LIB_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-+
-+/*! LZ4_attach_dictionary() :
-+ *  This is an experimental API that allows for the efficient use of a
-+ *  static dictionary many times.
-+ *
-+ *  Rather than re-loading the dictionary buffer into a working context before
-+ *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
-+ *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
-+ *  in which the working stream references the dictionary stream in-place.
-+ *
-+ *  Several assumptions are made about the state of the dictionary stream.
-+ *  Currently, only streams which have been prepared by LZ4_loadDict() should
-+ *  be expected to work.
-+ *
-+ *  Alternatively, the provided dictionary stream pointer may be NULL, in which
-+ *  case any existing dictionary stream is unset.
-+ *
-+ *  If a dictionary is provided, it replaces any pre-existing stream history.
-+ *  The dictionary contents are the only history that can be referenced and
-+ *  logically immediately precede the data compressed in the first subsequent
-+ *  compression call.
-+ *
-+ *  The dictionary will only remain attached to the working stream through the
-+ *  first compression call, at the end of which it is cleared. The dictionary
-+ *  stream (and source buffer) must remain in-place / accessible / unchanged
-+ *  through the completion of the first compression call on the stream.
-+ */
-+LZ4LIB_API void LZ4_attach_dictionary(LZ4_stream_t *working_stream, const LZ4_stream_t *dictionary_stream);
-+
-+#endif
-+
- /*-************************************
-  *  Private definitions
-  **************************************
-  * Do not use these definitions.
-  * They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
-  * Using these definitions will expose code to API and/or ABI break in future versions of the library.
-  **************************************/
- #define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
- #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
- #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
- 
- #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
- #include <stdint.h>
- 
--typedef struct {
-+typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
-+struct LZ4_stream_t_internal {
-     uint32_t hashTable[LZ4_HASH_SIZE_U32];
-     uint32_t currentOffset;
--    uint32_t initCheck;
-+    uint16_t initCheck;
-+    uint16_t tableType;
-     const uint8_t* dictionary;
--    uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
-+    const LZ4_stream_t_internal* dictCtx;
-     uint32_t dictSize;
--} LZ4_stream_t_internal;
-+};
- 
- typedef struct {
-     const uint8_t* externalDict;
-     size_t extDictSize;
-     const uint8_t* prefixEnd;
-     size_t prefixSize;
- } LZ4_streamDecode_t_internal;
- 
- #else
- 
--typedef struct {
-+typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
-+struct LZ4_stream_t_internal {
-     unsigned int hashTable[LZ4_HASH_SIZE_U32];
-     unsigned int currentOffset;
--    unsigned int initCheck;
-+    unsigned short initCheck;
-+    unsigned short tableType;
-     const unsigned char* dictionary;
--    unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
-+    const LZ4_stream_t_internal* dictCtx;
-     unsigned int dictSize;
--} LZ4_stream_t_internal;
-+};
- 
- typedef struct {
-     const unsigned char* externalDict;
-     size_t extDictSize;
-     const unsigned char* prefixEnd;
-     size_t prefixSize;
- } LZ4_streamDecode_t_internal;
- 
-@@ -428,52 +550,58 @@ union LZ4_streamDecode_u {
-    it is generally possible to disable them,
-    typically with -Wno-deprecated-declarations for gcc
-    or _CRT_SECURE_NO_WARNINGS in Visual.
-    Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS */
- #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
- #  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
- #else
- #  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
--#  if defined(__clang__) /* clang doesn't handle mixed C++11 and CNU attributes */
--#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
--#  elif defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
- #    define LZ4_DEPRECATED(message) [[deprecated(message)]]
--#  elif (LZ4_GCC_VERSION >= 405)
-+#  elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
- #    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
- #  elif (LZ4_GCC_VERSION >= 301)
- #    define LZ4_DEPRECATED(message) __attribute__((deprecated))
- #  elif defined(_MSC_VER)
- #    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
- #  else
- #    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
- #    define LZ4_DEPRECATED(message)
- #  endif
- #endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
- 
- /* Obsolete compression functions */
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress               (const char* source, char* dest, int sourceSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-+LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress               (const char* source, char* dest, int sourceSize);
-+LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
-+LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-+LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-+LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-+LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
- 
- /* Obsolete decompression functions */
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast() instead") int LZ4_uncompress (const char* source, char* dest, int outputSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe() instead") int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
-+LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
-+LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
- 
--/* Obsolete streaming functions; use new streaming interface whenever possible */
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
-+/* Obsolete streaming functions; degraded functionality; do not use!
-+ *
-+ * In order to perform streaming compression, these functions depended on data
-+ * that is no longer tracked in the state. They have been preserved as well as
-+ * possible: using them will still produce a correct output. However, they don't
-+ * actually retain any history between compression calls. The compression ratio
-+ * achieved will therefore be no better than compressing each chunk
-+ * independently.
-+ */
-+LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
-+LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
-+LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API  int   LZ4_resetStreamState(void* state, char* inputBuffer);
-+LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API     char* LZ4_slideInputBuffer (void* state);
- 
- /* Obsolete streaming decoding functions */
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
-+LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-+LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
- 
- #endif /* LZ4_H_2983827168210 */
- 
- 
- #if defined (__cplusplus)
- }
- #endif
-

rel-257/mozilla-esr60/patches/1460316-backout-1513900-lz.patch

@@ -1,3721 +0,0 @@
-# HG changeset patch
-# User Ian Neal <iann_cvs@blueyonder.co.uk>
-# Date 1589029820 -3600
-# Parent  b5986bcf757a1ce364c1a8263dc8068b2b4893c4
-Backout lz4.* part of Bug 1513900 (Reformat everything on the ESR branch to the Google coding style) so Bug 1460316 can apply cleanly. r=me a=me
-
-diff --git a/mfbt/lz4.c b/mfbt/lz4.c
---- a/mfbt/lz4.c
-+++ b/mfbt/lz4.c
-@@ -27,107 +27,100 @@
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-    You can contact the author at :
-     - LZ4 homepage : http://www.lz4.org
-     - LZ4 source repository : https://github.com/lz4/lz4
- */
- 
-+
- /*-************************************
-- *  Tuning parameters
-- **************************************/
-+*  Tuning parameters
-+**************************************/
- /*
-  * LZ4_HEAPMODE :
-- * Select how default compression functions will allocate memory for their hash
-- * table, in memory stack (0:default, fastest), or in memory heap (1:requires
-- * malloc()).
-+ * Select how default compression functions will allocate memory for their hash table,
-+ * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
-  */
- #ifndef LZ4_HEAPMODE
--#define LZ4_HEAPMODE 0
-+#  define LZ4_HEAPMODE 0
- #endif
- 
- /*
-  * ACCELERATION_DEFAULT :
-  * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
-  */
- #define ACCELERATION_DEFAULT 1
- 
-+
- /*-************************************
-- *  CPU Feature Detection
-- **************************************/
-+*  CPU Feature Detection
-+**************************************/
- /* LZ4_FORCE_MEMORY_ACCESS
-- * By default, access to unaligned memory is controlled by `memcpy()`, which is
-- * safe and portable. Unfortunately, on some target/compiler combinations, the
-- * generated assembly is sub-optimal. The below switch allow to select different
-- * access method for improved performance. Method 0 (default) : use `memcpy()`.
-- * Safe and portable. Method 1 : `__packed` statement. It depends on compiler
-- * extension (ie, not portable). This method is safe if your compiler supports
-- * it, and *generally* as fast or faster than `memcpy`. Method 2 :
-- * direct access. This method is portable but violate C standard. It can
-- * generate buggy code on targets which assembly generation depends
-- * on alignment. But in some circumstances, it's the only known way to get the
-- * most performance (ie GCC + ARMv6) See
-- * https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html
-- * for details. Prefer these methods in priority order (0 > 1 > 2)
-+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
-+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
-+ * The below switch allow to select different access method for improved performance.
-+ * Method 0 (default) : use `memcpy()`. Safe and portable.
-+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
-+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
-+ * Method 2 : direct access. This method is portable but violate C standard.
-+ *            It can generate buggy code on targets which assembly generation depends on alignment.
-+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
-+ * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
-+ * Prefer these methods in priority order (0 > 1 > 2)
-  */
--#ifndef LZ4_FORCE_MEMORY_ACCESS /* can be defined externally */
--#if defined(__GNUC__) &&                                     \
--    (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) ||  \
--     defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || \
--     defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__))
--#define LZ4_FORCE_MEMORY_ACCESS 2
--#elif defined(__INTEL_COMPILER) || defined(__GNUC__)
--#define LZ4_FORCE_MEMORY_ACCESS 1
--#endif
-+#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
-+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-+#    define LZ4_FORCE_MEMORY_ACCESS 2
-+#  elif defined(__INTEL_COMPILER) || defined(__GNUC__)
-+#    define LZ4_FORCE_MEMORY_ACCESS 1
-+#  endif
- #endif
- 
- /*
-  * LZ4_FORCE_SW_BITCOUNT
-- * Define this parameter if your target system or compiler does not support
-- * hardware bit count
-+ * Define this parameter if your target system or compiler does not support hardware bit count
-  */
--#if defined(_MSC_VER) &&                                                 \
--    defined(_WIN32_WCE) /* Visual Studio for Windows CE does not support \
--                           Hardware bit count */
--#define LZ4_FORCE_SW_BITCOUNT
-+#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for Windows CE does not support Hardware bit count */
-+#  define LZ4_FORCE_SW_BITCOUNT
- #endif
- 
-+
-+
- /*-************************************
-- *  Dependency
-- **************************************/
-+*  Dependency
-+**************************************/
- #include "lz4.h"
- /* see also "memory routines" below */
- 
-+
- /*-************************************
-- *  Compiler Options
-- **************************************/
--#ifdef _MSC_VER /* Visual Studio */
--#include <intrin.h>
--#pragma warning( \
--    disable : 4127) /* disable: C4127: conditional expression is constant */
--#pragma warning(disable : 4293) /* disable: C4293: too large shift (32-bits) \
--                                 */
--#endif                          /* _MSC_VER */
-+*  Compiler Options
-+**************************************/
-+#ifdef _MSC_VER    /* Visual Studio */
-+#  include <intrin.h>
-+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-+#  pragma warning(disable : 4293)        /* disable: C4293: too large shift (32-bits) */
-+#endif  /* _MSC_VER */
- 
- #ifndef LZ4_FORCE_INLINE
--#ifdef _MSC_VER /* Visual Studio */
--#define LZ4_FORCE_INLINE static __forceinline
--#else
--#if defined(__cplusplus) || \
--    defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */
--#ifdef __GNUC__
--#define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
--#else
--#define LZ4_FORCE_INLINE static inline
--#endif
--#else
--#define LZ4_FORCE_INLINE static
--#endif /* __STDC_VERSION__ */
--#endif /* _MSC_VER */
-+#  ifdef _MSC_VER    /* Visual Studio */
-+#    define LZ4_FORCE_INLINE static __forceinline
-+#  else
-+#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-+#      ifdef __GNUC__
-+#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
-+#      else
-+#        define LZ4_FORCE_INLINE static inline
-+#      endif
-+#    else
-+#      define LZ4_FORCE_INLINE static
-+#    endif /* __STDC_VERSION__ */
-+#  endif  /* _MSC_VER */
- #endif /* LZ4_FORCE_INLINE */
- 
- /* LZ4_FORCE_O2_GCC_PPC64LE and LZ4_FORCE_O2_INLINE_GCC_PPC64LE
-  * Gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy,
-  * together with a simple 8-byte copy loop as a fall-back path.
-  * However, this optimization hurts the decompression speed by >30%,
-  * because the execution does not go to the optimized loop
-  * for typical compressible data, and all of the preamble checks
-@@ -135,1637 +128,1437 @@
-  * This optimization happens only with the -O3 flag, and -O2 generates
-  * a simple 8-byte copy loop.
-  * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy
-  * functions are annotated with __attribute__((optimize("O2"))),
-  * and also LZ4_wildCopy is forcibly inlined, so that the O2 attribute
-  * of LZ4_wildCopy does not affect the compression speed.
-  */
- #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__)
--#define LZ4_FORCE_O2_GCC_PPC64LE __attribute__((optimize("O2")))
--#define LZ4_FORCE_O2_INLINE_GCC_PPC64LE \
--  __attribute__((optimize("O2"))) LZ4_FORCE_INLINE
-+#  define LZ4_FORCE_O2_GCC_PPC64LE __attribute__((optimize("O2")))
-+#  define LZ4_FORCE_O2_INLINE_GCC_PPC64LE __attribute__((optimize("O2"))) LZ4_FORCE_INLINE
- #else
--#define LZ4_FORCE_O2_GCC_PPC64LE
--#define LZ4_FORCE_O2_INLINE_GCC_PPC64LE static
-+#  define LZ4_FORCE_O2_GCC_PPC64LE
-+#  define LZ4_FORCE_O2_INLINE_GCC_PPC64LE static
- #endif
- 
--#if (defined(__GNUC__) && (__GNUC__ >= 3)) ||                   \
--    (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || \
--    defined(__clang__)
--#define expect(expr, value) (__builtin_expect((expr), (value)))
-+#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
-+#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
- #else
--#define expect(expr, value) (expr)
-+#  define expect(expr,value)    (expr)
- #endif
- 
--#define likely(expr) expect((expr) != 0, 1)
--#define unlikely(expr) expect((expr) != 0, 0)
-+#define likely(expr)     expect((expr) != 0, 1)
-+#define unlikely(expr)   expect((expr) != 0, 0)
-+
- 
- /*-************************************
-- *  Memory routines
-- **************************************/
--#include <stdlib.h> /* malloc, calloc, free */
--#define ALLOCATOR(n, s) calloc(n, s)
--#define FREEMEM free
--#include <string.h> /* memset, memcpy */
--#define MEM_INIT memset
-+*  Memory routines
-+**************************************/
-+#include <stdlib.h>   /* malloc, calloc, free */
-+#define ALLOCATOR(n,s) calloc(n,s)
-+#define FREEMEM        free
-+#include <string.h>   /* memset, memcpy */
-+#define MEM_INIT       memset
-+
- 
- /*-************************************
-- *  Basic Types
-- **************************************/
--#if defined(__cplusplus) || \
--    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
--#include <stdint.h>
--typedef uint8_t BYTE;
--typedef uint16_t U16;
--typedef uint32_t U32;
--typedef int32_t S32;
--typedef uint64_t U64;
--typedef uintptr_t uptrval;
-+*  Basic Types
-+**************************************/
-+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-+# include <stdint.h>
-+  typedef  uint8_t BYTE;
-+  typedef uint16_t U16;
-+  typedef uint32_t U32;
-+  typedef  int32_t S32;
-+  typedef uint64_t U64;
-+  typedef uintptr_t uptrval;
- #else
--typedef unsigned char BYTE;
--typedef unsigned short U16;
--typedef unsigned int U32;
--typedef signed int S32;
--typedef unsigned long long U64;
--typedef size_t uptrval; /* generally true, except OpenVMS-64 */
-+  typedef unsigned char       BYTE;
-+  typedef unsigned short      U16;
-+  typedef unsigned int        U32;
-+  typedef   signed int        S32;
-+  typedef unsigned long long  U64;
-+  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
- #endif
- 
- #if defined(__x86_64__)
--typedef U64 reg_t; /* 64-bits in x32 mode */
-+  typedef U64    reg_t;   /* 64-bits in x32 mode */
- #else
--typedef size_t reg_t;   /* 32-bits in x32 mode */
-+  typedef size_t reg_t;   /* 32-bits in x32 mode */
- #endif
- 
- /*-************************************
-- *  Reading and writing into memory
-- **************************************/
--static unsigned LZ4_isLittleEndian(void) {
--  const union {
--    U32 u;
--    BYTE c[4];
--  } one = {1}; /* don't use static : performance detrimental */
--  return one.c[0];
-+*  Reading and writing into memory
-+**************************************/
-+static unsigned LZ4_isLittleEndian(void)
-+{
-+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
-+    return one.c[0];
- }
- 
--#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS == 2)
-+
-+#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
- /* lie to the compiler about data alignment; use with caution */
- 
--static U16 LZ4_read16(const void* memPtr) { return *(const U16*)memPtr; }
--static U32 LZ4_read32(const void* memPtr) { return *(const U32*)memPtr; }
--static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*)memPtr; }
-+static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
-+static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
-+static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
- 
- static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
- static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
- 
--#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS == 1)
-+#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
- 
--/* __pack instructions are safer, but compiler specific, hence potentially
-- * problematic for some compilers */
-+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
- /* currently only defined for gcc and icc */
--typedef union {
--  U16 u16;
--  U32 u32;
--  reg_t uArch;
--} __attribute__((packed)) unalign;
-+typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) unalign;
- 
- static U16 LZ4_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
- static U32 LZ4_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
--static reg_t LZ4_read_ARCH(const void* ptr) {
--  return ((const unalign*)ptr)->uArch;
--}
-+static reg_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArch; }
-+
-+static void LZ4_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-+static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
- 
--static void LZ4_write16(void* memPtr, U16 value) {
--  ((unalign*)memPtr)->u16 = value;
--}
--static void LZ4_write32(void* memPtr, U32 value) {
--  ((unalign*)memPtr)->u32 = value;
--}
-+#else  /* safe and portable access through memcpy() */
- 
--#else /* safe and portable access through memcpy() */
--
--static U16 LZ4_read16(const void* memPtr) {
--  U16 val;
--  memcpy(&val, memPtr, sizeof(val));
--  return val;
-+static U16 LZ4_read16(const void* memPtr)
-+{
-+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
- }
- 
--static U32 LZ4_read32(const void* memPtr) {
--  U32 val;
--  memcpy(&val, memPtr, sizeof(val));
--  return val;
-+static U32 LZ4_read32(const void* memPtr)
-+{
-+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
- }
- 
--static reg_t LZ4_read_ARCH(const void* memPtr) {
--  reg_t val;
--  memcpy(&val, memPtr, sizeof(val));
--  return val;
-+static reg_t LZ4_read_ARCH(const void* memPtr)
-+{
-+    reg_t val; memcpy(&val, memPtr, sizeof(val)); return val;
- }
- 
--static void LZ4_write16(void* memPtr, U16 value) {
--  memcpy(memPtr, &value, sizeof(value));
-+static void LZ4_write16(void* memPtr, U16 value)
-+{
-+    memcpy(memPtr, &value, sizeof(value));
- }
- 
--static void LZ4_write32(void* memPtr, U32 value) {
--  memcpy(memPtr, &value, sizeof(value));
-+static void LZ4_write32(void* memPtr, U32 value)
-+{
-+    memcpy(memPtr, &value, sizeof(value));
- }
- 
- #endif /* LZ4_FORCE_MEMORY_ACCESS */
- 
--static U16 LZ4_readLE16(const void* memPtr) {
--  if (LZ4_isLittleEndian()) {
--    return LZ4_read16(memPtr);
--  } else {
--    const BYTE* p = (const BYTE*)memPtr;
--    return (U16)((U16)p[0] + (p[1] << 8));
--  }
--}
- 
--static void LZ4_writeLE16(void* memPtr, U16 value) {
--  if (LZ4_isLittleEndian()) {
--    LZ4_write16(memPtr, value);
--  } else {
--    BYTE* p = (BYTE*)memPtr;
--    p[0] = (BYTE)value;
--    p[1] = (BYTE)(value >> 8);
--  }
-+static U16 LZ4_readLE16(const void* memPtr)
-+{
-+    if (LZ4_isLittleEndian()) {
-+        return LZ4_read16(memPtr);
-+    } else {
-+        const BYTE* p = (const BYTE*)memPtr;
-+        return (U16)((U16)p[0] + (p[1]<<8));
-+    }
- }
- 
--static void LZ4_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-+static void LZ4_writeLE16(void* memPtr, U16 value)
-+{
-+    if (LZ4_isLittleEndian()) {
-+        LZ4_write16(memPtr, value);
-+    } else {
-+        BYTE* p = (BYTE*)memPtr;
-+        p[0] = (BYTE) value;
-+        p[1] = (BYTE)(value>>8);
-+    }
-+}
- 
--/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd
-- */
--LZ4_FORCE_O2_INLINE_GCC_PPC64LE
--void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd) {
--  BYTE* d = (BYTE*)dstPtr;
--  const BYTE* s = (const BYTE*)srcPtr;
--  BYTE* const e = (BYTE*)dstEnd;
--
--  do {
--    LZ4_copy8(d, s);
--    d += 8;
--    s += 8;
--  } while (d < e);
-+static void LZ4_copy8(void* dst, const void* src)
-+{
-+    memcpy(dst,src,8);
- }
- 
-+/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
-+LZ4_FORCE_O2_INLINE_GCC_PPC64LE
-+void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
-+{
-+    BYTE* d = (BYTE*)dstPtr;
-+    const BYTE* s = (const BYTE*)srcPtr;
-+    BYTE* const e = (BYTE*)dstEnd;
-+
-+    do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
-+}
-+
-+
- /*-************************************
-- *  Common Constants
-- **************************************/
-+*  Common Constants
-+**************************************/
- #define MINMATCH 4
- 
- #define WILDCOPYLENGTH 8
- #define LASTLITERALS 5
--#define MFLIMIT (WILDCOPYLENGTH + MINMATCH)
--static const int LZ4_minLength = (MFLIMIT + 1);
-+#define MFLIMIT (WILDCOPYLENGTH+MINMATCH)
-+static const int LZ4_minLength = (MFLIMIT+1);
- 
--#define KB *(1 << 10)
--#define MB *(1 << 20)
--#define GB *(1U << 30)
-+#define KB *(1 <<10)
-+#define MB *(1 <<20)
-+#define GB *(1U<<30)
- 
- #define MAXD_LOG 16
- #define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
- 
--#define ML_BITS 4
--#define ML_MASK ((1U << ML_BITS) - 1)
--#define RUN_BITS (8 - ML_BITS)
--#define RUN_MASK ((1U << RUN_BITS) - 1)
-+#define ML_BITS  4
-+#define ML_MASK  ((1U<<ML_BITS)-1)
-+#define RUN_BITS (8-ML_BITS)
-+#define RUN_MASK ((1U<<RUN_BITS)-1)
-+
- 
- /*-************************************
-- *  Error detection
-- **************************************/
--#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 1)
--#include <assert.h>
-+*  Error detection
-+**************************************/
-+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
-+#  include <assert.h>
- #else
--#ifndef assert
--#define assert(condition) ((void)0)
--#endif
-+#  ifndef assert
-+#    define assert(condition) ((void)0)
-+#  endif
- #endif
- 
--#define LZ4_STATIC_ASSERT(c)                       \
--  {                                                \
--    enum { LZ4_static_assert = 1 / (int)(!!(c)) }; \
--  } /* use only *after* variable declarations */
-+#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
- 
--#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 2)
--#include <stdio.h>
-+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
-+#  include <stdio.h>
- static int g_debuglog_enable = 1;
--#define DEBUGLOG(l, ...)                           \
--  {                                                \
--    if ((g_debuglog_enable) && (l <= LZ4_DEBUG)) { \
--      fprintf(stderr, __FILE__ ": ");              \
--      fprintf(stderr, __VA_ARGS__);                \
--      fprintf(stderr, " \n");                      \
--    }                                              \
--  }
-+#  define DEBUGLOG(l, ...) {                                  \
-+                if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-+                    fprintf(stderr, __FILE__ ": ");           \
-+                    fprintf(stderr, __VA_ARGS__);             \
-+                    fprintf(stderr, " \n");                   \
-+            }   }
- #else
--#define DEBUGLOG(l, ...) \
--  {} /* disabled */
-+#  define DEBUGLOG(l, ...)      {}    /* disabled */
- #endif
- 
-+
- /*-************************************
-- *  Common functions
-- **************************************/
--static unsigned LZ4_NbCommonBytes(reg_t val) {
--  if (LZ4_isLittleEndian()) {
--    if (sizeof(val) == 8) {
--#if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
--      unsigned long r = 0;
--      _BitScanForward64(&r, (U64)val);
--      return (int)(r >> 3);
--#elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 3))) && \
--    !defined(LZ4_FORCE_SW_BITCOUNT)
--      return (__builtin_ctzll((U64)val) >> 3);
--#else
--      static const int DeBruijnBytePos[64] = {
--          0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5,
--          3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5,
--          3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7};
--      return DeBruijnBytePos[((U64)((val & -(long long)val) *
--                                    0x0218A392CDABBD3FULL)) >>
--                             58];
--#endif
--    } else /* 32 bits */ {
--#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
--      unsigned long r;
--      _BitScanForward(&r, (U32)val);
--      return (int)(r >> 3);
--#elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 3))) && \
--    !defined(LZ4_FORCE_SW_BITCOUNT)
--      return (__builtin_ctz((U32)val) >> 3);
--#else
--      static const int DeBruijnBytePos[32] = {0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2,
--                                              1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2,
--                                              2, 0, 3, 1, 2, 0, 1, 0, 1, 1};
--      return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
--#endif
-+*  Common functions
-+**************************************/
-+static unsigned LZ4_NbCommonBytes (reg_t val)
-+{
-+    if (LZ4_isLittleEndian()) {
-+        if (sizeof(val)==8) {
-+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            unsigned long r = 0;
-+            _BitScanForward64( &r, (U64)val );
-+            return (int)(r>>3);
-+#       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            return (__builtin_ctzll((U64)val) >> 3);
-+#       else
-+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,
-+                                                     0, 3, 1, 3, 1, 4, 2, 7,
-+                                                     0, 2, 3, 6, 1, 5, 3, 5,
-+                                                     1, 3, 4, 4, 2, 5, 6, 7,
-+                                                     7, 0, 1, 2, 3, 3, 4, 6,
-+                                                     2, 6, 5, 5, 3, 4, 5, 6,
-+                                                     7, 1, 2, 4, 6, 4, 4, 5,
-+                                                     7, 2, 6, 5, 7, 6, 7, 7 };
-+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
-+#       endif
-+        } else /* 32 bits */ {
-+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            unsigned long r;
-+            _BitScanForward( &r, (U32)val );
-+            return (int)(r>>3);
-+#       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            return (__builtin_ctz((U32)val) >> 3);
-+#       else
-+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,
-+                                                     3, 2, 2, 1, 3, 2, 0, 1,
-+                                                     3, 3, 1, 2, 2, 2, 2, 0,
-+                                                     3, 1, 2, 0, 1, 0, 1, 1 };
-+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
-+#       endif
-+        }
-+    } else   /* Big Endian CPU */ {
-+        if (sizeof(val)==8) {   /* 64-bits */
-+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            unsigned long r = 0;
-+            _BitScanReverse64( &r, val );
-+            return (unsigned)(r>>3);
-+#       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            return (__builtin_clzll((U64)val) >> 3);
-+#       else
-+            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
-+                Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
-+                Note that this code path is never triggered in 32-bits mode. */
-+            unsigned r;
-+            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
-+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-+            r += (!val);
-+            return r;
-+#       endif
-+        } else /* 32 bits */ {
-+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            unsigned long r = 0;
-+            _BitScanReverse( &r, (unsigned long)val );
-+            return (unsigned)(r>>3);
-+#       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-+            return (__builtin_clz((U32)val) >> 3);
-+#       else
-+            unsigned r;
-+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-+            r += (!val);
-+            return r;
-+#       endif
-+        }
-     }
--  } else /* Big Endian CPU */ {
--    if (sizeof(val) == 8) { /* 64-bits */
--#if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
--      unsigned long r = 0;
--      _BitScanReverse64(&r, val);
--      return (unsigned)(r >> 3);
--#elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 3))) && \
--    !defined(LZ4_FORCE_SW_BITCOUNT)
--      return (__builtin_clzll((U64)val) >> 3);
--#else
--      static const U32 by32 = sizeof(val) * 4; /* 32 on 64 bits (goal), 16 on 32
--           bits. Just to avoid some static analyzer complaining about shift by
--           32 on 32-bits target. Note that this code path is never triggered in
--           32-bits mode. */
--      unsigned r;
--      if (!(val >> by32)) {
--        r = 4;
--      } else {
--        r = 0;
--        val >>= by32;
--      }
--      if (!(val >> 16)) {
--        r += 2;
--        val >>= 8;
--      } else {
--        val >>= 24;
--      }
--      r += (!val);
--      return r;
--#endif
--    } else /* 32 bits */ {
--#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
--      unsigned long r = 0;
--      _BitScanReverse(&r, (unsigned long)val);
--      return (unsigned)(r >> 3);
--#elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 3))) && \
--    !defined(LZ4_FORCE_SW_BITCOUNT)
--      return (__builtin_clz((U32)val) >> 3);
--#else
--      unsigned r;
--      if (!(val >> 16)) {
--        r = 2;
--        val >>= 8;
--      } else {
--        r = 0;
--        val >>= 24;
--      }
--      r += (!val);
--      return r;
--#endif
--    }
--  }
- }
- 
- #define STEPSIZE sizeof(reg_t)
- LZ4_FORCE_INLINE
--unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) {
--  const BYTE* const pStart = pIn;
-+unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-+{
-+    const BYTE* const pStart = pIn;
- 
--  if (likely(pIn < pInLimit - (STEPSIZE - 1))) {
--    reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
--    if (!diff) {
--      pIn += STEPSIZE;
--      pMatch += STEPSIZE;
--    } else {
--      return LZ4_NbCommonBytes(diff);
--    }
--  }
-+    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
-+        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-+        if (!diff) {
-+            pIn+=STEPSIZE; pMatch+=STEPSIZE;
-+        } else {
-+            return LZ4_NbCommonBytes(diff);
-+    }   }
- 
--  while (likely(pIn < pInLimit - (STEPSIZE - 1))) {
--    reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
--    if (!diff) {
--      pIn += STEPSIZE;
--      pMatch += STEPSIZE;
--      continue;
-+    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
-+        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-+        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
-+        pIn += LZ4_NbCommonBytes(diff);
-+        return (unsigned)(pIn - pStart);
-     }
--    pIn += LZ4_NbCommonBytes(diff);
--    return (unsigned)(pIn - pStart);
--  }
- 
--  if ((STEPSIZE == 8) && (pIn < (pInLimit - 3)) &&
--      (LZ4_read32(pMatch) == LZ4_read32(pIn))) {
--    pIn += 4;
--    pMatch += 4;
--  }
--  if ((pIn < (pInLimit - 1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) {
--    pIn += 2;
--    pMatch += 2;
--  }
--  if ((pIn < pInLimit) && (*pMatch == *pIn)) pIn++;
--  return (unsigned)(pIn - pStart);
-+    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
-+    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
-+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-+    return (unsigned)(pIn - pStart);
- }
- 
-+
- #ifndef LZ4_COMMONDEFS_ONLY
- /*-************************************
-- *  Local Constants
-- **************************************/
--static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT - 1));
--static const U32 LZ4_skipTrigger =
--    6; /* Increase this value ==> compression run slower on
--          incompressible data */
-+*  Local Constants
-+**************************************/
-+static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
-+static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
-+
- 
- /*-************************************
-- *  Local Structures and types
-- **************************************/
-+*  Local Structures and types
-+**************************************/
- typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive;
- typedef enum { byPtr, byU32, byU16 } tableType_t;
- 
- typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;
- typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
- 
- typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
- typedef enum { full = 0, partial = 1 } earlyEnd_directive;
- 
-+
- /*-************************************
-- *  Local Utils
-- **************************************/
--int LZ4_versionNumber(void) { return LZ4_VERSION_NUMBER; }
-+*  Local Utils
-+**************************************/
-+int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
- const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
--int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); }
-+int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
- int LZ4_sizeofState() { return LZ4_STREAMSIZE; }
- 
-+
- /*-******************************
-- *  Compression functions
-- ********************************/
--static U32 LZ4_hash4(U32 sequence, tableType_t const tableType) {
--  if (tableType == byU16)
--    return ((sequence * 2654435761U) >> ((MINMATCH * 8) - (LZ4_HASHLOG + 1)));
--  else
--    return ((sequence * 2654435761U) >> ((MINMATCH * 8) - LZ4_HASHLOG));
-+*  Compression functions
-+********************************/
-+static U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
-+{
-+    if (tableType == byU16)
-+        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
-+    else
-+        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
- }
- 
--static U32 LZ4_hash5(U64 sequence, tableType_t const tableType) {
--  static const U64 prime5bytes = 889523592379ULL;
--  static const U64 prime8bytes = 11400714785074694791ULL;
--  const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG + 1 : LZ4_HASHLOG;
--  if (LZ4_isLittleEndian())
--    return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
--  else
--    return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
--}
--
--LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p,
--                                      tableType_t const tableType) {
--  if ((sizeof(reg_t) == 8) && (tableType != byU16))
--    return LZ4_hash5(LZ4_read_ARCH(p), tableType);
--  return LZ4_hash4(LZ4_read32(p), tableType);
-+static U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
-+{
-+    static const U64 prime5bytes = 889523592379ULL;
-+    static const U64 prime8bytes = 11400714785074694791ULL;
-+    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
-+    if (LZ4_isLittleEndian())
-+        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
-+    else
-+        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
- }
- 
--static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase,
--                                  tableType_t const tableType,
--                                  const BYTE* srcBase) {
--  switch (tableType) {
--    case byPtr: {
--      const BYTE** hashTable = (const BYTE**)tableBase;
--      hashTable[h] = p;
--      return;
-+LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
-+{
-+    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-+    return LZ4_hash4(LZ4_read32(p), tableType);
-+}
-+
-+static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)
-+{
-+    switch (tableType)
-+    {
-+    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
-+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
-+    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
-     }
--    case byU32: {
--      U32* hashTable = (U32*)tableBase;
--      hashTable[h] = (U32)(p - srcBase);
--      return;
--    }
--    case byU16: {
--      U16* hashTable = (U16*)tableBase;
--      hashTable[h] = (U16)(p - srcBase);
--      return;
--    }
--  }
- }
- 
--LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase,
--                                      tableType_t tableType,
--                                      const BYTE* srcBase) {
--  U32 const h = LZ4_hashPosition(p, tableType);
--  LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
-+LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+{
-+    U32 const h = LZ4_hashPosition(p, tableType);
-+    LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
- }
- 
--static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase,
--                                         tableType_t tableType,
--                                         const BYTE* srcBase) {
--  if (tableType == byPtr) {
--    const BYTE** hashTable = (const BYTE**)tableBase;
--    return hashTable[h];
--  }
--  if (tableType == byU32) {
--    const U32* const hashTable = (U32*)tableBase;
--    return hashTable[h] + srcBase;
--  }
--  {
--    const U16* const hashTable = (U16*)tableBase;
--    return hashTable[h] + srcBase;
--  } /* default, to ensure a return */
-+static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+{
-+    if (tableType == byPtr) { const BYTE** hashTable = (const BYTE**) tableBase; return hashTable[h]; }
-+    if (tableType == byU32) { const U32* const hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }
-+    { const U16* const hashTable = (U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
- }
- 
--LZ4_FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase,
--                                             tableType_t tableType,
--                                             const BYTE* srcBase) {
--  U32 const h = LZ4_hashPosition(p, tableType);
--  return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
-+LZ4_FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
-+{
-+    U32 const h = LZ4_hashPosition(p, tableType);
-+    return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
- }
- 
-+
- /** LZ4_compress_generic() :
-     inlined, to ensure branches are decided at compilation time */
- LZ4_FORCE_INLINE int LZ4_compress_generic(
--    LZ4_stream_t_internal* const cctx, const char* const source,
--    char* const dest, const int inputSize, const int maxOutputSize,
--    const limitedOutput_directive outputLimited, const tableType_t tableType,
--    const dict_directive dict, const dictIssue_directive dictIssue,
--    const U32 acceleration) {
--  const BYTE* ip = (const BYTE*)source;
--  const BYTE* base;
--  const BYTE* lowLimit;
--  const BYTE* const lowRefLimit = ip - cctx->dictSize;
--  const BYTE* const dictionary = cctx->dictionary;
--  const BYTE* const dictEnd = dictionary + cctx->dictSize;
--  const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;
--  const BYTE* anchor = (const BYTE*)source;
--  const BYTE* const iend = ip + inputSize;
--  const BYTE* const mflimit = iend - MFLIMIT;
--  const BYTE* const matchlimit = iend - LASTLITERALS;
-+                 LZ4_stream_t_internal* const cctx,
-+                 const char* const source,
-+                 char* const dest,
-+                 const int inputSize,
-+                 const int maxOutputSize,
-+                 const limitedOutput_directive outputLimited,
-+                 const tableType_t tableType,
-+                 const dict_directive dict,
-+                 const dictIssue_directive dictIssue,
-+                 const U32 acceleration)
-+{
-+    const BYTE* ip = (const BYTE*) source;
-+    const BYTE* base;
-+    const BYTE* lowLimit;
-+    const BYTE* const lowRefLimit = ip - cctx->dictSize;
-+    const BYTE* const dictionary = cctx->dictionary;
-+    const BYTE* const dictEnd = dictionary + cctx->dictSize;
-+    const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;
-+    const BYTE* anchor = (const BYTE*) source;
-+    const BYTE* const iend = ip + inputSize;
-+    const BYTE* const mflimit = iend - MFLIMIT;
-+    const BYTE* const matchlimit = iend - LASTLITERALS;
- 
--  BYTE* op = (BYTE*)dest;
--  BYTE* const olimit = op + maxOutputSize;
-+    BYTE* op = (BYTE*) dest;
-+    BYTE* const olimit = op + maxOutputSize;
- 
--  U32 forwardH;
-+    U32 forwardH;
- 
--  /* Init conditions */
--  if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE)
--    return 0; /* Unsupported inputSize, too large (or negative) */
--  switch (dict) {
-+    /* Init conditions */
-+    if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;   /* Unsupported inputSize, too large (or negative) */
-+    switch(dict)
-+    {
-     case noDict:
-     default:
--      base = (const BYTE*)source;
--      lowLimit = (const BYTE*)source;
--      break;
-+        base = (const BYTE*)source;
-+        lowLimit = (const BYTE*)source;
-+        break;
-     case withPrefix64k:
--      base = (const BYTE*)source - cctx->currentOffset;
--      lowLimit = (const BYTE*)source - cctx->dictSize;
--      break;
-+        base = (const BYTE*)source - cctx->currentOffset;
-+        lowLimit = (const BYTE*)source - cctx->dictSize;
-+        break;
-     case usingExtDict:
--      base = (const BYTE*)source - cctx->currentOffset;
--      lowLimit = (const BYTE*)source;
--      break;
--  }
--  if ((tableType == byU16) && (inputSize >= LZ4_64Klimit))
--    return 0; /* Size too large (not within 64K limit) */
--  if (inputSize < LZ4_minLength)
--    goto _last_literals; /* Input too small, no compression (all literals) */
-+        base = (const BYTE*)source - cctx->currentOffset;
-+        lowLimit = (const BYTE*)source;
-+        break;
-+    }
-+    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
-+    if (inputSize<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
-+
-+    /* First Byte */
-+    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-+    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-+
-+    /* Main Loop */
-+    for ( ; ; ) {
-+        ptrdiff_t refDelta = 0;
-+        const BYTE* match;
-+        BYTE* token;
-+
-+        /* Find a match */
-+        {   const BYTE* forwardIp = ip;
-+            unsigned step = 1;
-+            unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
-+            do {
-+                U32 const h = forwardH;
-+                ip = forwardIp;
-+                forwardIp += step;
-+                step = (searchMatchNb++ >> LZ4_skipTrigger);
- 
--  /* First Byte */
--  LZ4_putPosition(ip, cctx->hashTable, tableType, base);
--  ip++;
--  forwardH = LZ4_hashPosition(ip, tableType);
-+                if (unlikely(forwardIp > mflimit)) goto _last_literals;
- 
--  /* Main Loop */
--  for (;;) {
--    ptrdiff_t refDelta = 0;
--    const BYTE* match;
--    BYTE* token;
-+                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
-+                if (dict==usingExtDict) {
-+                    if (match < (const BYTE*)source) {
-+                        refDelta = dictDelta;
-+                        lowLimit = dictionary;
-+                    } else {
-+                        refDelta = 0;
-+                        lowLimit = (const BYTE*)source;
-+                }   }
-+                forwardH = LZ4_hashPosition(forwardIp, tableType);
-+                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
- 
--    /* Find a match */
--    {
--      const BYTE* forwardIp = ip;
--      unsigned step = 1;
--      unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
--      do {
--        U32 const h = forwardH;
--        ip = forwardIp;
--        forwardIp += step;
--        step = (searchMatchNb++ >> LZ4_skipTrigger);
-+            } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0)
-+                || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
-+                || (LZ4_read32(match+refDelta) != LZ4_read32(ip)) );
-+        }
-+
-+        /* Catch up */
-+        while (((ip>anchor) & (match+refDelta > lowLimit)) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; }
- 
--        if (unlikely(forwardIp > mflimit)) goto _last_literals;
-+        /* Encode Literals */
-+        {   unsigned const litLength = (unsigned)(ip - anchor);
-+            token = op++;
-+            if ((outputLimited) &&  /* Check output buffer overflow */
-+                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)))
-+                return 0;
-+            if (litLength >= RUN_MASK) {
-+                int len = (int)litLength-RUN_MASK;
-+                *token = (RUN_MASK<<ML_BITS);
-+                for(; len >= 255 ; len-=255) *op++ = 255;
-+                *op++ = (BYTE)len;
-+            }
-+            else *token = (BYTE)(litLength<<ML_BITS);
- 
--        match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
--        if (dict == usingExtDict) {
--          if (match < (const BYTE*)source) {
--            refDelta = dictDelta;
--            lowLimit = dictionary;
--          } else {
--            refDelta = 0;
--            lowLimit = (const BYTE*)source;
--          }
-+            /* Copy Literals */
-+            LZ4_wildCopy(op, anchor, op+litLength);
-+            op+=litLength;
-         }
--        forwardH = LZ4_hashPosition(forwardIp, tableType);
--        LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
-+
-+_next_match:
-+        /* Encode Offset */
-+        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
-+
-+        /* Encode MatchLength */
-+        {   unsigned matchCode;
- 
--      } while (((dictIssue == dictSmall) ? (match < lowRefLimit) : 0) ||
--               ((tableType == byU16) ? 0 : (match + MAX_DISTANCE < ip)) ||
--               (LZ4_read32(match + refDelta) != LZ4_read32(ip)));
--    }
-+            if ((dict==usingExtDict) && (lowLimit==dictionary)) {
-+                const BYTE* limit;
-+                match += refDelta;
-+                limit = ip + (dictEnd-match);
-+                if (limit > matchlimit) limit = matchlimit;
-+                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-+                ip += MINMATCH + matchCode;
-+                if (ip==limit) {
-+                    unsigned const more = LZ4_count(ip, (const BYTE*)source, matchlimit);
-+                    matchCode += more;
-+                    ip += more;
-+                }
-+            } else {
-+                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-+                ip += MINMATCH + matchCode;
-+            }
- 
--    /* Catch up */
--    while (((ip > anchor) & (match + refDelta > lowLimit)) &&
--           (unlikely(ip[-1] == match[refDelta - 1]))) {
--      ip--;
--      match--;
--    }
-+            if ( outputLimited &&    /* Check output buffer overflow */
-+                (unlikely(op + (1 + LASTLITERALS) + (matchCode>>8) > olimit)) )
-+                return 0;
-+            if (matchCode >= ML_MASK) {
-+                *token += ML_MASK;
-+                matchCode -= ML_MASK;
-+                LZ4_write32(op, 0xFFFFFFFF);
-+                while (matchCode >= 4*255) {
-+                    op+=4;
-+                    LZ4_write32(op, 0xFFFFFFFF);
-+                    matchCode -= 4*255;
-+                }
-+                op += matchCode / 255;
-+                *op++ = (BYTE)(matchCode % 255);
-+            } else
-+                *token += (BYTE)(matchCode);
-+        }
-+
-+        anchor = ip;
- 
--    /* Encode Literals */
--    {
--      unsigned const litLength = (unsigned)(ip - anchor);
--      token = op++;
--      if ((outputLimited) && /* Check output buffer overflow */
--          (unlikely(op + litLength + (2 + 1 + LASTLITERALS) +
--                        (litLength / 255) >
--                    olimit)))
--        return 0;
--      if (litLength >= RUN_MASK) {
--        int len = (int)litLength - RUN_MASK;
--        *token = (RUN_MASK << ML_BITS);
--        for (; len >= 255; len -= 255) *op++ = 255;
--        *op++ = (BYTE)len;
--      } else
--        *token = (BYTE)(litLength << ML_BITS);
-+        /* Test end of chunk */
-+        if (ip > mflimit) break;
-+
-+        /* Fill table */
-+        LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
- 
--      /* Copy Literals */
--      LZ4_wildCopy(op, anchor, op + litLength);
--      op += litLength;
-+        /* Test next position */
-+        match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
-+        if (dict==usingExtDict) {
-+            if (match < (const BYTE*)source) {
-+                refDelta = dictDelta;
-+                lowLimit = dictionary;
-+            } else {
-+                refDelta = 0;
-+                lowLimit = (const BYTE*)source;
-+        }   }
-+        LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-+        if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1)
-+            && (match+MAX_DISTANCE>=ip)
-+            && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) )
-+        { token=op++; *token=0; goto _next_match; }
-+
-+        /* Prepare next loop */
-+        forwardH = LZ4_hashPosition(++ip, tableType);
-     }
- 
--  _next_match:
--    /* Encode Offset */
--    LZ4_writeLE16(op, (U16)(ip - match));
--    op += 2;
--
--    /* Encode MatchLength */
--    {
--      unsigned matchCode;
--
--      if ((dict == usingExtDict) && (lowLimit == dictionary)) {
--        const BYTE* limit;
--        match += refDelta;
--        limit = ip + (dictEnd - match);
--        if (limit > matchlimit) limit = matchlimit;
--        matchCode = LZ4_count(ip + MINMATCH, match + MINMATCH, limit);
--        ip += MINMATCH + matchCode;
--        if (ip == limit) {
--          unsigned const more = LZ4_count(ip, (const BYTE*)source, matchlimit);
--          matchCode += more;
--          ip += more;
-+_last_literals:
-+    /* Encode Last Literals */
-+    {   size_t const lastRun = (size_t)(iend - anchor);
-+        if ( (outputLimited) &&  /* Check output buffer overflow */
-+            ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) )
-+            return 0;
-+        if (lastRun >= RUN_MASK) {
-+            size_t accumulator = lastRun - RUN_MASK;
-+            *op++ = RUN_MASK << ML_BITS;
-+            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-+            *op++ = (BYTE) accumulator;
-+        } else {
-+            *op++ = (BYTE)(lastRun<<ML_BITS);
-         }
--      } else {
--        matchCode = LZ4_count(ip + MINMATCH, match + MINMATCH, matchlimit);
--        ip += MINMATCH + matchCode;
--      }
--
--      if (outputLimited && /* Check output buffer overflow */
--          (unlikely(op + (1 + LASTLITERALS) + (matchCode >> 8) > olimit)))
--        return 0;
--      if (matchCode >= ML_MASK) {
--        *token += ML_MASK;
--        matchCode -= ML_MASK;
--        LZ4_write32(op, 0xFFFFFFFF);
--        while (matchCode >= 4 * 255) {
--          op += 4;
--          LZ4_write32(op, 0xFFFFFFFF);
--          matchCode -= 4 * 255;
--        }
--        op += matchCode / 255;
--        *op++ = (BYTE)(matchCode % 255);
--      } else
--        *token += (BYTE)(matchCode);
--    }
--
--    anchor = ip;
--
--    /* Test end of chunk */
--    if (ip > mflimit) break;
--
--    /* Fill table */
--    LZ4_putPosition(ip - 2, cctx->hashTable, tableType, base);
--
--    /* Test next position */
--    match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
--    if (dict == usingExtDict) {
--      if (match < (const BYTE*)source) {
--        refDelta = dictDelta;
--        lowLimit = dictionary;
--      } else {
--        refDelta = 0;
--        lowLimit = (const BYTE*)source;
--      }
--    }
--    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
--    if (((dictIssue == dictSmall) ? (match >= lowRefLimit) : 1) &&
--        (match + MAX_DISTANCE >= ip) &&
--        (LZ4_read32(match + refDelta) == LZ4_read32(ip))) {
--      token = op++;
--      *token = 0;
--      goto _next_match;
-+        memcpy(op, anchor, lastRun);
-+        op += lastRun;
-     }
- 
--    /* Prepare next loop */
--    forwardH = LZ4_hashPosition(++ip, tableType);
--  }
-+    /* End */
-+    return (int) (((char*)op)-dest);
-+}
-+
-+
-+int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-+{
-+    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-+    LZ4_resetStream((LZ4_stream_t*)state);
-+    if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
- 
--_last_literals:
--  /* Encode Last Literals */
--  {
--    size_t const lastRun = (size_t)(iend - anchor);
--    if ((outputLimited) && /* Check output buffer overflow */
--        ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) >
--         (U32)maxOutputSize))
--      return 0;
--    if (lastRun >= RUN_MASK) {
--      size_t accumulator = lastRun - RUN_MASK;
--      *op++ = RUN_MASK << ML_BITS;
--      for (; accumulator >= 255; accumulator -= 255) *op++ = 255;
--      *op++ = (BYTE)accumulator;
-+    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-+        if (inputSize < LZ4_64Klimit)
-+            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited,                        byU16, noDict, noDictIssue, acceleration);
-+        else
-+            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-     } else {
--      *op++ = (BYTE)(lastRun << ML_BITS);
-+        if (inputSize < LZ4_64Klimit)
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput,                        byU16, noDict, noDictIssue, acceleration);
-+        else
-+            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-     }
--    memcpy(op, anchor, lastRun);
--    op += lastRun;
--  }
--
--  /* End */
--  return (int)(((char*)op) - dest);
- }
- 
--int LZ4_compress_fast_extState(void* state, const char* source, char* dest,
--                               int inputSize, int maxOutputSize,
--                               int acceleration) {
--  LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
--  LZ4_resetStream((LZ4_stream_t*)state);
--  if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
- 
--  if (maxOutputSize >= LZ4_compressBound(inputSize)) {
--    if (inputSize < LZ4_64Klimit)
--      return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited,
--                                  byU16, noDict, noDictIssue, acceleration);
--    else
--      return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited,
--                                  (sizeof(void*) == 8) ? byU32 : byPtr, noDict,
--                                  noDictIssue, acceleration);
--  } else {
--    if (inputSize < LZ4_64Klimit)
--      return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize,
--                                  limitedOutput, byU16, noDict, noDictIssue,
--                                  acceleration);
--    else
--      return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize,
--                                  limitedOutput,
--                                  (sizeof(void*) == 8) ? byU32 : byPtr, noDict,
--                                  noDictIssue, acceleration);
--  }
-+int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-+{
-+#if (LZ4_HEAPMODE)
-+    void* ctxPtr = ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-+#else
-+    LZ4_stream_t ctx;
-+    void* const ctxPtr = &ctx;
-+#endif
-+
-+    int const result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
-+
-+#if (LZ4_HEAPMODE)
-+    FREEMEM(ctxPtr);
-+#endif
-+    return result;
- }
- 
--int LZ4_compress_fast(const char* source, char* dest, int inputSize,
--                      int maxOutputSize, int acceleration) {
--#if (LZ4_HEAPMODE)
--  void* ctxPtr = ALLOCATOR(
--      1, sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
--#else
--  LZ4_stream_t ctx;
--  void* const ctxPtr = &ctx;
--#endif
- 
--  int const result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize,
--                                                maxOutputSize, acceleration);
--
--#if (LZ4_HEAPMODE)
--  FREEMEM(ctxPtr);
--#endif
--  return result;
-+int LZ4_compress_default(const char* source, char* dest, int inputSize, int maxOutputSize)
-+{
-+    return LZ4_compress_fast(source, dest, inputSize, maxOutputSize, 1);
- }
- 
--int LZ4_compress_default(const char* source, char* dest, int inputSize,
--                         int maxOutputSize) {
--  return LZ4_compress_fast(source, dest, inputSize, maxOutputSize, 1);
--}
- 
- /* hidden debug function */
--/* strangely enough, gcc generates faster code when this function is
-- * uncommented, even if unused */
--int LZ4_compress_fast_force(const char* source, char* dest, int inputSize,
--                            int maxOutputSize, int acceleration) {
--  LZ4_stream_t ctx;
--  LZ4_resetStream(&ctx);
-+/* strangely enough, gcc generates faster code when this function is uncommented, even if unused */
-+int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-+{
-+    LZ4_stream_t ctx;
-+    LZ4_resetStream(&ctx);
- 
--  if (inputSize < LZ4_64Klimit)
--    return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize,
--                                maxOutputSize, limitedOutput, byU16, noDict,
--                                noDictIssue, acceleration);
--  else
--    return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize,
--                                maxOutputSize, limitedOutput,
--                                sizeof(void*) == 8 ? byU32 : byPtr, noDict,
--                                noDictIssue, acceleration);
-+    if (inputSize < LZ4_64Klimit)
-+        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16,                        noDict, noDictIssue, acceleration);
-+    else
-+        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
- }
- 
-+
- /*-******************************
-- *  *_destSize() variant
-- ********************************/
-+*  *_destSize() variant
-+********************************/
- 
--static int LZ4_compress_destSize_generic(LZ4_stream_t_internal* const ctx,
--                                         const char* const src, char* const dst,
--                                         int* const srcSizePtr,
--                                         const int targetDstSize,
--                                         const tableType_t tableType) {
--  const BYTE* ip = (const BYTE*)src;
--  const BYTE* base = (const BYTE*)src;
--  const BYTE* lowLimit = (const BYTE*)src;
--  const BYTE* anchor = ip;
--  const BYTE* const iend = ip + *srcSizePtr;
--  const BYTE* const mflimit = iend - MFLIMIT;
--  const BYTE* const matchlimit = iend - LASTLITERALS;
-+static int LZ4_compress_destSize_generic(
-+                       LZ4_stream_t_internal* const ctx,
-+                 const char* const src,
-+                       char* const dst,
-+                       int*  const srcSizePtr,
-+                 const int targetDstSize,
-+                 const tableType_t tableType)
-+{
-+    const BYTE* ip = (const BYTE*) src;
-+    const BYTE* base = (const BYTE*) src;
-+    const BYTE* lowLimit = (const BYTE*) src;
-+    const BYTE* anchor = ip;
-+    const BYTE* const iend = ip + *srcSizePtr;
-+    const BYTE* const mflimit = iend - MFLIMIT;
-+    const BYTE* const matchlimit = iend - LASTLITERALS;
-+
-+    BYTE* op = (BYTE*) dst;
-+    BYTE* const oend = op + targetDstSize;
-+    BYTE* const oMaxLit = op + targetDstSize - 2 /* offset */ - 8 /* because 8+MINMATCH==MFLIMIT */ - 1 /* token */;
-+    BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
-+    BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
-+
-+    U32 forwardH;
-+
- 
--  BYTE* op = (BYTE*)dst;
--  BYTE* const oend = op + targetDstSize;
--  BYTE* const oMaxLit = op + targetDstSize - 2 /* offset */ -
--                        8 /* because 8+MINMATCH==MFLIMIT */ - 1 /* token */;
--  BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
--  BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
-+    /* Init conditions */
-+    if (targetDstSize < 1) return 0;                                     /* Impossible to store anything */
-+    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;            /* Unsupported input size, too large (or negative) */
-+    if ((tableType == byU16) && (*srcSizePtr>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
-+    if (*srcSizePtr<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
- 
--  U32 forwardH;
-+    /* First Byte */
-+    *srcSizePtr = 0;
-+    LZ4_putPosition(ip, ctx->hashTable, tableType, base);
-+    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-+
-+    /* Main Loop */
-+    for ( ; ; ) {
-+        const BYTE* match;
-+        BYTE* token;
- 
--  /* Init conditions */
--  if (targetDstSize < 1) return 0; /* Impossible to store anything */
--  if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE)
--    return 0; /* Unsupported input size, too large (or negative) */
--  if ((tableType == byU16) && (*srcSizePtr >= LZ4_64Klimit))
--    return 0; /* Size too large (not within 64K limit) */
--  if (*srcSizePtr < LZ4_minLength)
--    goto _last_literals; /* Input too small, no compression (all literals) */
-+        /* Find a match */
-+        {   const BYTE* forwardIp = ip;
-+            unsigned step = 1;
-+            unsigned searchMatchNb = 1 << LZ4_skipTrigger;
-+
-+            do {
-+                U32 h = forwardH;
-+                ip = forwardIp;
-+                forwardIp += step;
-+                step = (searchMatchNb++ >> LZ4_skipTrigger);
-+
-+                if (unlikely(forwardIp > mflimit)) goto _last_literals;
-+
-+                match = LZ4_getPositionOnHash(h, ctx->hashTable, tableType, base);
-+                forwardH = LZ4_hashPosition(forwardIp, tableType);
-+                LZ4_putPositionOnHash(ip, h, ctx->hashTable, tableType, base);
-+
-+            } while ( ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
-+                || (LZ4_read32(match) != LZ4_read32(ip)) );
-+        }
- 
--  /* First Byte */
--  *srcSizePtr = 0;
--  LZ4_putPosition(ip, ctx->hashTable, tableType, base);
--  ip++;
--  forwardH = LZ4_hashPosition(ip, tableType);
-+        /* Catch up */
-+        while ((ip>anchor) && (match > lowLimit) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
- 
--  /* Main Loop */
--  for (;;) {
--    const BYTE* match;
--    BYTE* token;
-+        /* Encode Literal length */
-+        {   unsigned litLength = (unsigned)(ip - anchor);
-+            token = op++;
-+            if (op + ((litLength+240)/255) + litLength > oMaxLit) {
-+                /* Not enough space for a last match */
-+                op--;
-+                goto _last_literals;
-+            }
-+            if (litLength>=RUN_MASK) {
-+                unsigned len = litLength - RUN_MASK;
-+                *token=(RUN_MASK<<ML_BITS);
-+                for(; len >= 255 ; len-=255) *op++ = 255;
-+                *op++ = (BYTE)len;
-+            }
-+            else *token = (BYTE)(litLength<<ML_BITS);
- 
--    /* Find a match */
--    {
--      const BYTE* forwardIp = ip;
--      unsigned step = 1;
--      unsigned searchMatchNb = 1 << LZ4_skipTrigger;
-+            /* Copy Literals */
-+            LZ4_wildCopy(op, anchor, op+litLength);
-+            op += litLength;
-+        }
-+
-+_next_match:
-+        /* Encode Offset */
-+        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
-+
-+        /* Encode MatchLength */
-+        {   size_t matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
- 
--      do {
--        U32 h = forwardH;
--        ip = forwardIp;
--        forwardIp += step;
--        step = (searchMatchNb++ >> LZ4_skipTrigger);
-+            if (op + ((matchLength+240)/255) > oMaxMatch) {
-+                /* Match description too long : reduce it */
-+                matchLength = (15-1) + (oMaxMatch-op) * 255;
-+            }
-+            ip += MINMATCH + matchLength;
- 
--        if (unlikely(forwardIp > mflimit)) goto _last_literals;
-+            if (matchLength>=ML_MASK) {
-+                *token += ML_MASK;
-+                matchLength -= ML_MASK;
-+                while (matchLength >= 255) { matchLength-=255; *op++ = 255; }
-+                *op++ = (BYTE)matchLength;
-+            }
-+            else *token += (BYTE)(matchLength);
-+        }
-+
-+        anchor = ip;
- 
--        match = LZ4_getPositionOnHash(h, ctx->hashTable, tableType, base);
--        forwardH = LZ4_hashPosition(forwardIp, tableType);
--        LZ4_putPositionOnHash(ip, h, ctx->hashTable, tableType, base);
-+        /* Test end of block */
-+        if (ip > mflimit) break;
-+        if (op > oMaxSeq) break;
-+
-+        /* Fill table */
-+        LZ4_putPosition(ip-2, ctx->hashTable, tableType, base);
- 
--      } while (((tableType == byU16) ? 0 : (match + MAX_DISTANCE < ip)) ||
--               (LZ4_read32(match) != LZ4_read32(ip)));
--    }
-+        /* Test next position */
-+        match = LZ4_getPosition(ip, ctx->hashTable, tableType, base);
-+        LZ4_putPosition(ip, ctx->hashTable, tableType, base);
-+        if ( (match+MAX_DISTANCE>=ip)
-+            && (LZ4_read32(match)==LZ4_read32(ip)) )
-+        { token=op++; *token=0; goto _next_match; }
- 
--    /* Catch up */
--    while ((ip > anchor) && (match > lowLimit) &&
--           (unlikely(ip[-1] == match[-1]))) {
--      ip--;
--      match--;
-+        /* Prepare next loop */
-+        forwardH = LZ4_hashPosition(++ip, tableType);
-     }
- 
--    /* Encode Literal length */
--    {
--      unsigned litLength = (unsigned)(ip - anchor);
--      token = op++;
--      if (op + ((litLength + 240) / 255) + litLength > oMaxLit) {
--        /* Not enough space for a last match */
--        op--;
--        goto _last_literals;
--      }
--      if (litLength >= RUN_MASK) {
--        unsigned len = litLength - RUN_MASK;
--        *token = (RUN_MASK << ML_BITS);
--        for (; len >= 255; len -= 255) *op++ = 255;
--        *op++ = (BYTE)len;
--      } else
--        *token = (BYTE)(litLength << ML_BITS);
--
--      /* Copy Literals */
--      LZ4_wildCopy(op, anchor, op + litLength);
--      op += litLength;
--    }
--
--  _next_match:
--    /* Encode Offset */
--    LZ4_writeLE16(op, (U16)(ip - match));
--    op += 2;
--
--    /* Encode MatchLength */
--    {
--      size_t matchLength =
--          LZ4_count(ip + MINMATCH, match + MINMATCH, matchlimit);
--
--      if (op + ((matchLength + 240) / 255) > oMaxMatch) {
--        /* Match description too long : reduce it */
--        matchLength = (15 - 1) + (oMaxMatch - op) * 255;
--      }
--      ip += MINMATCH + matchLength;
--
--      if (matchLength >= ML_MASK) {
--        *token += ML_MASK;
--        matchLength -= ML_MASK;
--        while (matchLength >= 255) {
--          matchLength -= 255;
--          *op++ = 255;
--        }
--        *op++ = (BYTE)matchLength;
--      } else
--        *token += (BYTE)(matchLength);
--    }
--
--    anchor = ip;
--
--    /* Test end of block */
--    if (ip > mflimit) break;
--    if (op > oMaxSeq) break;
--
--    /* Fill table */
--    LZ4_putPosition(ip - 2, ctx->hashTable, tableType, base);
--
--    /* Test next position */
--    match = LZ4_getPosition(ip, ctx->hashTable, tableType, base);
--    LZ4_putPosition(ip, ctx->hashTable, tableType, base);
--    if ((match + MAX_DISTANCE >= ip) && (LZ4_read32(match) == LZ4_read32(ip))) {
--      token = op++;
--      *token = 0;
--      goto _next_match;
--    }
--
--    /* Prepare next loop */
--    forwardH = LZ4_hashPosition(++ip, tableType);
--  }
--
- _last_literals:
--  /* Encode Last Literals */
--  {
--    size_t lastRunSize = (size_t)(iend - anchor);
--    if (op + 1 /* token */ + ((lastRunSize + 240) / 255) /* litLength */ +
--            lastRunSize /* literals */
--        > oend) {
--      /* adapt lastRunSize to fill 'dst' */
--      lastRunSize = (oend - op) - 1;
--      lastRunSize -= (lastRunSize + 240) / 255;
--    }
--    ip = anchor + lastRunSize;
-+    /* Encode Last Literals */
-+    {   size_t lastRunSize = (size_t)(iend - anchor);
-+        if (op + 1 /* token */ + ((lastRunSize+240)/255) /* litLength */ + lastRunSize /* literals */ > oend) {
-+            /* adapt lastRunSize to fill 'dst' */
-+            lastRunSize  = (oend-op) - 1;
-+            lastRunSize -= (lastRunSize+240)/255;
-+        }
-+        ip = anchor + lastRunSize;
- 
--    if (lastRunSize >= RUN_MASK) {
--      size_t accumulator = lastRunSize - RUN_MASK;
--      *op++ = RUN_MASK << ML_BITS;
--      for (; accumulator >= 255; accumulator -= 255) *op++ = 255;
--      *op++ = (BYTE)accumulator;
--    } else {
--      *op++ = (BYTE)(lastRunSize << ML_BITS);
-+        if (lastRunSize >= RUN_MASK) {
-+            size_t accumulator = lastRunSize - RUN_MASK;
-+            *op++ = RUN_MASK << ML_BITS;
-+            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-+            *op++ = (BYTE) accumulator;
-+        } else {
-+            *op++ = (BYTE)(lastRunSize<<ML_BITS);
-+        }
-+        memcpy(op, anchor, lastRunSize);
-+        op += lastRunSize;
-     }
--    memcpy(op, anchor, lastRunSize);
--    op += lastRunSize;
--  }
-+
-+    /* End */
-+    *srcSizePtr = (int) (((const char*)ip)-src);
-+    return (int) (((char*)op)-dst);
-+}
-+
- 
--  /* End */
--  *srcSizePtr = (int)(((const char*)ip) - src);
--  return (int)(((char*)op) - dst);
-+static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-+{
-+    LZ4_resetStream(state);
-+
-+    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-+        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
-+    } else {
-+        if (*srcSizePtr < LZ4_64Klimit)
-+            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16);
-+        else
-+            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr);
-+    }
- }
- 
--static int LZ4_compress_destSize_extState(LZ4_stream_t* state, const char* src,
--                                          char* dst, int* srcSizePtr,
--                                          int targetDstSize) {
--  LZ4_resetStream(state);
- 
--  if (targetDstSize >=
--      LZ4_compressBound(*srcSizePtr)) { /* compression success is guaranteed */
--    return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr,
--                                      targetDstSize, 1);
--  } else {
--    if (*srcSizePtr < LZ4_64Klimit)
--      return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst,
--                                           srcSizePtr, targetDstSize, byU16);
--    else
--      return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst,
--                                           srcSizePtr, targetDstSize,
--                                           sizeof(void*) == 8 ? byU32 : byPtr);
--  }
--}
--
--int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr,
--                          int targetDstSize) {
-+int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-+{
- #if (LZ4_HEAPMODE)
--  LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(
--      1, sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
-+    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
- #else
--  LZ4_stream_t ctxBody;
--  LZ4_stream_t* ctx = &ctxBody;
-+    LZ4_stream_t ctxBody;
-+    LZ4_stream_t* ctx = &ctxBody;
- #endif
- 
--  int result =
--      LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
-+    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
- 
- #if (LZ4_HEAPMODE)
--  FREEMEM(ctx);
-+    FREEMEM(ctx);
- #endif
--  return result;
-+    return result;
- }
- 
-+
-+
- /*-******************************
-- *  Streaming functions
-- ********************************/
-+*  Streaming functions
-+********************************/
- 
--LZ4_stream_t* LZ4_createStream(void) {
--  LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
--  LZ4_STATIC_ASSERT(
--      LZ4_STREAMSIZE >=
--      sizeof(LZ4_stream_t_internal)); /* A compilation error here means
--                                         LZ4_STREAMSIZE is not large enough */
--  LZ4_resetStream(lz4s);
--  return lz4s;
-+LZ4_stream_t* LZ4_createStream(void)
-+{
-+    LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
-+    LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
-+    LZ4_resetStream(lz4s);
-+    return lz4s;
- }
- 
--void LZ4_resetStream(LZ4_stream_t* LZ4_stream) {
--  DEBUGLOG(4, "LZ4_resetStream");
--  MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
-+void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
-+{
-+    DEBUGLOG(4, "LZ4_resetStream");
-+    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
- }
- 
--int LZ4_freeStream(LZ4_stream_t* LZ4_stream) {
--  if (!LZ4_stream) return 0; /* support free on NULL */
--  FREEMEM(LZ4_stream);
--  return (0);
-+int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
-+{
-+    if (!LZ4_stream) return 0;   /* support free on NULL */
-+    FREEMEM(LZ4_stream);
-+    return (0);
- }
- 
-+
- #define HASH_UNIT sizeof(reg_t)
--int LZ4_loadDict(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) {
--  LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
--  const BYTE* p = (const BYTE*)dictionary;
--  const BYTE* const dictEnd = p + dictSize;
--  const BYTE* base;
-+int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
-+{
-+    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
-+    const BYTE* p = (const BYTE*)dictionary;
-+    const BYTE* const dictEnd = p + dictSize;
-+    const BYTE* base;
- 
--  if ((dict->initCheck) ||
--      (dict->currentOffset >
--       1 GB)) /* Uninitialized structure, or reuse overflow */
--    LZ4_resetStream(LZ4_dict);
-+    if ((dict->initCheck) || (dict->currentOffset > 1 GB))  /* Uninitialized structure, or reuse overflow */
-+        LZ4_resetStream(LZ4_dict);
- 
--  if (dictSize < (int)HASH_UNIT) {
--    dict->dictionary = NULL;
--    dict->dictSize = 0;
--    return 0;
--  }
-+    if (dictSize < (int)HASH_UNIT) {
-+        dict->dictionary = NULL;
-+        dict->dictSize = 0;
-+        return 0;
-+    }
- 
--  if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
--  dict->currentOffset += 64 KB;
--  base = p - dict->currentOffset;
--  dict->dictionary = p;
--  dict->dictSize = (U32)(dictEnd - p);
--  dict->currentOffset += dict->dictSize;
-+    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-+    dict->currentOffset += 64 KB;
-+    base = p - dict->currentOffset;
-+    dict->dictionary = p;
-+    dict->dictSize = (U32)(dictEnd - p);
-+    dict->currentOffset += dict->dictSize;
- 
--  while (p <= dictEnd - HASH_UNIT) {
--    LZ4_putPosition(p, dict->hashTable, byU32, base);
--    p += 3;
--  }
-+    while (p <= dictEnd-HASH_UNIT) {
-+        LZ4_putPosition(p, dict->hashTable, byU32, base);
-+        p+=3;
-+    }
- 
--  return dict->dictSize;
-+    return dict->dictSize;
- }
- 
--static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src) {
--  if ((LZ4_dict->currentOffset > 0x80000000) ||
--      ((uptrval)LZ4_dict->currentOffset >
--       (uptrval)src)) { /* address space overflow */
--    /* rescale hash table */
--    U32 const delta = LZ4_dict->currentOffset - 64 KB;
--    const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
--    int i;
--    for (i = 0; i < LZ4_HASH_SIZE_U32; i++) {
--      if (LZ4_dict->hashTable[i] < delta)
--        LZ4_dict->hashTable[i] = 0;
--      else
--        LZ4_dict->hashTable[i] -= delta;
-+
-+static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
-+{
-+    if ((LZ4_dict->currentOffset > 0x80000000) ||
-+        ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) {   /* address space overflow */
-+        /* rescale hash table */
-+        U32 const delta = LZ4_dict->currentOffset - 64 KB;
-+        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-+        int i;
-+        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-+            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-+            else LZ4_dict->hashTable[i] -= delta;
-+        }
-+        LZ4_dict->currentOffset = 64 KB;
-+        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-+        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-     }
--    LZ4_dict->currentOffset = 64 KB;
--    if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
--    LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
--  }
- }
- 
--int LZ4_compress_fast_continue(LZ4_stream_t* LZ4_stream, const char* source,
--                               char* dest, int inputSize, int maxOutputSize,
--                               int acceleration) {
--  LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
--  const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-+
-+int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-+{
-+    LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
-+    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
- 
--  const BYTE* smallest = (const BYTE*)source;
--  if (streamPtr->initCheck) return 0; /* Uninitialized structure detected */
--  if ((streamPtr->dictSize > 0) && (smallest > dictEnd)) smallest = dictEnd;
--  LZ4_renormDictT(streamPtr, smallest);
--  if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
-+    const BYTE* smallest = (const BYTE*) source;
-+    if (streamPtr->initCheck) return 0;   /* Uninitialized structure detected */
-+    if ((streamPtr->dictSize>0) && (smallest>dictEnd)) smallest = dictEnd;
-+    LZ4_renormDictT(streamPtr, smallest);
-+    if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
-+
-+    /* Check overlapping input/dictionary space */
-+    {   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
-+        if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-+            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-+            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-+            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-+            streamPtr->dictionary = dictEnd - streamPtr->dictSize;
-+        }
-+    }
- 
--  /* Check overlapping input/dictionary space */
--  {
--    const BYTE* sourceEnd = (const BYTE*)source + inputSize;
--    if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
--      streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
--      if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
--      if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
--      streamPtr->dictionary = dictEnd - streamPtr->dictSize;
-+    /* prefix mode : source data follows dictionary */
-+    if (dictEnd == (const BYTE*)source) {
-+        int result;
-+        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-+            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
-+        else
-+            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
-+        streamPtr->dictSize += (U32)inputSize;
-+        streamPtr->currentOffset += (U32)inputSize;
-+        return result;
-     }
--  }
- 
--  /* prefix mode : source data follows dictionary */
--  if (dictEnd == (const BYTE*)source) {
-+    /* external dictionary mode */
-+    {   int result;
-+        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-+            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
-+        else
-+            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
-+        streamPtr->dictionary = (const BYTE*)source;
-+        streamPtr->dictSize = (U32)inputSize;
-+        streamPtr->currentOffset += (U32)inputSize;
-+        return result;
-+    }
-+}
-+
-+
-+/* Hidden debug function, to force external dictionary mode */
-+int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int inputSize)
-+{
-+    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
-     int result;
--    if ((streamPtr->dictSize < 64 KB) &&
--        (streamPtr->dictSize < streamPtr->currentOffset))
--      result = LZ4_compress_generic(streamPtr, source, dest, inputSize,
--                                    maxOutputSize, limitedOutput, byU32,
--                                    withPrefix64k, dictSmall, acceleration);
--    else
--      result = LZ4_compress_generic(streamPtr, source, dest, inputSize,
--                                    maxOutputSize, limitedOutput, byU32,
--                                    withPrefix64k, noDictIssue, acceleration);
--    streamPtr->dictSize += (U32)inputSize;
--    streamPtr->currentOffset += (U32)inputSize;
--    return result;
--  }
-+    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
- 
--  /* external dictionary mode */
--  {
--    int result;
--    if ((streamPtr->dictSize < 64 KB) &&
--        (streamPtr->dictSize < streamPtr->currentOffset))
--      result = LZ4_compress_generic(streamPtr, source, dest, inputSize,
--                                    maxOutputSize, limitedOutput, byU32,
--                                    usingExtDict, dictSmall, acceleration);
--    else
--      result = LZ4_compress_generic(streamPtr, source, dest, inputSize,
--                                    maxOutputSize, limitedOutput, byU32,
--                                    usingExtDict, noDictIssue, acceleration);
-+    const BYTE* smallest = dictEnd;
-+    if (smallest > (const BYTE*) source) smallest = (const BYTE*) source;
-+    LZ4_renormDictT(streamPtr, smallest);
-+
-+    result = LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-+
-     streamPtr->dictionary = (const BYTE*)source;
-     streamPtr->dictSize = (U32)inputSize;
-     streamPtr->currentOffset += (U32)inputSize;
-+
-     return result;
--  }
--}
--
--/* Hidden debug function, to force external dictionary mode */
--int LZ4_compress_forceExtDict(LZ4_stream_t* LZ4_dict, const char* source,
--                              char* dest, int inputSize) {
--  LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
--  int result;
--  const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
--
--  const BYTE* smallest = dictEnd;
--  if (smallest > (const BYTE*)source) smallest = (const BYTE*)source;
--  LZ4_renormDictT(streamPtr, smallest);
--
--  result =
--      LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited,
--                           byU32, usingExtDict, noDictIssue, 1);
--
--  streamPtr->dictionary = (const BYTE*)source;
--  streamPtr->dictSize = (U32)inputSize;
--  streamPtr->currentOffset += (U32)inputSize;
--
--  return result;
- }
- 
--/*! LZ4_saveDict() :
-- *  If previously compressed data block is not guaranteed to remain available at
-- * its memory location, save it into a safer place (char* safeBuffer). Note :
-- * you don't need to call LZ4_loadDict() afterwards, dictionary is immediately
-- * usable, you can therefore call LZ4_compress_fast_continue(). Return :
-- * saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
-- */
--int LZ4_saveDict(LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize) {
--  LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
--  const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
- 
--  if ((U32)dictSize > 64 KB)
--    dictSize = 64 KB; /* useless to define a dictionary > 64 KB */
--  if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
-+/*! LZ4_saveDict() :
-+ *  If previously compressed data block is not guaranteed to remain available at its memory location,
-+ *  save it into a safer place (char* safeBuffer).
-+ *  Note : you don't need to call LZ4_loadDict() afterwards,
-+ *         dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue().
-+ *  Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
-+ */
-+int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
-+{
-+    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-+    const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
- 
--  memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
-+    if ((U32)dictSize > 64 KB) dictSize = 64 KB;   /* useless to define a dictionary > 64 KB */
-+    if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
-+
-+    memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
- 
--  dict->dictionary = (const BYTE*)safeBuffer;
--  dict->dictSize = (U32)dictSize;
-+    dict->dictionary = (const BYTE*)safeBuffer;
-+    dict->dictSize = (U32)dictSize;
- 
--  return dictSize;
-+    return dictSize;
- }
- 
-+
-+
- /*-*****************************
-- *  Decompression functions
-- *******************************/
-+*  Decompression functions
-+*******************************/
- /*! LZ4_decompress_generic() :
-  *  This generic decompression function covers all use cases.
-  *  It shall be instantiated several times, using different sets of directives.
-- *  Note that it is important for performance that this function really get
-- * inlined, in order to remove useless branches during compilation optimization.
-+ *  Note that it is important for performance that this function really get inlined,
-+ *  in order to remove useless branches during compilation optimization.
-  */
- LZ4_FORCE_O2_GCC_PPC64LE
- LZ4_FORCE_INLINE int LZ4_decompress_generic(
--    const char* const src, char* const dst, int srcSize,
--    int outputSize, /* If endOnInput==endOnInputSize, this value is
--                       `dstCapacity` */
-+                 const char* const src,
-+                 char* const dst,
-+                 int srcSize,
-+                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
-+
-+                 int endOnInput,         /* endOnOutputSize, endOnInputSize */
-+                 int partialDecoding,    /* full, partial */
-+                 int targetOutputSize,   /* only used if partialDecoding==partial */
-+                 int dict,               /* noDict, withPrefix64k, usingExtDict */
-+                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
-+                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-+                 const size_t dictSize         /* note : = 0 if noDict */
-+                 )
-+{
-+    const BYTE* ip = (const BYTE*) src;
-+    const BYTE* const iend = ip + srcSize;
- 
--    int endOnInput,              /* endOnOutputSize, endOnInputSize */
--    int partialDecoding,         /* full, partial */
--    int targetOutputSize,        /* only used if partialDecoding==partial */
--    int dict,                    /* noDict, withPrefix64k, usingExtDict */
--    const BYTE* const lowPrefix, /* always <= dst, == dst when no prefix */
--    const BYTE* const dictStart, /* only if dict==usingExtDict */
--    const size_t dictSize        /* note : = 0 if noDict */
--) {
--  const BYTE* ip = (const BYTE*)src;
--  const BYTE* const iend = ip + srcSize;
-+    BYTE* op = (BYTE*) dst;
-+    BYTE* const oend = op + outputSize;
-+    BYTE* cpy;
-+    BYTE* oexit = op + targetOutputSize;
-+
-+    const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
-+    const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
-+    const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
-+
-+    const int safeDecode = (endOnInput==endOnInputSize);
-+    const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
-+
-+
-+    /* Special cases */
-+    if ((partialDecoding) && (oexit > oend-MFLIMIT)) oexit = oend-MFLIMIT;                      /* targetOutputSize too high => just decode everything */
-+    if ((endOnInput) && (unlikely(outputSize==0))) return ((srcSize==1) && (*ip==0)) ? 0 : -1;  /* Empty output buffer */
-+    if ((!endOnInput) && (unlikely(outputSize==0))) return (*ip==0?1:-1);
- 
--  BYTE* op = (BYTE*)dst;
--  BYTE* const oend = op + outputSize;
--  BYTE* cpy;
--  BYTE* oexit = op + targetOutputSize;
-+    /* Main Loop : decode sequences */
-+    while (1) {
-+        size_t length;
-+        const BYTE* match;
-+        size_t offset;
- 
--  const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
--  const unsigned inc32table[8] = {0, 1, 2, 1, 0, 4, 4, 4};
--  const int dec64table[8] = {0, 0, 0, -1, -4, 1, 2, 3};
-+        unsigned const token = *ip++;
- 
--  const int safeDecode = (endOnInput == endOnInputSize);
--  const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
-+        /* shortcut for common case :
-+         * in most circumstances, we expect to decode small matches (<= 18 bytes) separated by few literals (<= 14 bytes).
-+         * this shortcut was tested on x86 and x64, where it improves decoding speed.
-+         * it has not yet been benchmarked on ARM, Power, mips, etc. */
-+        if (((ip + 14 /*maxLL*/ + 2 /*offset*/ <= iend)
-+          & (op + 14 /*maxLL*/ + 18 /*maxML*/ <= oend))
-+          & ((token < (15<<ML_BITS)) & ((token & ML_MASK) != 15)) ) {
-+            size_t const ll = token >> ML_BITS;
-+            size_t const off = LZ4_readLE16(ip+ll);
-+            const BYTE* const matchPtr = op + ll - off;  /* pointer underflow risk ? */
-+            if ((off >= 18) /* do not deal with overlapping matches */ & (matchPtr >= lowPrefix)) {
-+                size_t const ml = (token & ML_MASK) + MINMATCH;
-+                memcpy(op, ip, 16); op += ll; ip += ll + 2 /*offset*/;
-+                memcpy(op, matchPtr, 18); op += ml;
-+                continue;
-+            }
-+        }
- 
--  /* Special cases */
--  if ((partialDecoding) && (oexit > oend - MFLIMIT))
--    oexit = oend -
--            MFLIMIT; /* targetOutputSize too high => just decode everything */
--  if ((endOnInput) && (unlikely(outputSize == 0)))
--    return ((srcSize == 1) && (*ip == 0)) ? 0 : -1; /* Empty output buffer */
--  if ((!endOnInput) && (unlikely(outputSize == 0))) return (*ip == 0 ? 1 : -1);
-+        /* decode literal length */
-+        if ((length=(token>>ML_BITS)) == RUN_MASK) {
-+            unsigned s;
-+            do {
-+                s = *ip++;
-+                length += s;
-+            } while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) & (s==255) );
-+            if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) goto _output_error;   /* overflow detection */
-+            if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) goto _output_error;   /* overflow detection */
-+        }
- 
--  /* Main Loop : decode sequences */
--  while (1) {
--    size_t length;
--    const BYTE* match;
--    size_t offset;
-+        /* copy literals */
-+        cpy = op+length;
-+        if ( ((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
-+            || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
-+        {
-+            if (partialDecoding) {
-+                if (cpy > oend) goto _output_error;                           /* Error : write attempt beyond end of output buffer */
-+                if ((endOnInput) && (ip+length > iend)) goto _output_error;   /* Error : read attempt beyond end of input buffer */
-+            } else {
-+                if ((!endOnInput) && (cpy != oend)) goto _output_error;       /* Error : block decoding must stop exactly there */
-+                if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) goto _output_error;   /* Error : input must be consumed */
-+            }
-+            memcpy(op, ip, length);
-+            ip += length;
-+            op += length;
-+            break;     /* Necessarily EOF, due to parsing restrictions */
-+        }
-+        LZ4_wildCopy(op, ip, cpy);
-+        ip += length; op = cpy;
- 
--    unsigned const token = *ip++;
-+        /* get offset */
-+        offset = LZ4_readLE16(ip); ip+=2;
-+        match = op - offset;
-+        if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
-+        LZ4_write32(op, (U32)offset);   /* costs ~1%; silence an msan warning when offset==0 */
-+
-+        /* get matchlength */
-+        length = token & ML_MASK;
-+        if (length == ML_MASK) {
-+            unsigned s;
-+            do {
-+                s = *ip++;
-+                if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
-+                length += s;
-+            } while (s==255);
-+            if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-+        }
-+        length += MINMATCH;
-+
-+        /* check external dictionary */
-+        if ((dict==usingExtDict) && (match < lowPrefix)) {
-+            if (unlikely(op+length > oend-LASTLITERALS)) goto _output_error;   /* doesn't respect parsing restriction */
- 
--    /* shortcut for common case :
--     * in most circumstances, we expect to decode small matches (<= 18 bytes)
--     * separated by few literals (<= 14 bytes). this shortcut was tested on x86
--     * and x64, where it improves decoding speed. it has not yet been
--     * benchmarked on ARM, Power, mips, etc. */
--    if (((ip + 14 /*maxLL*/ + 2 /*offset*/ <= iend) &
--         (op + 14 /*maxLL*/ + 18 /*maxML*/ <= oend)) &
--        ((token < (15 << ML_BITS)) & ((token & ML_MASK) != 15))) {
--      size_t const ll = token >> ML_BITS;
--      size_t const off = LZ4_readLE16(ip + ll);
--      const BYTE* const matchPtr = op + ll - off; /* pointer underflow risk ? */
--      if ((off >= 18) /* do not deal with overlapping matches */ &
--          (matchPtr >= lowPrefix)) {
--        size_t const ml = (token & ML_MASK) + MINMATCH;
--        memcpy(op, ip, 16);
--        op += ll;
--        ip += ll + 2 /*offset*/;
--        memcpy(op, matchPtr, 18);
--        op += ml;
--        continue;
--      }
--    }
-+            if (length <= (size_t)(lowPrefix-match)) {
-+                /* match can be copied as a single segment from external dictionary */
-+                memmove(op, dictEnd - (lowPrefix-match), length);
-+                op += length;
-+            } else {
-+                /* match encompass external dictionary and current block */
-+                size_t const copySize = (size_t)(lowPrefix-match);
-+                size_t const restSize = length - copySize;
-+                memcpy(op, dictEnd - copySize, copySize);
-+                op += copySize;
-+                if (restSize > (size_t)(op-lowPrefix)) {  /* overlap copy */
-+                    BYTE* const endOfMatch = op + restSize;
-+                    const BYTE* copyFrom = lowPrefix;
-+                    while (op < endOfMatch) *op++ = *copyFrom++;
-+                } else {
-+                    memcpy(op, lowPrefix, restSize);
-+                    op += restSize;
-+            }   }
-+            continue;
-+        }
- 
--    /* decode literal length */
--    if ((length = (token >> ML_BITS)) == RUN_MASK) {
--      unsigned s;
--      do {
--        s = *ip++;
--        length += s;
--      } while (likely(endOnInput ? ip < iend - RUN_MASK : 1) & (s == 255));
--      if ((safeDecode) && unlikely((uptrval)(op) + length < (uptrval)(op)))
--        goto _output_error; /* overflow detection */
--      if ((safeDecode) && unlikely((uptrval)(ip) + length < (uptrval)(ip)))
--        goto _output_error; /* overflow detection */
-+        /* copy match within block */
-+        cpy = op + length;
-+        if (unlikely(offset<8)) {
-+            op[0] = match[0];
-+            op[1] = match[1];
-+            op[2] = match[2];
-+            op[3] = match[3];
-+            match += inc32table[offset];
-+            memcpy(op+4, match, 4);
-+            match -= dec64table[offset];
-+        } else { LZ4_copy8(op, match); match+=8; }
-+        op += 8;
-+
-+        if (unlikely(cpy>oend-12)) {
-+            BYTE* const oCopyLimit = oend-(WILDCOPYLENGTH-1);
-+            if (cpy > oend-LASTLITERALS) goto _output_error;    /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-+            if (op < oCopyLimit) {
-+                LZ4_wildCopy(op, match, oCopyLimit);
-+                match += oCopyLimit - op;
-+                op = oCopyLimit;
-+            }
-+            while (op<cpy) *op++ = *match++;
-+        } else {
-+            LZ4_copy8(op, match);
-+            if (length>16) LZ4_wildCopy(op+8, match+8, cpy);
-+        }
-+        op = cpy;   /* correction */
-     }
- 
--    /* copy literals */
--    cpy = op + length;
--    if (((endOnInput) && ((cpy > (partialDecoding ? oexit : oend - MFLIMIT)) ||
--                          (ip + length > iend - (2 + 1 + LASTLITERALS)))) ||
--        ((!endOnInput) && (cpy > oend - WILDCOPYLENGTH))) {
--      if (partialDecoding) {
--        if (cpy > oend)
--          goto _output_error; /* Error : write attempt beyond end of output
--                                 buffer */
--        if ((endOnInput) && (ip + length > iend))
--          goto _output_error; /* Error : read attempt beyond end of input buffer
--                               */
--      } else {
--        if ((!endOnInput) && (cpy != oend))
--          goto _output_error; /* Error : block decoding must stop exactly there
--                               */
--        if ((endOnInput) && ((ip + length != iend) || (cpy > oend)))
--          goto _output_error; /* Error : input must be consumed */
--      }
--      memcpy(op, ip, length);
--      ip += length;
--      op += length;
--      break; /* Necessarily EOF, due to parsing restrictions */
--    }
--    LZ4_wildCopy(op, ip, cpy);
--    ip += length;
--    op = cpy;
--
--    /* get offset */
--    offset = LZ4_readLE16(ip);
--    ip += 2;
--    match = op - offset;
--    if ((checkOffset) && (unlikely(match + dictSize < lowPrefix)))
--      goto _output_error; /* Error : offset outside buffers */
--    LZ4_write32(
--        op,
--        (U32)offset); /* costs ~1%; silence an msan warning when offset==0 */
--
--    /* get matchlength */
--    length = token & ML_MASK;
--    if (length == ML_MASK) {
--      unsigned s;
--      do {
--        s = *ip++;
--        if ((endOnInput) && (ip > iend - LASTLITERALS)) goto _output_error;
--        length += s;
--      } while (s == 255);
--      if ((safeDecode) && unlikely((uptrval)(op) + length < (uptrval)op))
--        goto _output_error; /* overflow detection */
--    }
--    length += MINMATCH;
--
--    /* check external dictionary */
--    if ((dict == usingExtDict) && (match < lowPrefix)) {
--      if (unlikely(op + length > oend - LASTLITERALS))
--        goto _output_error; /* doesn't respect parsing restriction */
-+    /* end of decoding */
-+    if (endOnInput)
-+       return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
-+    else
-+       return (int) (((const char*)ip)-src);   /* Nb of input bytes read */
- 
--      if (length <= (size_t)(lowPrefix - match)) {
--        /* match can be copied as a single segment from external dictionary */
--        memmove(op, dictEnd - (lowPrefix - match), length);
--        op += length;
--      } else {
--        /* match encompass external dictionary and current block */
--        size_t const copySize = (size_t)(lowPrefix - match);
--        size_t const restSize = length - copySize;
--        memcpy(op, dictEnd - copySize, copySize);
--        op += copySize;
--        if (restSize > (size_t)(op - lowPrefix)) { /* overlap copy */
--          BYTE* const endOfMatch = op + restSize;
--          const BYTE* copyFrom = lowPrefix;
--          while (op < endOfMatch) *op++ = *copyFrom++;
--        } else {
--          memcpy(op, lowPrefix, restSize);
--          op += restSize;
--        }
--      }
--      continue;
--    }
-+    /* Overflow error detected */
-+_output_error:
-+    return (int) (-(((const char*)ip)-src))-1;
-+}
- 
--    /* copy match within block */
--    cpy = op + length;
--    if (unlikely(offset < 8)) {
--      op[0] = match[0];
--      op[1] = match[1];
--      op[2] = match[2];
--      op[3] = match[3];
--      match += inc32table[offset];
--      memcpy(op + 4, match, 4);
--      match -= dec64table[offset];
--    } else {
--      LZ4_copy8(op, match);
--      match += 8;
--    }
--    op += 8;
- 
--    if (unlikely(cpy > oend - 12)) {
--      BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH - 1);
--      if (cpy > oend - LASTLITERALS)
--        goto _output_error; /* Error : last LASTLITERALS bytes must be literals
--                               (uncompressed) */
--      if (op < oCopyLimit) {
--        LZ4_wildCopy(op, match, oCopyLimit);
--        match += oCopyLimit - op;
--        op = oCopyLimit;
--      }
--      while (op < cpy) *op++ = *match++;
--    } else {
--      LZ4_copy8(op, match);
--      if (length > 16) LZ4_wildCopy(op + 8, match + 8, cpy);
--    }
--    op = cpy; /* correction */
--  }
--
--  /* end of decoding */
--  if (endOnInput)
--    return (int)(((char*)op) - dst); /* Nb of output bytes decoded */
--  else
--    return (int)(((const char*)ip) - src); /* Nb of input bytes read */
--
--  /* Overflow error detected */
--_output_error:
--  return (int)(-(((const char*)ip) - src)) - 1;
-+LZ4_FORCE_O2_GCC_PPC64LE
-+int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, full, 0, noDict, (BYTE*)dest, NULL, 0);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe(const char* source, char* dest, int compressedSize,
--                        int maxDecompressedSize) {
--  return LZ4_decompress_generic(source, dest, compressedSize,
--                                maxDecompressedSize, endOnInputSize, full, 0,
--                                noDict, (BYTE*)dest, NULL, 0);
--}
--
--LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_partial(const char* source, char* dest,
--                                int compressedSize, int targetOutputSize,
--                                int maxDecompressedSize) {
--  return LZ4_decompress_generic(source, dest, compressedSize,
--                                maxDecompressedSize, endOnInputSize, partial,
--                                targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
-+int LZ4_decompress_safe_partial(const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, partial, targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_fast(const char* source, char* dest, int originalSize) {
--  return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize,
--                                full, 0, withPrefix64k, (BYTE*)(dest - 64 KB),
--                                NULL, 64 KB);
-+int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
-+{
-+    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
- }
- 
-+
- /*===== streaming decompression functions =====*/
- 
--LZ4_streamDecode_t* LZ4_createStreamDecode(void) {
--  LZ4_streamDecode_t* lz4s =
--      (LZ4_streamDecode_t*)ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
--  return lz4s;
-+LZ4_streamDecode_t* LZ4_createStreamDecode(void)
-+{
-+    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
-+    return lz4s;
- }
- 
--int LZ4_freeStreamDecode(LZ4_streamDecode_t* LZ4_stream) {
--  if (!LZ4_stream) return 0; /* support free on NULL */
--  FREEMEM(LZ4_stream);
--  return 0;
-+int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
-+{
-+    if (!LZ4_stream) return 0;   /* support free on NULL */
-+    FREEMEM(LZ4_stream);
-+    return 0;
- }
- 
- /*!
-  * LZ4_setStreamDecode() :
-  * Use this function to instruct where to find the dictionary.
-- * This function is not necessary if previous data is still available where it
-- * was decoded. Loading a size of 0 is allowed (same effect as no dictionary).
-+ * This function is not necessary if previous data is still available where it was decoded.
-+ * Loading a size of 0 is allowed (same effect as no dictionary).
-  * Return : 1 if OK, 0 if error
-  */
--int LZ4_setStreamDecode(LZ4_streamDecode_t* LZ4_streamDecode,
--                        const char* dictionary, int dictSize) {
--  LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
--  lz4sd->prefixSize = (size_t)dictSize;
--  lz4sd->prefixEnd = (const BYTE*)dictionary + dictSize;
--  lz4sd->externalDict = NULL;
--  lz4sd->extDictSize = 0;
--  return 1;
-+int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
-+{
-+    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-+    lz4sd->prefixSize = (size_t) dictSize;
-+    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-+    lz4sd->externalDict = NULL;
-+    lz4sd->extDictSize  = 0;
-+    return 1;
- }
- 
- /*
- *_continue() :
--    These decoding functions allow decompression of multiple blocks in
--"streaming" mode. Previously decoded blocks must still be available at the
--memory position where they were decoded. If it's not possible, save the relevant
--part of decoded data into a safe buffer, and indicate where it stands using
--LZ4_setStreamDecode()
-+    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-+    Previously decoded blocks must still be available at the memory position where they were decoded.
-+    If it's not possible, save the relevant part of decoded data into a safe buffer,
-+    and indicate where it stands using LZ4_setStreamDecode()
- */
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_continue(LZ4_streamDecode_t* LZ4_streamDecode,
--                                 const char* source, char* dest,
--                                 int compressedSize, int maxOutputSize) {
--  LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
--  int result;
-+int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
-+{
-+    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-+    int result;
- 
--  if (lz4sd->prefixEnd == (BYTE*)dest) {
--    result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                    endOnInputSize, full, 0, usingExtDict,
--                                    lz4sd->prefixEnd - lz4sd->prefixSize,
--                                    lz4sd->externalDict, lz4sd->extDictSize);
--    if (result <= 0) return result;
--    lz4sd->prefixSize += result;
--    lz4sd->prefixEnd += result;
--  } else {
--    lz4sd->extDictSize = lz4sd->prefixSize;
--    lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
--    result = LZ4_decompress_generic(
--        source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0,
--        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
--    if (result <= 0) return result;
--    lz4sd->prefixSize = result;
--    lz4sd->prefixEnd = (BYTE*)dest + result;
--  }
-+    if (lz4sd->prefixEnd == (BYTE*)dest) {
-+        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                        endOnInputSize, full, 0,
-+                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize += result;
-+        lz4sd->prefixEnd  += result;
-+    } else {
-+        lz4sd->extDictSize = lz4sd->prefixSize;
-+        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-+        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-+                                        endOnInputSize, full, 0,
-+                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize = result;
-+        lz4sd->prefixEnd  = (BYTE*)dest + result;
-+    }
- 
--  return result;
-+    return result;
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_fast_continue(LZ4_streamDecode_t* LZ4_streamDecode,
--                                 const char* source, char* dest,
--                                 int originalSize) {
--  LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
--  int result;
-+int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
-+{
-+    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-+    int result;
- 
--  if (lz4sd->prefixEnd == (BYTE*)dest) {
--    result = LZ4_decompress_generic(source, dest, 0, originalSize,
--                                    endOnOutputSize, full, 0, usingExtDict,
--                                    lz4sd->prefixEnd - lz4sd->prefixSize,
--                                    lz4sd->externalDict, lz4sd->extDictSize);
--    if (result <= 0) return result;
--    lz4sd->prefixSize += originalSize;
--    lz4sd->prefixEnd += originalSize;
--  } else {
--    lz4sd->extDictSize = lz4sd->prefixSize;
--    lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
--    result = LZ4_decompress_generic(
--        source, dest, 0, originalSize, endOnOutputSize, full, 0, usingExtDict,
--        (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
--    if (result <= 0) return result;
--    lz4sd->prefixSize = originalSize;
--    lz4sd->prefixEnd = (BYTE*)dest + originalSize;
--  }
-+    if (lz4sd->prefixEnd == (BYTE*)dest) {
-+        result = LZ4_decompress_generic(source, dest, 0, originalSize,
-+                                        endOnOutputSize, full, 0,
-+                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize += originalSize;
-+        lz4sd->prefixEnd  += originalSize;
-+    } else {
-+        lz4sd->extDictSize = lz4sd->prefixSize;
-+        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-+        result = LZ4_decompress_generic(source, dest, 0, originalSize,
-+                                        endOnOutputSize, full, 0,
-+                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-+        if (result <= 0) return result;
-+        lz4sd->prefixSize = originalSize;
-+        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-+    }
- 
--  return result;
-+    return result;
- }
- 
-+
- /*
- Advanced decoding functions :
- *_usingDict() :
-     These decoding functions work the same as "_continue" ones,
-     the dictionary must be explicitly provided within parameters
- */
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--LZ4_FORCE_INLINE int LZ4_decompress_usingDict_generic(
--    const char* source, char* dest, int compressedSize, int maxOutputSize,
--    int safe, const char* dictStart, int dictSize) {
--  if (dictSize == 0)
--    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                  safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
--  if (dictStart + dictSize == dest) {
--    if (dictSize >= (int)(64 KB - 1))
--      return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                    safe, full, 0, withPrefix64k,
--                                    (BYTE*)dest - 64 KB, NULL, 0);
--    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                  safe, full, 0, noDict, (BYTE*)dest - dictSize,
--                                  NULL, 0);
--  }
--  return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                safe, full, 0, usingExtDict, (BYTE*)dest,
--                                (const BYTE*)dictStart, dictSize);
-+LZ4_FORCE_INLINE int LZ4_decompress_usingDict_generic(const char* source, char* dest, int compressedSize, int maxOutputSize, int safe, const char* dictStart, int dictSize)
-+{
-+    if (dictSize==0)
-+        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
-+    if (dictStart+dictSize == dest) {
-+        if (dictSize >= (int)(64 KB - 1))
-+            return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
-+        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
-+    }
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_usingDict(const char* source, char* dest,
--                                  int compressedSize, int maxOutputSize,
--                                  const char* dictStart, int dictSize) {
--  return LZ4_decompress_usingDict_generic(
--      source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
-+int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
-+{
-+    return LZ4_decompress_usingDict_generic(source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
- }
- 
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_fast_usingDict(const char* source, char* dest,
--                                  int originalSize, const char* dictStart,
--                                  int dictSize) {
--  return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0,
--                                          dictStart, dictSize);
-+int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
-+{
-+    return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0, dictStart, dictSize);
- }
- 
- /* debug function */
- LZ4_FORCE_O2_GCC_PPC64LE
--int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
--                                     int compressedSize, int maxOutputSize,
--                                     const char* dictStart, int dictSize) {
--  return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                endOnInputSize, full, 0, usingExtDict,
--                                (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-+int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
- }
- 
-+
- /*=*************************************************
-- *  Obsolete Functions
-- ***************************************************/
-+*  Obsolete Functions
-+***************************************************/
- /* obsolete compression functions */
--int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize,
--                               int maxOutputSize) {
--  return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
--}
--int LZ4_compress(const char* source, char* dest, int inputSize) {
--  return LZ4_compress_default(source, dest, inputSize,
--                              LZ4_compressBound(inputSize));
--}
--int LZ4_compress_limitedOutput_withState(void* state, const char* src,
--                                         char* dst, int srcSize, int dstSize) {
--  return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
--}
--int LZ4_compress_withState(void* state, const char* src, char* dst,
--                           int srcSize) {
--  return LZ4_compress_fast_extState(state, src, dst, srcSize,
--                                    LZ4_compressBound(srcSize), 1);
--}
--int LZ4_compress_limitedOutput_continue(LZ4_stream_t* LZ4_stream,
--                                        const char* src, char* dst, int srcSize,
--                                        int maxDstSize) {
--  return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, maxDstSize,
--                                    1);
--}
--int LZ4_compress_continue(LZ4_stream_t* LZ4_stream, const char* source,
--                          char* dest, int inputSize) {
--  return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize,
--                                    LZ4_compressBound(inputSize), 1);
--}
-+int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { return LZ4_compress_default(source, dest, inputSize, maxOutputSize); }
-+int LZ4_compress(const char* source, char* dest, int inputSize) { return LZ4_compress_default(source, dest, inputSize, LZ4_compressBound(inputSize)); }
-+int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1); }
-+int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1); }
-+int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, maxDstSize, 1); }
-+int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize) { return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1); }
- 
- /*
- These function names are deprecated and should no longer be used.
- They are only provided here for compatibility with older user programs.
- - LZ4_uncompress is totally equivalent to LZ4_decompress_fast
- - LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
- */
--int LZ4_uncompress(const char* source, char* dest, int outputSize) {
--  return LZ4_decompress_fast(source, dest, outputSize);
--}
--int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize,
--                                     int maxOutputSize) {
--  return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
--}
-+int LZ4_uncompress (const char* source, char* dest, int outputSize) { return LZ4_decompress_fast(source, dest, outputSize); }
-+int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) { return LZ4_decompress_safe(source, dest, isize, maxOutputSize); }
-+
- 
- /* Obsolete Streaming functions */
- 
- int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
- 
--static void LZ4_init(LZ4_stream_t* lz4ds, BYTE* base) {
--  MEM_INIT(lz4ds, 0, sizeof(LZ4_stream_t));
--  lz4ds->internal_donotuse.bufferStart = base;
-+static void LZ4_init(LZ4_stream_t* lz4ds, BYTE* base)
-+{
-+    MEM_INIT(lz4ds, 0, sizeof(LZ4_stream_t));
-+    lz4ds->internal_donotuse.bufferStart = base;
- }
- 
--int LZ4_resetStreamState(void* state, char* inputBuffer) {
--  if ((((uptrval)state) & 3) != 0)
--    return 1; /* Error : pointer is not aligned on 4-bytes boundary */
--  LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer);
--  return 0;
-+int LZ4_resetStreamState(void* state, char* inputBuffer)
-+{
-+    if ((((uptrval)state) & 3) != 0) return 1;   /* Error : pointer is not aligned on 4-bytes boundary */
-+    LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer);
-+    return 0;
- }
- 
--void* LZ4_create(char* inputBuffer) {
--  LZ4_stream_t* lz4ds = (LZ4_stream_t*)ALLOCATOR(8, sizeof(LZ4_stream_t));
--  LZ4_init(lz4ds, (BYTE*)inputBuffer);
--  return lz4ds;
-+void* LZ4_create (char* inputBuffer)
-+{
-+    LZ4_stream_t* lz4ds = (LZ4_stream_t*)ALLOCATOR(8, sizeof(LZ4_stream_t));
-+    LZ4_init (lz4ds, (BYTE*)inputBuffer);
-+    return lz4ds;
- }
- 
--char* LZ4_slideInputBuffer(void* LZ4_Data) {
--  LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)LZ4_Data)->internal_donotuse;
--  int dictSize =
--      LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)ctx->bufferStart, 64 KB);
--  return (char*)(ctx->bufferStart + dictSize);
-+char* LZ4_slideInputBuffer (void* LZ4_Data)
-+{
-+    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)LZ4_Data)->internal_donotuse;
-+    int dictSize = LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)ctx->bufferStart, 64 KB);
-+    return (char*)(ctx->bufferStart + dictSize);
- }
- 
- /* Obsolete streaming decompression functions */
- 
--int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest,
--                                      int compressedSize, int maxOutputSize) {
--  return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
--                                endOnInputSize, full, 0, withPrefix64k,
--                                (BYTE*)dest - 64 KB, NULL, 64 KB);
-+int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
-+{
-+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
- }
- 
--int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest,
--                                      int originalSize) {
--  return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize,
--                                full, 0, withPrefix64k, (BYTE*)dest - 64 KB,
--                                NULL, 64 KB);
-+int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
-+{
-+    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
- }
- 
--#endif /* LZ4_COMMONDEFS_ONLY */
-+#endif   /* LZ4_COMMONDEFS_ONLY */
-diff --git a/mfbt/lz4.h b/mfbt/lz4.h
---- a/mfbt/lz4.h
-+++ b/mfbt/lz4.h
-@@ -27,565 +27,453 @@
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-    You can contact the author at :
-     - LZ4 homepage : http://www.lz4.org
-     - LZ4 source repository : https://github.com/lz4/lz4
- */
--#if defined(__cplusplus)
-+#if defined (__cplusplus)
- extern "C" {
- #endif
- 
- #ifndef LZ4_H_2983827168210
- #define LZ4_H_2983827168210
- 
- /* --- Dependency --- */
--#include <stddef.h> /* size_t */
-+#include <stddef.h>   /* size_t */
-+
- 
- /**
-   Introduction
- 
--  LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s
--  per core, scalable with multi-cores CPU. It features an extremely fast
--  decoder, with speed in multiple GB/s per core, typically reaching RAM speed
--  limits on multi-core systems.
-+  LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s per core,
-+  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
-+  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
- 
--  The LZ4 compression library provides in-memory compression and decompression
--  functions. Compression can be done in:
-+  The LZ4 compression library provides in-memory compression and decompression functions.
-+  Compression can be done in:
-     - a single step (described as Simple Functions)
-     - a single step, reusing a context (described in Advanced Functions)
-     - unbounded multiple steps (described as Streaming compression)
- 
--  lz4.h provides block compression functions. It gives full buffer control to
--  user. Decompressing an lz4-compressed block also requires metadata (such as
--  compressed size). Each application is free to encode such metadata in
--  whichever way it wants.
-+  lz4.h provides block compression functions. It gives full buffer control to user.
-+  Decompressing an lz4-compressed block also requires metadata (such as compressed size).
-+  Each application is free to encode such metadata in whichever way it wants.
- 
--  An additional format, called LZ4 frame specification
--  (doc/lz4_Frame_format.md), take care of encoding standard metadata alongside
--  LZ4-compressed blocks. If your application requires interoperability, it's
--  recommended to use it. A library is provided to take care of it, see
--  lz4frame.h.
-+  An additional format, called LZ4 frame specification (doc/lz4_Frame_format.md),
-+  take care of encoding standard metadata alongside LZ4-compressed blocks.
-+  If your application requires interoperability, it's recommended to use it.
-+  A library is provided to take care of it, see lz4frame.h.
- */
- 
- /*^***************************************************************
-- *  Export parameters
-- *****************************************************************/
-+*  Export parameters
-+*****************************************************************/
- /*
-- *  LZ4_DLL_EXPORT :
-- *  Enable exporting of functions when building a Windows DLL
-- *  LZ4LIB_VISIBILITY :
-- *  Control library symbols visibility.
-- */
-+*  LZ4_DLL_EXPORT :
-+*  Enable exporting of functions when building a Windows DLL
-+*  LZ4LIB_VISIBILITY :
-+*  Control library symbols visibility.
-+*/
- #ifndef LZ4LIB_VISIBILITY
--#if defined(__GNUC__) && (__GNUC__ >= 4)
--#define LZ4LIB_VISIBILITY __attribute__((visibility("default")))
-+#  if defined(__GNUC__) && (__GNUC__ >= 4)
-+#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
-+#  else
-+#    define LZ4LIB_VISIBILITY
-+#  endif
-+#endif
-+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
-+#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
-+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
-+#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
- #else
--#define LZ4LIB_VISIBILITY
--#endif
--#endif
--#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT == 1)
--#define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
--#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT == 1)
--#define LZ4LIB_API                                                           \
--  __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to \
--                                             generate better code, saving a  \
--                                             function pointer load from the  \
--                                             IAT and an indirect jump.*/
--#else
--#define LZ4LIB_API LZ4LIB_VISIBILITY
-+#  define LZ4LIB_API LZ4LIB_VISIBILITY
- #endif
- 
- /*------   Version   ------*/
--#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes  */
--#define LZ4_VERSION_MINOR                                                      \
--  8                           /* for new (non-breaking) interface capabilities \
--                               */
--#define LZ4_VERSION_RELEASE 1 /* for tweaks, bug-fixes, or development */
-+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
-+#define LZ4_VERSION_MINOR    8    /* for new (non-breaking) interface capabilities */
-+#define LZ4_VERSION_RELEASE  1    /* for tweaks, bug-fixes, or development */
- 
--#define LZ4_VERSION_NUMBER                                   \
--  (LZ4_VERSION_MAJOR * 100 * 100 + LZ4_VERSION_MINOR * 100 + \
--   LZ4_VERSION_RELEASE)
-+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
- 
- #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
- #define LZ4_QUOTE(str) #str
- #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
- #define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
- 
--LZ4LIB_API int LZ4_versionNumber(
--    void); /**< library version number; to be used when checking dll version */
--LZ4LIB_API const char* LZ4_versionString(
--    void); /**< library version string; to be used when checking dll version */
-+LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; to be used when checking dll version */
-+LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; to be used when checking dll version */
-+
- 
- /*-************************************
-- *  Tuning parameter
-- **************************************/
-+*  Tuning parameter
-+**************************************/
- /*!
-  * LZ4_MEMORY_USAGE :
-- * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 ->
-- * 64KB; 20 -> 1MB; etc.) Increasing memory usage improves compression ratio
-+ * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
-+ * Increasing memory usage improves compression ratio
-  * Reduced memory usage can improve speed, due to cache effect
-  * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
-  */
- #ifndef LZ4_MEMORY_USAGE
--#define LZ4_MEMORY_USAGE 14
-+# define LZ4_MEMORY_USAGE 14
- #endif
- 
- /*-************************************
-- *  Simple Functions
-- **************************************/
-+*  Simple Functions
-+**************************************/
- /*! LZ4_compress_default() :
-     Compresses 'srcSize' bytes from buffer 'src'
-     into already allocated 'dst' buffer of size 'dstCapacity'.
--    Compression is guaranteed to succeed if 'dstCapacity' >=
--   LZ4_compressBound(srcSize). It also runs faster, so it's a recommended
--   setting. If the function cannot compress 'src' into a limited 'dst' budget,
-+    Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
-+    It also runs faster, so it's a recommended setting.
-+    If the function cannot compress 'src' into a limited 'dst' budget,
-     compression stops *immediately*, and the function result is zero.
-     As a consequence, 'dst' content is not valid.
--    This function never writes outside 'dst' buffer, nor read outside 'source'
--   buffer. srcSize : supported max value is LZ4_MAX_INPUT_VALUE dstCapacity :
--   full or partial size of buffer 'dst' (which must be already allocated) return
--   : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
-+    This function never writes outside 'dst' buffer, nor read outside 'source' buffer.
-+        srcSize : supported max value is LZ4_MAX_INPUT_VALUE
-+        dstCapacity : full or partial size of buffer 'dst' (which must be already allocated)
-+        return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
-                   or 0 if compression fails */
--LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize,
--                                    int dstCapacity);
-+LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
- 
- /*! LZ4_decompress_safe() :
-     compressedSize : is the exact complete size of the compressed block.
--    dstCapacity : is the size of destination buffer, which must be already
--   allocated. return : the number of bytes decompressed into destination buffer
--   (necessarily <= dstCapacity) If destination buffer is not large enough,
--   decoding will stop and output an error code (negative value). If the source
--   stream is detected malformed, the function will stop decoding and return a
--   negative result. This function is protected against buffer overflow exploits,
--   including malicious data packets. It never writes outside output buffer, nor
--   reads outside input buffer.
-+    dstCapacity : is the size of destination buffer, which must be already allocated.
-+    return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
-+             If destination buffer is not large enough, decoding will stop and output an error code (negative value).
-+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
-+             This function is protected against buffer overflow exploits, including malicious data packets.
-+             It never writes outside output buffer, nor reads outside input buffer.
- */
--LZ4LIB_API int LZ4_decompress_safe(const char* src, char* dst,
--                                   int compressedSize, int dstCapacity);
-+LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
-+
- 
- /*-************************************
-- *  Advanced Functions
-- **************************************/
--#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */
--#define LZ4_COMPRESSBOUND(isize)                    \
--  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE \
--       ? 0                                          \
--       : (isize) + ((isize) / 255) + 16)
-+*  Advanced Functions
-+**************************************/
-+#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
-+#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
- 
- /*!
- LZ4_compressBound() :
--    Provides the maximum size that LZ4 compression may output in a "worst case"
--scenario (input data not compressible) This function is primarily useful for
--memory allocation purposes (destination buffer size). Macro LZ4_COMPRESSBOUND()
--is also provided for compilation-time evaluation (stack memory allocation for
--example). Note that LZ4_compress_default() compress faster when dest buffer size
--is >= LZ4_compressBound(srcSize) inputSize  : max supported value is
--LZ4_MAX_INPUT_SIZE return : maximum output size in a "worst case" scenario or 0,
--if input size is too large ( > LZ4_MAX_INPUT_SIZE)
-+    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
-+    This function is primarily useful for memory allocation purposes (destination buffer size).
-+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
-+    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
-+        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-+        return : maximum output size in a "worst case" scenario
-+              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
- */
- LZ4LIB_API int LZ4_compressBound(int inputSize);
- 
- /*!
- LZ4_compress_fast() :
--    Same as LZ4_compress_default(), but allows to select an "acceleration"
--factor. The larger the acceleration value, the faster the algorithm, but also
--the lesser the compression. It's a trade-off. It can be fine tuned, with each
--successive value providing roughly +~3% to speed. An acceleration value of "1"
--is the same as regular LZ4_compress_default() Values <= 0 will be replaced by
--ACCELERATION_DEFAULT (see lz4.c), which is 1.
-+    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
-+    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-+    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-+    An acceleration value of "1" is the same as regular LZ4_compress_default()
-+    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
- */
--LZ4LIB_API int LZ4_compress_fast(const char* src, char* dst, int srcSize,
--                                 int dstCapacity, int acceleration);
-+LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-+
- 
- /*!
- LZ4_compress_fast_extState() :
--    Same compression function, just using an externally allocated memory space
--to store compression state. Use LZ4_sizeofState() to know how much memory must
--be allocated, and allocate it on 8-bytes boundaries (using malloc() typically).
-+    Same compression function, just using an externally allocated memory space to store compression state.
-+    Use LZ4_sizeofState() to know how much memory must be allocated,
-+    and allocate it on 8-bytes boundaries (using malloc() typically).
-     Then, provide it as 'void* state' to compression function.
- */
- LZ4LIB_API int LZ4_sizeofState(void);
--LZ4LIB_API int LZ4_compress_fast_extState(void* state, const char* src,
--                                          char* dst, int srcSize,
--                                          int dstCapacity, int acceleration);
-+LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-+
- 
- /*!
- LZ4_compress_destSize() :
-     Reverse the logic : compresses as much data as possible from 'src' buffer
-     into already allocated buffer 'dst' of size 'targetDestSize'.
--    This function either compresses the entire 'src' content into 'dst' if it's
--large enough, or fill 'dst' buffer completely with as much data as possible from
--'src'. *srcSizePtr : will be modified to indicate how many bytes where read from
--'src' to fill 'dst'. New value is necessarily <= old value. return : Nb bytes
--written into 'dst' (necessarily <= targetDestSize) or 0 if compression fails
-+    This function either compresses the entire 'src' content into 'dst' if it's large enough,
-+    or fill 'dst' buffer completely with as much data as possible from 'src'.
-+        *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
-+                      New value is necessarily <= old value.
-+        return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
-+                 or 0 if compression fails
- */
--LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst,
--                                     int* srcSizePtr, int targetDstSize);
-+LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
-+
- 
- /*!
- LZ4_decompress_fast() : (unsafe!!)
-     originalSize : is the original uncompressed size
--    return : the number of bytes read from the source buffer (in other words,
--the compressed size) If the source stream is detected malformed, the function
--will stop decoding and return a negative result. Destination buffer must be
--already allocated. Its size must be >= 'originalSize' bytes. note : This
--function respects memory boundaries for *properly formed* compressed data. It is
--a bit faster than LZ4_decompress_safe(). However, it does not provide any
--protection against intentionally modified data stream (malicious input). Use
--this function in trusted environment only (data to decode comes from a trusted
--source).
-+    return : the number of bytes read from the source buffer (in other words, the compressed size)
-+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
-+             Destination buffer must be already allocated. Its size must be >= 'originalSize' bytes.
-+    note : This function respects memory boundaries for *properly formed* compressed data.
-+           It is a bit faster than LZ4_decompress_safe().
-+           However, it does not provide any protection against intentionally modified data stream (malicious input).
-+           Use this function in trusted environment only (data to decode comes from a trusted source).
- */
--LZ4LIB_API int LZ4_decompress_fast(const char* src, char* dst,
--                                   int originalSize);
-+LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
- 
- /*!
- LZ4_decompress_safe_partial() :
--    This function decompress a compressed block of size 'srcSize' at position
--'src' into destination buffer 'dst' of size 'dstCapacity'. The function will
--decompress a minimum of 'targetOutputSize' bytes, and stop after that. However,
--it's not accurate, and may write more than 'targetOutputSize' (but <=
--dstCapacity).
--   @return : the number of bytes decoded in the destination buffer (necessarily
--<= dstCapacity) Note : this number can be < 'targetOutputSize' should the
--compressed block contain less data. Always control how many bytes were decoded.
--             If the source stream is detected malformed, the function will stop
--decoding and return a negative result. This function never writes outside of
--output buffer, and never reads outside of input buffer. It is therefore
--protected against malicious data packets.
-+    This function decompress a compressed block of size 'srcSize' at position 'src'
-+    into destination buffer 'dst' of size 'dstCapacity'.
-+    The function will decompress a minimum of 'targetOutputSize' bytes, and stop after that.
-+    However, it's not accurate, and may write more than 'targetOutputSize' (but <= dstCapacity).
-+   @return : the number of bytes decoded in the destination buffer (necessarily <= dstCapacity)
-+       Note : this number can be < 'targetOutputSize' should the compressed block contain less data.
-+             Always control how many bytes were decoded.
-+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
-+             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets.
- */
--LZ4LIB_API int LZ4_decompress_safe_partial(const char* src, char* dst,
--                                           int srcSize, int targetOutputSize,
--                                           int dstCapacity);
-+LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
-+
- 
- /*-*********************************************
-- *  Streaming Compression Functions
-- ***********************************************/
--typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */
-+*  Streaming Compression Functions
-+***********************************************/
-+typedef union LZ4_stream_u LZ4_stream_t;   /* incomplete type (defined later) */
- 
- /*! LZ4_createStream() and LZ4_freeStream() :
-  *  LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
-  *  LZ4_freeStream() releases its memory.
-  */
- LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
--LZ4LIB_API int LZ4_freeStream(LZ4_stream_t* streamPtr);
-+LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
- 
- /*! LZ4_resetStream() :
-  *  An LZ4_stream_t structure can be allocated once and re-used multiple times.
-  *  Use this function to start compressing a new stream.
-  */
--LZ4LIB_API void LZ4_resetStream(LZ4_stream_t* streamPtr);
-+LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
- 
- /*! LZ4_loadDict() :
-  *  Use this function to load a static dictionary into LZ4_stream_t.
-- *  Any previous data will be forgotten, only 'dictionary' will remain in
-- * memory. Loading a size of 0 is allowed, and is the same as reset.
-+ *  Any previous data will be forgotten, only 'dictionary' will remain in memory.
-+ *  Loading a size of 0 is allowed, and is the same as reset.
-  * @return : dictionary size, in bytes (necessarily <= 64 KB)
-  */
--LZ4LIB_API int LZ4_loadDict(LZ4_stream_t* streamPtr, const char* dictionary,
--                            int dictSize);
-+LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
- 
- /*! LZ4_compress_fast_continue() :
-- *  Compress content into 'src' using data from previously compressed blocks,
-- * improving compression ratio. 'dst' buffer must be already allocated. If
-- * dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to
-- * succeed, and runs faster.
-+ *  Compress content into 'src' using data from previously compressed blocks, improving compression ratio.
-+ *  'dst' buffer must be already allocated.
-+ *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
-  *
-- *  Important : Up to 64KB of previously compressed data is assumed to remain
-- * present and unmodified in memory ! Special 1 : If input buffer is a
-- * double-buffer, it can have any size, including < 64 KB. Special 2 : If input
-- * buffer is a ring-buffer, it can have any size, including < 64 KB.
-+ *  Important : Up to 64KB of previously compressed data is assumed to remain present and unmodified in memory !
-+ *  Special 1 : If input buffer is a double-buffer, it can have any size, including < 64 KB.
-+ *  Special 2 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
-  *
-  * @return : size of compressed block
-- *           or 0 if there is an error (typically, compressed data cannot fit
-- * into 'dst') After an error, the stream status is invalid, it can only be
-- * reset or freed.
-+ *           or 0 if there is an error (typically, compressed data cannot fit into 'dst')
-+ *  After an error, the stream status is invalid, it can only be reset or freed.
-  */
--LZ4LIB_API int LZ4_compress_fast_continue(LZ4_stream_t* streamPtr,
--                                          const char* src, char* dst,
--                                          int srcSize, int dstCapacity,
--                                          int acceleration);
-+LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
- 
- /*! LZ4_saveDict() :
-- *  If previously compressed data block is not guaranteed to remain available at
-- * its current memory location, save it into a safer place (char* safeBuffer).
-- *  Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(),
-- * dictionary is immediately usable.
-- *  @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if
-- * error.
-+ *  If previously compressed data block is not guaranteed to remain available at its current memory location,
-+ *  save it into a safer place (char* safeBuffer).
-+ *  Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(), dictionary is immediately usable.
-+ *  @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
-  */
--LZ4LIB_API int LZ4_saveDict(LZ4_stream_t* streamPtr, char* safeBuffer,
--                            int dictSize);
-+LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
-+
- 
- /*-**********************************************
-- *  Streaming Decompression Functions
-- *  Bufferless synchronous API
-- ************************************************/
--typedef union LZ4_streamDecode_u
--    LZ4_streamDecode_t; /* incomplete type (defined later) */
-+*  Streaming Decompression Functions
-+*  Bufferless synchronous API
-+************************************************/
-+typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* incomplete type (defined later) */
- 
- /*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
-  *  creation / destruction of streaming decompression tracking structure.
-  *  A tracking structure can be re-used multiple times sequentially. */
- LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
--LZ4LIB_API int LZ4_freeStreamDecode(LZ4_streamDecode_t* LZ4_stream);
-+LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
- 
- /*! LZ4_setStreamDecode() :
-- *  An LZ4_streamDecode_t structure can be allocated once and re-used multiple
-- * times. Use this function to start decompression of a new stream of blocks. A
-- * dictionary can optionnally be set. Use NULL or size 0 for a simple reset
-- * order.
-+ *  An LZ4_streamDecode_t structure can be allocated once and re-used multiple times.
-+ *  Use this function to start decompression of a new stream of blocks.
-+ *  A dictionary can optionnally be set. Use NULL or size 0 for a simple reset order.
-  * @return : 1 if OK, 0 if error
-  */
--LZ4LIB_API int LZ4_setStreamDecode(LZ4_streamDecode_t* LZ4_streamDecode,
--                                   const char* dictionary, int dictSize);
-+LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
- 
- /*! LZ4_decompress_*_continue() :
-- *  These decoding functions allow decompression of consecutive blocks in
-- * "streaming" mode. A block is an unsplittable entity, it must be presented
-- * entirely to a decompression function. Decompression functions only accept
-- * one block at a time. Previously decoded blocks *must* remain available at
-- * the memory position where they were decoded (up to 64 KB).
-+ *  These decoding functions allow decompression of consecutive blocks in "streaming" mode.
-+ *  A block is an unsplittable entity, it must be presented entirely to a decompression function.
-+ *  Decompression functions only accept one block at a time.
-+ *  Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB).
-  *
-- *  Special : if application sets a ring buffer for decompression, it must
-- * respect one of the following conditions :
-- *  - Exactly same size as encoding buffer, with same update rule (block
-- * boundaries at same positions) In which case, the decoding & encoding ring
-- * buffer can have any size, including very small ones ( < 64 KB).
-+ *  Special : if application sets a ring buffer for decompression, it must respect one of the following conditions :
-+ *  - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
-+ *    In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
-  *  - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
-- *    maxBlockSize is implementation dependent. It's the maximum size of any
-- * single block. In which case, encoding and decoding buffers do not need to be
-- * synchronized, and encoding ring buffer can have any size, including small
-- * ones ( < 64 KB).
-+ *    maxBlockSize is implementation dependent. It's the maximum size of any single block.
-+ *    In which case, encoding and decoding buffers do not need to be synchronized,
-+ *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
-  *  - _At least_ 64 KB + 8 bytes + maxBlockSize.
-- *    In which case, encoding and decoding buffers do not need to be
-- * synchronized, and encoding ring buffer can have any size, including larger
-- * than decoding buffer. Whenever these conditions are not possible, save the
-- * last 64KB of decoded data into a safe buffer, and indicate where it is saved
-- * using LZ4_setStreamDecode() before decompressing next block.
-- */
--LZ4LIB_API int LZ4_decompress_safe_continue(
--    LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst,
--    int srcSize, int dstCapacity);
--LZ4LIB_API int LZ4_decompress_fast_continue(
--    LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst,
--    int originalSize);
-+ *    In which case, encoding and decoding buffers do not need to be synchronized,
-+ *    and encoding ring buffer can have any size, including larger than decoding buffer.
-+ *  Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
-+ *  and indicate where it is saved using LZ4_setStreamDecode() before decompressing next block.
-+*/
-+LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity);
-+LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
-+
- 
- /*! LZ4_decompress_*_usingDict() :
-  *  These decoding functions work the same as
-- *  a combination of LZ4_setStreamDecode() followed by
-- * LZ4_decompress_*_continue() They are stand-alone, and don't need an
-- * LZ4_streamDecode_t structure.
-+ *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
-+ *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
-  */
--LZ4LIB_API int LZ4_decompress_safe_usingDict(const char* src, char* dst,
--                                             int srcSize, int dstCapcity,
--                                             const char* dictStart,
--                                             int dictSize);
--LZ4LIB_API int LZ4_decompress_fast_usingDict(const char* src, char* dst,
--                                             int originalSize,
--                                             const char* dictStart,
--                                             int dictSize);
-+LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize);
-+LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
-+
- 
- /*^**********************************************
-  * !!!!!!   STATIC LINKING ONLY   !!!!!!
-  ***********************************************/
- /*-************************************
-  *  Private definitions
-  **************************************
-  * Do not use these definitions.
-- * They are exposed to allow static allocation of `LZ4_stream_t` and
-- *`LZ4_streamDecode_t`. Using these definitions will expose code to API and/or
-- *ABI break in future versions of the library.
-+ * They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
-+ * Using these definitions will expose code to API and/or ABI break in future versions of the library.
-  **************************************/
--#define LZ4_HASHLOG (LZ4_MEMORY_USAGE - 2)
-+#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
- #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
--#define LZ4_HASH_SIZE_U32 \
--  (1 << LZ4_HASHLOG) /* required as macro for static allocation */
-+#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
- 
--#if defined(__cplusplus) || \
--    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
- #include <stdint.h>
- 
- typedef struct {
--  uint32_t hashTable[LZ4_HASH_SIZE_U32];
--  uint32_t currentOffset;
--  uint32_t initCheck;
--  const uint8_t* dictionary;
--  uint8_t* bufferStart; /* obsolete, used for slideInputBuffer */
--  uint32_t dictSize;
-+    uint32_t hashTable[LZ4_HASH_SIZE_U32];
-+    uint32_t currentOffset;
-+    uint32_t initCheck;
-+    const uint8_t* dictionary;
-+    uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
-+    uint32_t dictSize;
- } LZ4_stream_t_internal;
- 
- typedef struct {
--  const uint8_t* externalDict;
--  size_t extDictSize;
--  const uint8_t* prefixEnd;
--  size_t prefixSize;
-+    const uint8_t* externalDict;
-+    size_t extDictSize;
-+    const uint8_t* prefixEnd;
-+    size_t prefixSize;
- } LZ4_streamDecode_t_internal;
- 
- #else
- 
- typedef struct {
--  unsigned int hashTable[LZ4_HASH_SIZE_U32];
--  unsigned int currentOffset;
--  unsigned int initCheck;
--  const unsigned char* dictionary;
--  unsigned char* bufferStart; /* obsolete, used for slideInputBuffer */
--  unsigned int dictSize;
-+    unsigned int hashTable[LZ4_HASH_SIZE_U32];
-+    unsigned int currentOffset;
-+    unsigned int initCheck;
-+    const unsigned char* dictionary;
-+    unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
-+    unsigned int dictSize;
- } LZ4_stream_t_internal;
- 
- typedef struct {
--  const unsigned char* externalDict;
--  size_t extDictSize;
--  const unsigned char* prefixEnd;
--  size_t prefixSize;
-+    const unsigned char* externalDict;
-+    size_t extDictSize;
-+    const unsigned char* prefixEnd;
-+    size_t prefixSize;
- } LZ4_streamDecode_t_internal;
- 
- #endif
- 
- /*!
-  * LZ4_stream_t :
-  * information structure to track an LZ4 stream.
-  * init this structure before first use.
-  * note : only use in association with static linking !
-  *        this definition is not API/ABI safe,
-  *        it may change in a future version !
-  */
--#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE - 3)) + 4)
--#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
-+#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
-+#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
- union LZ4_stream_u {
--  unsigned long long table[LZ4_STREAMSIZE_U64];
--  LZ4_stream_t_internal internal_donotuse;
--}; /* previously typedef'd to LZ4_stream_t */
-+    unsigned long long table[LZ4_STREAMSIZE_U64];
-+    LZ4_stream_t_internal internal_donotuse;
-+} ;  /* previously typedef'd to LZ4_stream_t */
-+
- 
- /*!
-  * LZ4_streamDecode_t :
-  * information structure to track an LZ4 stream during decompression.
-  * init this structure  using LZ4_setStreamDecode (or memset()) before first use
-  * note : only use in association with static linking !
-  *        this definition is not API/ABI safe,
-  *        and may change in a future version !
-  */
--#define LZ4_STREAMDECODESIZE_U64 4
--#define LZ4_STREAMDECODESIZE \
--  (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
-+#define LZ4_STREAMDECODESIZE_U64  4
-+#define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
- union LZ4_streamDecode_u {
--  unsigned long long table[LZ4_STREAMDECODESIZE_U64];
--  LZ4_streamDecode_t_internal internal_donotuse;
--}; /* previously typedef'd to LZ4_streamDecode_t */
-+    unsigned long long table[LZ4_STREAMDECODESIZE_U64];
-+    LZ4_streamDecode_t_internal internal_donotuse;
-+} ;   /* previously typedef'd to LZ4_streamDecode_t */
-+
- 
- /*-************************************
-- *  Obsolete Functions
-- **************************************/
-+*  Obsolete Functions
-+**************************************/
- 
- /*! Deprecation warnings
-    Should deprecation warnings be a problem,
-    it is generally possible to disable them,
-    typically with -Wno-deprecated-declarations for gcc
-    or _CRT_SECURE_NO_WARNINGS in Visual.
-    Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS */
- #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
--#define LZ4_DEPRECATED(message) /* disable deprecation warnings */
-+#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
- #else
--#define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
--#if defined(__clang__) /* clang doesn't handle mixed C++11 and CNU attributes \
--                        */
--#define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
--#elif defined(__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
--#define LZ4_DEPRECATED(message) [[deprecated(message)]]
--#elif (LZ4_GCC_VERSION >= 405)
--#define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
--#elif (LZ4_GCC_VERSION >= 301)
--#define LZ4_DEPRECATED(message) __attribute__((deprecated))
--#elif defined(_MSC_VER)
--#define LZ4_DEPRECATED(message) __declspec(deprecated(message))
--#else
--#pragma message( \
--    "WARNING: You need to implement LZ4_DEPRECATED for this compiler")
--#define LZ4_DEPRECATED(message)
--#endif
-+#  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-+#  if defined(__clang__) /* clang doesn't handle mixed C++11 and CNU attributes */
-+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-+#  elif defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-+#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
-+#  elif (LZ4_GCC_VERSION >= 405)
-+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-+#  elif (LZ4_GCC_VERSION >= 301)
-+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
-+#  elif defined(_MSC_VER)
-+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
-+#  else
-+#    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
-+#    define LZ4_DEPRECATED(message)
-+#  endif
- #endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
- 
- /* Obsolete compression functions */
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_default() instead") int LZ4_compress(const char* source,
--                                                           char* dest,
--                                                           int sourceSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_default() instead") int LZ4_compress_limitedOutput(const char*
--                                                                             source,
--                                                                         char*
--                                                                             dest,
--                                                                         int sourceSize,
--                                                                         int maxOutputSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_fast_extState() instead") int LZ4_compress_withState(void*
--                                                                               state,
--                                                                           const char*
--                                                                               source,
--                                                                           char*
--                                                                               dest,
--                                                                           int inputSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_fast_extState() "
--    "instead") int LZ4_compress_limitedOutput_withState(void* state,
--                                                        const char* source,
--                                                        char* dest,
--                                                        int inputSize,
--                                                        int maxOutputSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_fast_continue() instead") int LZ4_compress_continue(LZ4_stream_t*
--                                                                              LZ4_streamPtr,
--                                                                          const char*
--                                                                              source,
--                                                                          char*
--                                                                              dest,
--                                                                          int inputSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_compress_fast_continue() "
--    "instead") int LZ4_compress_limitedOutput_continue(LZ4_stream_t*
--                                                           LZ4_streamPtr,
--                                                       const char* source,
--                                                       char* dest,
--                                                       int inputSize,
--                                                       int maxOutputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress               (const char* source, char* dest, int sourceSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
- 
- /* Obsolete decompression functions */
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_decompress_fast() instead") int LZ4_uncompress(const char* source,
--                                                            char* dest,
--                                                            int outputSize);
--LZ4LIB_API
--LZ4_DEPRECATED(
--    "use LZ4_decompress_safe() "
--    "instead")
--int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize,
--                                     int maxOutputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast() instead") int LZ4_uncompress (const char* source, char* dest, int outputSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe() instead") int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
- 
--/* Obsolete streaming functions; use new streaming interface whenever possible
-- */
--LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create(
--    char* inputBuffer);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_createStream() instead") int LZ4_sizeofStreamState(void);
--LZ4LIB_API
--LZ4_DEPRECATED("use LZ4_resetStream() instead")
--int LZ4_resetStreamState(void* state, char* inputBuffer);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_saveDict() instead") char* LZ4_slideInputBuffer(void* state);
-+/* Obsolete streaming functions; use new streaming interface whenever possible */
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
- 
- /* Obsolete streaming decoding functions */
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_decompress_safe_usingDict() "
--    "instead") int LZ4_decompress_safe_withPrefix64k(const char* src, char* dst,
--                                                     int compressedSize,
--                                                     int maxDstSize);
--LZ4LIB_API LZ4_DEPRECATED(
--    "use LZ4_decompress_fast_usingDict() "
--    "instead") int LZ4_decompress_fast_withPrefix64k(const char* src, char* dst,
--                                                     int originalSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
- 
- #endif /* LZ4_H_2983827168210 */
- 
--#if defined(__cplusplus)
-+
-+#if defined (__cplusplus)
- }
- #endif

rel-257/mozilla-esr60/patches/1463424-62a1.patch

@@ -1,106 +0,0 @@
-# HG changeset patch
-# User Nicolas Silva <nsilva@mozilla.com>
-# Date 1527500043 -7200
-# Node ID 39607a36ad6b04083f56fe0a10861cd486a1d399
-# Parent  d58738b1b97dbc905b0064839dd76a591a9e50ad
-Bug 1463424 - Fix divide by zeroes in qcms. r=Bas
-
-diff --git a/gfx/qcms/matrix.c b/gfx/qcms/matrix.c
---- a/gfx/qcms/matrix.c
-+++ b/gfx/qcms/matrix.c
-@@ -59,20 +59,21 @@ struct matrix matrix_invert(struct matri
- 	static int a[3] = { 2, 2, 1 };
- 	static int b[3] = { 1, 0, 0 };
- 
- 	/* inv  (A) = 1/det (A) * adj (A) */
- 	float det = matrix_det(mat);
- 
- 	if (det == 0) {
- 		dest_mat.invalid = true;
--	} else {
--		dest_mat.invalid = false;
-+		return dest_mat;
- 	}
- 
-+	dest_mat.invalid = false;
-+
- 	det = 1/det;
- 
- 	for (j = 0; j < 3; j++) {
- 		for (i = 0; i < 3; i++) {
- 			double p;
- 			int ai = a[i];
- 			int aj = a[j];
- 			int bi = b[i];
-diff --git a/gfx/qcms/transform.c b/gfx/qcms/transform.c
---- a/gfx/qcms/transform.c
-+++ b/gfx/qcms/transform.c
-@@ -163,16 +163,19 @@ static struct matrix build_RGB_to_XYZ_tr
- 	primaries.m[2][2] = 1 - xb - yb;
- 	primaries.invalid = false;
- 
- 	white_point.v[0] = xn/yn;
- 	white_point.v[1] = 1.;
- 	white_point.v[2] = (1.0-xn-yn)/yn;
- 
- 	primaries_invert = matrix_invert(primaries);
-+	if (primaries_invert.invalid) {
-+		return matrix_invalid();
-+	}
- 
- 	coefs = matrix_eval(primaries_invert, white_point);
- 
- 	result.m[0][0] = coefs.v[0]*xr;
- 	result.m[0][1] = coefs.v[1]*xg;
- 	result.m[0][2] = coefs.v[2]*xb;
- 
- 	result.m[1][0] = coefs.v[0]*yr;
-@@ -220,16 +223,19 @@ compute_chromatic_adaption(struct CIE_XY
- {
- 	struct matrix chad_inv;
- 	struct vector cone_source_XYZ, cone_source_rgb;
- 	struct vector cone_dest_XYZ, cone_dest_rgb;
- 	struct matrix cone, tmp;
- 
- 	tmp = chad;
- 	chad_inv = matrix_invert(tmp);
-+	if (chad_inv.invalid) {
-+		return matrix_invalid();
-+	}
- 
- 	cone_source_XYZ.v[0] = source_white_point.X;
- 	cone_source_XYZ.v[1] = source_white_point.Y;
- 	cone_source_XYZ.v[2] = source_white_point.Z;
- 
- 	cone_dest_XYZ.v[0] = dest_white_point.X;
- 	cone_dest_XYZ.v[1] = dest_white_point.Y;
- 	cone_dest_XYZ.v[2] = dest_white_point.Z;
-@@ -267,22 +273,26 @@ adaption_matrix(struct CIE_XYZ source_il
- }
- 
- /* from lcms: cmsAdaptMatrixToD50 */
- static struct matrix adapt_matrix_to_D50(struct matrix r, qcms_CIE_xyY source_white_pt)
- {
- 	struct CIE_XYZ Dn;
- 	struct matrix Bradford;
- 
--	if (source_white_pt.y == 0.0)
-+	if (source_white_pt.y == 0.0) {
- 		return matrix_invalid();
-+	}
- 
- 	Dn = xyY2XYZ(source_white_pt);
- 
- 	Bradford = adaption_matrix(Dn, D50_XYZ);
-+	if (Bradford.invalid) {
-+		return matrix_invalid();
-+	}
- 	return matrix_multiply(Bradford, r);
- }
- 
- qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcms_CIE_xyYTRIPLE primaries)
- {
- 	struct matrix colorants;
- 	colorants = build_RGB_to_XYZ_transfer_matrix(white_point, primaries);
- 	colorants = adapt_matrix_to_D50(colorants, white_point);
-

rel-257/mozilla-esr60/patches/1473833-63a1.patch

@@ -1,69 +0,0 @@
-# HG changeset patch
-# User Kyle Machulis <kyle@nonpolynomial.com>
-# Date 1533603238 0
-# Node ID e5f69bca3ee6fd5e67ab876db7d220acc26ab75c
-# Parent  f2091046b96c868cb3b51b9ada87b53f3c61ecec
-Bug 1473833 - Skip object loading when given unrecognized mime type; r=bzbarsky
-
-At the moment, a tag that has document type capabilities will try to
-load tag content with invalid MIME types as a document. This patch
-will cause the load to fail silently instead.
-
-This will cause failures in certain WPTs that expect plugins to be
-present to fill in MIME type requirements, which we currently don't
-have available on CI. These WPTs have been disabled for the moment.
-
-MozReview-Commit-ID: 9JGR4LClE5x
-
-Differential Revision: https://phabricator.services.mozilla.com/D2542
-
-diff --git a/devtools/client/inspector/test/doc_inspector_embed.html b/devtools/client/inspector/test/doc_inspector_embed.html
---- a/devtools/client/inspector/test/doc_inspector_embed.html
-+++ b/devtools/client/inspector/test/doc_inspector_embed.html
-@@ -1,6 +1,6 @@
- <!doctype html><html><head><meta charset="UTF-8"></head><body>
- <object>
--  <embed src="doc_inspector_menu.html" type="application/html"
-+  <embed src="doc_inspector_menu.html" type="text/html"
-          width="422" height="258"></embed>
- </object>
- </body></html>
-diff --git a/dom/base/nsObjectLoadingContent.cpp b/dom/base/nsObjectLoadingContent.cpp
---- a/dom/base/nsObjectLoadingContent.cpp
-+++ b/dom/base/nsObjectLoadingContent.cpp
-@@ -1731,22 +1731,25 @@ nsObjectLoadingContent::UpdateObjectPara
-   } else if (newChannel) {
-     // If newChannel is set above, we considered it in setting newMime
-     newType = newMime_Type;
-     LOG(("OBJLC [%p]: Using channel type", this));
-   } else if (((caps & eAllowPluginSkipChannel) || !newURI) &&
-              IsPluginType(newMime_Type)) {
-     newType = newMime_Type;
-     LOG(("OBJLC [%p]: Plugin type with no URI, skipping channel load", this));
--  } else if (newURI) {
-+  } else if (newURI && (mOriginalContentType.IsEmpty() || newMime_Type != eType_Null)) {
-     // We could potentially load this if we opened a channel on mURI, indicate
--    // This by leaving type as loading
-+    // this by leaving type as loading.
-+    //
-+    // If a MIME type was requested in the tag, but we have decided to set load
-+    // type to null, ignore (otherwise we'll default to document type loading).
-     newType = eType_Loading;
-   } else {
--    // Unloadable - no URI, and no plugin type. Non-plugin types (images,
-+    // Unloadable - no URI, and no plugin/MIME type. Non-plugin types (images,
-     // documents) always load with a channel.
-     newType = eType_Null;
-   }
- 
-   ///
-   /// Handle existing channels
-   ///
- 
-diff --git a/testing/web-platform/meta/content-security-policy/svg/object-in-svg-foreignobject.sub.html.ini b/testing/web-platform/meta/content-security-policy/svg/object-in-svg-foreignobject.sub.html.ini
-new file mode 100644
---- /dev/null
-+++ b/testing/web-platform/meta/content-security-policy/svg/object-in-svg-foreignobject.sub.html.ini
-@@ -0,0 +1,2 @@
-+[object-in-svg-foreignobject.sub.html]
-+  disabled: https://github.com/web-platform-tests/wpt/issues/12282

rel-257/mozilla-esr60/patches/NOBUG-0c5f5c2e2a86-64a1.patch

@@ -1,84 +0,0 @@
-# HG changeset patch
-# User Jeff Gilbert <jgilbert@mozilla.com>
-# Date 1539382900 25200
-# Node ID 0c5f5c2e2a860f9f681e301662aabe2deca8be4b
-# Parent  cb2f2ac274e792f5fe518198c41e7fa12acc2beb
-No bug - Fix compiler warnings on Windows.
-
-diff --git a/dom/plugins/test/testplugin/nptest_windows.cpp b/dom/plugins/test/testplugin/nptest_windows.cpp
---- a/dom/plugins/test/testplugin/nptest_windows.cpp
-+++ b/dom/plugins/test/testplugin/nptest_windows.cpp
-@@ -58,18 +58,16 @@ struct _PlatformData {
-   ID2D1Factory* d2d1Factory;
- };
- 
- bool pluginSupportsWindowMode() { return true; }
- 
- bool pluginSupportsWindowlessMode() { return true; }
- 
- NPError pluginInstanceInit(InstanceData* instanceData) {
--  NPP npp = instanceData->npp;
--
-   instanceData->platformData =
-       static_cast<PlatformData*>(NPN_MemAlloc(sizeof(PlatformData)));
-   if (!instanceData->platformData) return NPERR_OUT_OF_MEMORY_ERROR;
- 
-   instanceData->platformData->childWindow = nullptr;
-   instanceData->platformData->device = nullptr;
-   instanceData->platformData->frontBuffer = nullptr;
-   instanceData->platformData->backBuffer = nullptr;
-diff --git a/gfx/thebes/gfxGDIFontList.cpp b/gfx/thebes/gfxGDIFontList.cpp
---- a/gfx/thebes/gfxGDIFontList.cpp
-+++ b/gfx/thebes/gfxGDIFontList.cpp
-@@ -593,18 +593,18 @@ nsresult gfxGDIFontList::InitFontListFor
-   mNonExistingFonts.Clear();
- 
-   // iterate over available families
-   LOGFONTW logfont;
-   memset(&logfont, 0, sizeof(logfont));
-   logfont.lfCharSet = DEFAULT_CHARSET;
- 
-   AutoDC hdc;
--  int result = EnumFontFamiliesExW(hdc.GetDC(), &logfont,
--                                   (FONTENUMPROCW)&EnumFontFamExProc, 0, 0);
-+  (void)EnumFontFamiliesExW(hdc.GetDC(), &logfont,
-+                            (FONTENUMPROCW)&EnumFontFamExProc, 0, 0);
- 
-   GetFontSubstitutes();
- 
-   GetPrefsAndStartLoader();
- 
-   return NS_OK;
- }
- 
-diff --git a/gfx/thebes/gfxWindowsPlatform.cpp b/gfx/thebes/gfxWindowsPlatform.cpp
---- a/gfx/thebes/gfxWindowsPlatform.cpp
-+++ b/gfx/thebes/gfxWindowsPlatform.cpp
-@@ -1200,25 +1200,25 @@ bool gfxWindowsPlatform::IsOptimus() {
-         GetModuleHandleA("nvumdshimx.dll")) {
-       knowIsOptimus = 1;
-     } else {
-       knowIsOptimus = 0;
-     }
-   }
-   return knowIsOptimus;
- }
--
-+/*
- static inline bool IsWARPStable() {
-   // It seems like nvdxgiwrap makes a mess of WARP. See bug 1154703.
-   if (!IsWin8OrLater() || GetModuleHandleA("nvdxgiwrap.dll")) {
-     return false;
-   }
-   return true;
- }
--
-+*/
- static void InitializeANGLEConfig() {
-   FeatureState& d3d11ANGLE = gfxConfig::GetFeature(Feature::D3D11_HW_ANGLE);
- 
-   if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
-     d3d11ANGLE.DisableByDefault(
-         FeatureStatus::Unavailable, "D3D11 compositing is disabled",
-         NS_LITERAL_CSTRING("FEATURE_FAILURE_D3D11_DISABLED"));
-     return;

rel-257/mozilla-esr60/patches/series

@@ -1,12 +1,3 @@
-1463424-62a1.patch
-1473833-63a1.patch
-1460316-backout-1513900-lz.patch
-1460316-62a1.patch
-1439450-64a1.patch
-NOBUG-0c5f5c2e2a86-64a1.patch
-1336712-65a1.patch
-1437128-61a1.patch
-1445969-61a1.patch
 1446809-1-61a1.patch
 1446809-2-61a1.patch
 1446809-3-61a1.patch