[linux-kernel] Update zstd.diff

contrib/linux-kernel/zstd.diff

@@ -1210,10 +1210,10 @@ index 0000000..aa5eb4d
 +				huf_decompress.o decompress.o
 diff --git a/lib/zstd/bitstream.h b/lib/zstd/bitstream.h
 new file mode 100644
-index 0000000..2f6e76c
+index 0000000..0fa6db1
 --- /dev/null
 +++ b/lib/zstd/bitstream.h
-@@ -0,0 +1,382 @@
+@@ -0,0 +1,374 @@
 +/*
 + * bitstream
 + * Part of FSE library
@@ -1266,16 +1266,15 @@ index 0000000..2f6e76c
 +/*-****************************************
 +*  Dependencies
 +******************************************/
-+#include "mem.h"            /* unaligned access routines */
 +#include "error_private.h" /* error codes and messages */
-+
++#include "mem.h"	   /* unaligned access routines */
 +
 +/*=========================================
 +*  Target specific
 +=========================================*/
 +#define STREAM_ACCUMULATOR_MIN_32 25
 +#define STREAM_ACCUMULATOR_MIN_64 57
-+#define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
++#define STREAM_ACCUMULATOR_MIN ((U32)(ZSTD_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
 +
 +/*-******************************************
 +*  bitStream encoding API (write forward)
@@ -1284,8 +1283,7 @@ index 0000000..2f6e76c
 +*  A critical property of these streams is that they encode and decode in **reverse** direction.
 +*  So the first bit sequence you add will be the last to be read, like a LIFO stack.
 +*/
-+typedef struct
++typedef struct {
-+{
 +	size_t bitContainer;
 +	int bitPos;
 +	char *startPtr;
@@ -1293,10 +1291,10 @@ index 0000000..2f6e76c
 +	char *endPtr;
 +} BIT_CStream_t;
 +
-+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
++ZSTD_STATIC size_t BIT_initCStream(BIT_CStream_t *bitC, void *dstBuffer, size_t dstCapacity);
-+MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
++ZSTD_STATIC void BIT_addBits(BIT_CStream_t *bitC, size_t value, unsigned nbBits);
-+MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
++ZSTD_STATIC void BIT_flushBits(BIT_CStream_t *bitC);
-+MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
++ZSTD_STATIC size_t BIT_closeCStream(BIT_CStream_t *bitC);
 +
 +/* Start with initCStream, providing the size of buffer to write into.
 +*  bitStream will never write outside of this buffer.
@@ -1315,29 +1313,28 @@ index 0000000..2f6e76c
 +*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
 +*/
 +
-+
 +/*-********************************************
 +*  bitStream decoding API (read backward)
 +**********************************************/
-+typedef struct
++typedef struct {
-+{
 +	size_t bitContainer;
 +	unsigned bitsConsumed;
 +	const char *ptr;
 +	const char *start;
 +} BIT_DStream_t;
 +
-+typedef enum { BIT_DStream_unfinished = 0,
++typedef enum {
++	BIT_DStream_unfinished = 0,
 +	BIT_DStream_endOfBuffer = 1,
 +	BIT_DStream_completed = 2,
-+			   BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
++	BIT_DStream_overflow = 3
++} BIT_DStream_status; /* result of BIT_reloadDStream() */
 +		      /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
 +
-+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
++ZSTD_STATIC size_t BIT_initDStream(BIT_DStream_t *bitD, const void *srcBuffer, size_t srcSize);
-+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
++ZSTD_STATIC size_t BIT_readBits(BIT_DStream_t *bitD, unsigned nbBits);
-+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
++ZSTD_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t *bitD);
-+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
++ZSTD_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t *bitD);
-+
 +
 +/* Start by invoking BIT_initDStream().
 +*  A chunk of the bitStream is then stored into a local register.
@@ -1349,32 +1346,27 @@ index 0000000..2f6e76c
 +*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
 +*/
 +
-+
 +/*-****************************************
 +*  unsafe API
 +******************************************/
-+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
++ZSTD_STATIC void BIT_addBitsFast(BIT_CStream_t *bitC, size_t value, unsigned nbBits);
 +/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
 +
-+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
++ZSTD_STATIC void BIT_flushBitsFast(BIT_CStream_t *bitC);
 +/* unsafe version; does not check buffer overflow */
 +
-+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
++ZSTD_STATIC size_t BIT_readBitsFast(BIT_DStream_t *bitD, unsigned nbBits);
 +/* faster, but works only if nbBits >= 1 */
 +
-+
-+
 +/*-**************************************************************
 +*  Internal functions
 +****************************************************************/
-+MEM_STATIC unsigned BIT_highbit32 (register U32 val)
++ZSTD_STATIC unsigned BIT_highbit32(register U32 val) { return 31 - __builtin_clz(val); }
-+{
-+	return 31 - __builtin_clz(val);
-+}
 +
 +/*=====    Local Constants   =====*/
-+static const unsigned BIT_mask[] = { 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,  0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF };   /* up to 26 bits */
++static const unsigned BIT_mask[] = {0,       1,       3,       7,	0xF,      0x1F,     0x3F,     0x7F,      0xFF,
-+
++				    0x1FF,   0x3FF,   0x7FF,   0xFFF,    0x1FFF,   0x3FFF,   0x7FFF,   0xFFFF,    0x1FFFF,
++				    0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF}; /* up to 26 bits */
 +
 +/*-**************************************************************
 +*  bitStream encoding
@@ -1383,21 +1375,22 @@ index 0000000..2f6e76c
 + *  `dstCapacity` must be > sizeof(void*)
 + *  @return : 0 if success,
 +			  otherwise an error code (can be tested using ERR_isError() ) */
-+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* startPtr, size_t dstCapacity)
++ZSTD_STATIC size_t BIT_initCStream(BIT_CStream_t *bitC, void *startPtr, size_t dstCapacity)
 +{
 +	bitC->bitContainer = 0;
 +	bitC->bitPos = 0;
 +	bitC->startPtr = (char *)startPtr;
 +	bitC->ptr = bitC->startPtr;
 +	bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->ptr);
-+	if (dstCapacity <= sizeof(bitC->ptr)) return ERROR(dstSize_tooSmall);
++	if (dstCapacity <= sizeof(bitC->ptr))
++		return ERROR(dstSize_tooSmall);
 +	return 0;
 +}
 +
 +/*! BIT_addBits() :
 +	can add up to 26 bits into `bitC`.
 +	Does not check for register overflow ! */
-+MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits)
++ZSTD_STATIC void BIT_addBits(BIT_CStream_t *bitC, size_t value, unsigned nbBits)
 +{
 +	bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos;
 +	bitC->bitPos += nbBits;
@@ -1405,7 +1398,7 @@ index 0000000..2f6e76c
 +
 +/*! BIT_addBitsFast() :
 + *  works only if `value` is _clean_, meaning all high bits above nbBits are 0 */
-+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits)
++ZSTD_STATIC void BIT_addBitsFast(BIT_CStream_t *bitC, size_t value, unsigned nbBits)
 +{
 +	bitC->bitContainer |= value << bitC->bitPos;
 +	bitC->bitPos += nbBits;
@@ -1413,10 +1406,10 @@ index 0000000..2f6e76c
 +
 +/*! BIT_flushBitsFast() :
 + *  unsafe version; does not check buffer overflow */
-+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
++ZSTD_STATIC void BIT_flushBitsFast(BIT_CStream_t *bitC)
 +{
 +	size_t const nbBytes = bitC->bitPos >> 3;
-+	MEM_writeLEST(bitC->ptr, bitC->bitContainer);
++	ZSTD_writeLEST(bitC->ptr, bitC->bitContainer);
 +	bitC->ptr += nbBytes;
 +	bitC->bitPos &= 7;
 +	bitC->bitContainer >>= nbBytes * 8; /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */
@@ -1425,12 +1418,13 @@ index 0000000..2f6e76c
 +/*! BIT_flushBits() :
 + *  safe version; check for buffer overflow, and prevents it.
 + *  note : does not signal buffer overflow. This will be revealed later on using BIT_closeCStream() */
-+MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
++ZSTD_STATIC void BIT_flushBits(BIT_CStream_t *bitC)
 +{
 +	size_t const nbBytes = bitC->bitPos >> 3;
-+	MEM_writeLEST(bitC->ptr, bitC->bitContainer);
++	ZSTD_writeLEST(bitC->ptr, bitC->bitContainer);
 +	bitC->ptr += nbBytes;
-+	if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
++	if (bitC->ptr > bitC->endPtr)
++		bitC->ptr = bitC->endPtr;
 +	bitC->bitPos &= 7;
 +	bitC->bitContainer >>= nbBytes * 8; /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */
 +}
@@ -1438,17 +1432,17 @@ index 0000000..2f6e76c
 +/*! BIT_closeCStream() :
 + *  @return : size of CStream, in bytes,
 +			  or 0 if it could not fit into dstBuffer */
-+MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
++ZSTD_STATIC size_t BIT_closeCStream(BIT_CStream_t *bitC)
 +{
 +	BIT_addBitsFast(bitC, 1, 1); /* endMark */
 +	BIT_flushBits(bitC);
 +
-+	if (bitC->ptr >= bitC->endPtr) return 0; /* doesn't fit within authorized budget : cancel */
++	if (bitC->ptr >= bitC->endPtr)
++		return 0; /* doesn't fit within authorized budget : cancel */
 +
 +	return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
 +}
 +
-+
 +/*-********************************************************
 +* bitStream decoding
 +**********************************************************/
@@ -1458,23 +1452,28 @@ index 0000000..2f6e76c
 +*   `srcSize` must be the *exact* size of the bitStream, in bytes.
 +*   @return : size of stream (== srcSize) or an errorCode if a problem is detected
 +*/
-+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
++ZSTD_STATIC size_t BIT_initDStream(BIT_DStream_t *bitD, const void *srcBuffer, size_t srcSize)
 +{
-+	if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
++	if (srcSize < 1) {
++		memset(bitD, 0, sizeof(*bitD));
++		return ERROR(srcSize_wrong);
++	}
 +
 +	if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
 +		bitD->start = (const char *)srcBuffer;
 +		bitD->ptr = (const char *)srcBuffer + srcSize - sizeof(bitD->bitContainer);
-+		bitD->bitContainer = MEM_readLEST(bitD->ptr);
++		bitD->bitContainer = ZSTD_readLEST(bitD->ptr);
-+		{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
++		{
++			BYTE const lastByte = ((const BYTE *)srcBuffer)[srcSize - 1];
 +			bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
-+		  if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
++			if (lastByte == 0)
++				return ERROR(GENERIC); /* endMark not present */
++		}
 +	} else {
 +		bitD->start = (const char *)srcBuffer;
 +		bitD->ptr = bitD->start;
 +		bitD->bitContainer = *(const BYTE *)(bitD->start);
-+		switch(srcSize)
++		switch (srcSize) {
-+		{
 +		case 7: bitD->bitContainer += (size_t)(((const BYTE *)(srcBuffer))[6]) << (sizeof(bitD->bitContainer) * 8 - 16);
 +		case 6: bitD->bitContainer += (size_t)(((const BYTE *)(srcBuffer))[5]) << (sizeof(bitD->bitContainer) * 8 - 24);
 +		case 5: bitD->bitContainer += (size_t)(((const BYTE *)(srcBuffer))[4]) << (sizeof(bitD->bitContainer) * 8 - 32);
@@ -1483,29 +1482,23 @@ index 0000000..2f6e76c
 +		case 2: bitD->bitContainer += (size_t)(((const BYTE *)(srcBuffer))[1]) << 8;
 +		default:;
 +		}
-+		{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
++		{
++			BYTE const lastByte = ((const BYTE *)srcBuffer)[srcSize - 1];
 +			bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
-+		  if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
++			if (lastByte == 0)
++				return ERROR(GENERIC); /* endMark not present */
++		}
 +		bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize) * 8;
 +	}
 +
 +	return srcSize;
 +}
 +
-+MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
++ZSTD_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start) { return bitContainer >> start; }
-+{
-+	return bitContainer >> start;
-+}
 +
-+MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
++ZSTD_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits) { return (bitContainer >> start) & BIT_mask[nbBits]; }
-+{
-+	return (bitContainer >> start) & BIT_mask[nbBits];
-+}
 +
-+MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
++ZSTD_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits) { return bitContainer & BIT_mask[nbBits]; }
-+{
-+	return bitContainer & BIT_mask[nbBits];
-+}
 +
 +/*! BIT_lookBits() :
 + *  Provides next n bits from local register.
@@ -1514,7 +1507,7 @@ index 0000000..2f6e76c
 + *  On 64-bits, maxNbBits==56.
 + *  @return : value extracted
 + */
-+ MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
++ZSTD_STATIC size_t BIT_lookBits(const BIT_DStream_t *bitD, U32 nbBits)
 +{
 +	U32 const bitMask = sizeof(bitD->bitContainer) * 8 - 1;
 +	return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask - nbBits) & bitMask);
@@ -1522,23 +1515,20 @@ index 0000000..2f6e76c
 +
 +/*! BIT_lookBitsFast() :
 +*   unsafe version; only works only if nbBits >= 1 */
-+MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
++ZSTD_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t *bitD, U32 nbBits)
 +{
 +	U32 const bitMask = sizeof(bitD->bitContainer) * 8 - 1;
 +	return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask + 1) - nbBits) & bitMask);
 +}
 +
-+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
++ZSTD_STATIC void BIT_skipBits(BIT_DStream_t *bitD, U32 nbBits) { bitD->bitsConsumed += nbBits; }
-+{
-+	bitD->bitsConsumed += nbBits;
-+}
 +
 +/*! BIT_readBits() :
 + *  Read (consume) next n bits from local register and update.
 + *  Pay attention to not read more than nbBits contained into local register.
 + *  @return : extracted value.
 + */
-+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
++ZSTD_STATIC size_t BIT_readBits(BIT_DStream_t *bitD, U32 nbBits)
 +{
 +	size_t const value = BIT_lookBits(bitD, nbBits);
 +	BIT_skipBits(bitD, nbBits);
@@ -1547,7 +1537,7 @@ index 0000000..2f6e76c
 +
 +/*! BIT_readBitsFast() :
 +*   unsafe version; only works only if nbBits >= 1 */
-+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
++ZSTD_STATIC size_t BIT_readBitsFast(BIT_DStream_t *bitD, U32 nbBits)
 +{
 +	size_t const value = BIT_lookBitsFast(bitD, nbBits);
 +	BIT_skipBits(bitD, nbBits);
@@ -1559,7 +1549,7 @@ index 0000000..2f6e76c
 +*   This function is safe, it guarantees it will not read beyond src buffer.
 +*   @return : status of `BIT_DStream_t` internal register.
 +			  if status == BIT_DStream_unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */
-+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
++ZSTD_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t *bitD)
 +{
 +	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer) * 8)) /* should not happen => corruption detected */
 +		return BIT_DStream_overflow;
@@ -1567,14 +1557,16 @@ index 0000000..2f6e76c
 +	if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
 +		bitD->ptr -= bitD->bitsConsumed >> 3;
 +		bitD->bitsConsumed &= 7;
-+		bitD->bitContainer = MEM_readLEST(bitD->ptr);
++		bitD->bitContainer = ZSTD_readLEST(bitD->ptr);
 +		return BIT_DStream_unfinished;
 +	}
 +	if (bitD->ptr == bitD->start) {
-+		if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
++		if (bitD->bitsConsumed < sizeof(bitD->bitContainer) * 8)
++			return BIT_DStream_endOfBuffer;
 +		return BIT_DStream_completed;
 +	}
-+	{	U32 nbBytes = bitD->bitsConsumed >> 3;
++	{
++		U32 nbBytes = bitD->bitsConsumed >> 3;
 +		BIT_DStream_status result = BIT_DStream_unfinished;
 +		if (bitD->ptr - nbBytes < bitD->start) {
 +			nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */
@@ -1582,7 +1574,7 @@ index 0000000..2f6e76c
 +		}
 +		bitD->ptr -= nbBytes;
 +		bitD->bitsConsumed -= nbBytes * 8;
-+		bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
++		bitD->bitContainer = ZSTD_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */
 +		return result;
 +	}
 +}
@@ -1590,7 +1582,7 @@ index 0000000..2f6e76c
 +/*! BIT_endOfDStream() :
 +*   @return Tells if DStream has exactly reached its end (all bits consumed).
 +*/
-+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
++ZSTD_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t *DStream)
 +{
 +	return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer) * 8));
 +}
@@ -1598,10 +1590,10 @@ index 0000000..2f6e76c
 +#endif /* BITSTREAM_H_MODULE */
 diff --git a/lib/zstd/compress.c b/lib/zstd/compress.c
 new file mode 100644
-index 0000000..a078969
+index 0000000..6c07a04
 --- /dev/null
 +++ b/lib/zstd/compress.c
-@@ -0,0 +1,3304 @@
+@@ -0,0 +1,3461 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -1618,17 +1610,16 @@ index 0000000..a078969
 + * ("BSD").
 + */
 +
-+
 +/*-*************************************
 +*  Dependencies
 +***************************************/
++#include "fse.h"
++#include "huf.h"
++#include "mem.h"
++#include "zstd_internal.h" /* includes zstd.h */
 +#include <linux/kernel.h>
 +#include <linux/module.h>
 +#include <linux/string.h> /* memset */
-+#include "mem.h"
-+#include "fse.h"
-+#include "huf.h"
-+#include "zstd_internal.h"  /* includes zstd.h */
 +
 +/*-*************************************
 +*  Constants
@@ -1637,14 +1628,11 @@ index 0000000..a078969
 +#define HASH_READ_SIZE 8
 +typedef enum { ZSTDcs_created = 0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
 +
-+
 +/*-*************************************
 +*  Helper functions
 +***************************************/
-+#define ZSTD_STATIC_ASSERT(c) { enum { ZSTD_static_assert = 1/(int)(!!(c)) }; }
 +size_t ZSTD_compressBound(size_t srcSize) { return FSE_compressBound(srcSize) + 12; }
 +
-+
 +/*-*************************************
 +*  Sequence storage
 +***************************************/
@@ -1655,7 +1643,6 @@ index 0000000..a078969
 +	ssPtr->longLengthID = 0;
 +}
 +
-+
 +/*-*************************************
 +*  Context memory management
 +***************************************/
@@ -1696,7 +1683,8 @@ index 0000000..a078969
 +	unsigned tmpCounters[HUF_WORKSPACE_SIZE_U32];
 +};
 +
-+size_t ZSTD_CCtxWorkspaceBound(ZSTD_compressionParameters cParams) {
++size_t ZSTD_CCtxWorkspaceBound(ZSTD_compressionParameters cParams)
++{
 +	size_t const blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, (size_t)1 << cParams.windowLog);
 +	U32 const divider = (cParams.searchLength == 3) ? 3 : 4;
 +	size_t const maxNbSeq = blockSize / divider;
@@ -1706,8 +1694,10 @@ index 0000000..a078969
 +	U32 const hashLog3 = (cParams.searchLength > 3) ? 0 : MIN(ZSTD_HASHLOG3_MAX, cParams.windowLog);
 +	size_t const h3Size = ((size_t)1) << hashLog3;
 +	size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
-+	size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32) + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));
++	size_t const optSpace =
-+	size_t const workspaceSize = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace + (((cParams.strategy == ZSTD_btopt) || (cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);
++	    ((MaxML + 1) + (MaxLL + 1) + (MaxOff + 1) + (1 << Litbits)) * sizeof(U32) + (ZSTD_OPT_NUM + 1) * (sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));
++	size_t const workspaceSize = tableSpace + (256 * sizeof(U32)) /* huffTable */ + tokenSpace +
++				     (((cParams.strategy == ZSTD_btopt) || (cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);
 +
 +	return ZSTD_ALIGN(sizeof(ZSTD_stack)) + ZSTD_ALIGN(sizeof(ZSTD_CCtx)) + ZSTD_ALIGN(workspaceSize);
 +}
@@ -1715,9 +1705,11 @@ index 0000000..a078969
 +static ZSTD_CCtx *ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
 +{
 +	ZSTD_CCtx *cctx;
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +	cctx = (ZSTD_CCtx *)ZSTD_malloc(sizeof(ZSTD_CCtx), customMem);
-+	if (!cctx) return NULL;
++	if (!cctx)
++		return NULL;
 +	memset(cctx, 0, sizeof(ZSTD_CCtx));
 +	cctx->customMem = customMem;
 +	return cctx;
@@ -1735,40 +1727,38 @@ index 0000000..a078969
 +
 +size_t ZSTD_freeCCtx(ZSTD_CCtx *cctx)
 +{
-+	if (cctx==NULL) return 0;   /* support free on NULL */
++	if (cctx == NULL)
++		return 0; /* support free on NULL */
 +	ZSTD_free(cctx->workSpace, cctx->customMem);
 +	ZSTD_free(cctx, cctx->customMem);
 +	return 0; /* reserved as a potential error code in the future */
 +}
 +
-+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx)   /* hidden interface */
++const seqStore_t *ZSTD_getSeqStore(const ZSTD_CCtx *ctx) /* hidden interface */ { return &(ctx->seqStore); }
-+{
-+	return &(ctx->seqStore);
-+}
-+
-+static ZSTD_parameters ZSTD_getParamsFromCCtx(const ZSTD_CCtx* cctx)
-+{
-+	return cctx->params;
-+}
 +
++static ZSTD_parameters ZSTD_getParamsFromCCtx(const ZSTD_CCtx *cctx) { return cctx->params; }
 +
 +/** ZSTD_checkParams() :
 +	ensure param values remain within authorized range.
 +	@return : 0, or an error code if one value is beyond authorized range */
 +size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 +{
-+#   define CLAMPCHECK(val,min,max) { if ((val<min) | (val>max)) return ERROR(compressionParameter_unsupported); }
++#define CLAMPCHECK(val, min, max)                                       \
++	{                                                               \
++		if ((val < min) | (val > max))                          \
++			return ERROR(compressionParameter_unsupported); \
++	}
 +	CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
 +	CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);
 +	CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
 +	CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
 +	CLAMPCHECK(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);
 +	CLAMPCHECK(cParams.targetLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
-+	if ((U32)(cParams.strategy) > (U32)ZSTD_btopt2) return ERROR(compressionParameter_unsupported);
++	if ((U32)(cParams.strategy) > (U32)ZSTD_btopt2)
++		return ERROR(compressionParameter_unsupported);
 +	return 0;
 +}
 +
-+
 +/** ZSTD_cycleLog() :
 + *  condition for correct operation : hashLog > 1 */
 +static U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
@@ -1785,32 +1775,37 @@ index 0000000..a078969
 +	Note : cPar is considered validated at this stage. Use ZSTD_checkParams() to ensure that. */
 +ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize)
 +{
-+	if (srcSize+dictSize == 0) return cPar;   /* no size information available : no adjustment */
++	if (srcSize + dictSize == 0)
++		return cPar; /* no size information available : no adjustment */
 +
 +	/* resize params, to use less memory when necessary */
-+	{	U32 const minSrcSize = (srcSize==0) ? 500 : 0;
++	{
++		U32 const minSrcSize = (srcSize == 0) ? 500 : 0;
 +		U64 const rSize = srcSize + dictSize + minSrcSize;
 +		if (rSize < ((U64)1 << ZSTD_WINDOWLOG_MAX)) {
 +			U32 const srcLog = MAX(ZSTD_HASHLOG_MIN, ZSTD_highbit32((U32)(rSize)-1) + 1);
-+			if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
++			if (cPar.windowLog > srcLog)
-+	}   }
++				cPar.windowLog = srcLog;
-+	if (cPar.hashLog > cPar.windowLog) cPar.hashLog = cPar.windowLog;
++		}
-+	{	U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
++	}
-+		if (cycleLog > cPar.windowLog) cPar.chainLog -= (cycleLog - cPar.windowLog);
++	if (cPar.hashLog > cPar.windowLog)
++		cPar.hashLog = cPar.windowLog;
++	{
++		U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
++		if (cycleLog > cPar.windowLog)
++			cPar.chainLog -= (cycleLog - cPar.windowLog);
 +	}
 +
-+	if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* required for frame header */
++	if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
++		cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* required for frame header */
 +
 +	return cPar;
 +}
 +
-+
 +static U32 ZSTD_equivalentParams(ZSTD_parameters param1, ZSTD_parameters param2)
 +{
-+	return (param1.cParams.hashLog  == param2.cParams.hashLog)
++	return (param1.cParams.hashLog == param2.cParams.hashLog) & (param1.cParams.chainLog == param2.cParams.chainLog) &
-+		 & (param1.cParams.chainLog == param2.cParams.chainLog)
++	       (param1.cParams.strategy == param2.cParams.strategy) & ((param1.cParams.searchLength == 3) == (param2.cParams.searchLength == 3));
-+		 & (param1.cParams.strategy == param2.cParams.strategy)
-+		 & ((param1.cParams.searchLength==3) == (param2.cParams.searchLength==3));
 +}
 +
 +/*! ZSTD_continueCCtx() :
@@ -1826,7 +1821,11 @@ index 0000000..a078969
 +	cctx->stage = ZSTDcs_init;
 +	cctx->dictID = 0;
 +	cctx->loadedDictEnd = 0;
-+	{ int i; for (i=0; i<ZSTD_REP_NUM; i++) cctx->rep[i] = repStartValue[i]; }
++	{
++		int i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			cctx->rep[i] = repStartValue[i];
++	}
 +	cctx->seqStore.litLengthSum = 0; /* force reset of btopt stats */
 +	xxh64_reset(&cctx->xxhState, 0);
 +	return 0;
@@ -1836,9 +1835,7 @@ index 0000000..a078969
 +
 +/*! ZSTD_resetCCtx_advanced() :
 +	note : `params` must be validated */
-+static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
++static size_t ZSTD_resetCCtx_advanced(ZSTD_CCtx *zc, ZSTD_parameters params, U64 frameContentSize, ZSTD_compResetPolicy_e const crp)
-+									   ZSTD_parameters params, U64 frameContentSize,
-+									   ZSTD_compResetPolicy_e const crp)
 +{
 +	if (crp == ZSTDcrp_continue)
 +		if (ZSTD_equivalentParams(params, zc->params)) {
@@ -1847,7 +1844,8 @@ index 0000000..a078969
 +			return ZSTD_continueCCtx(zc, params, frameContentSize);
 +		}
 +
-+	{	size_t const blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, (size_t)1 << params.cParams.windowLog);
++	{
++		size_t const blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, (size_t)1 << params.cParams.windowLog);
 +		U32 const divider = (params.cParams.searchLength == 3) ? 3 : 4;
 +		size_t const maxNbSeq = blockSize / divider;
 +		size_t const tokenSpace = blockSize + 11 * maxNbSeq;
@@ -1859,18 +1857,22 @@ index 0000000..a078969
 +		void *ptr;
 +
 +		/* Check if workSpace is large enough, alloc a new one if needed */
-+		{	size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32)
++		{
-+								  + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));
++			size_t const optSpace = ((MaxML + 1) + (MaxLL + 1) + (MaxOff + 1) + (1 << Litbits)) * sizeof(U32) +
-+			size_t const neededSpace = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace
++						(ZSTD_OPT_NUM + 1) * (sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));
-+								  + (((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);
++			size_t const neededSpace = tableSpace + (256 * sizeof(U32)) /* huffTable */ + tokenSpace +
++						   (((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);
 +			if (zc->workSpaceSize < neededSpace) {
 +				ZSTD_free(zc->workSpace, zc->customMem);
 +				zc->workSpace = ZSTD_malloc(neededSpace, zc->customMem);
-+				if (zc->workSpace == NULL) return ERROR(memory_allocation);
++				if (zc->workSpace == NULL)
++					return ERROR(memory_allocation);
 +				zc->workSpaceSize = neededSpace;
-+		}   }
++			}
++		}
 +
-+		if (crp!=ZSTDcrp_noMemset) memset(zc->workSpace, 0, tableSpace);   /* reset tables only */
++		if (crp != ZSTDcrp_noMemset)
++			memset(zc->workSpace, 0, tableSpace); /* reset tables only */
 +		xxh64_reset(&zc->xxhState, 0);
 +		zc->hashLog3 = hashLog3;
 +		zc->hashTable = (U32 *)(zc->workSpace);
@@ -1891,7 +1893,11 @@ index 0000000..a078969
 +		zc->params = params;
 +		zc->blockSize = blockSize;
 +		zc->frameContentSize = frameContentSize;
-+		{ int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->rep[i] = repStartValue[i]; }
++		{
++			int i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				zc->rep[i] = repStartValue[i];
++		}
 +
 +		if ((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btopt2)) {
 +			zc->seqStore.litFreq = (U32 *)ptr;
@@ -1924,9 +1930,11 @@ index 0000000..a078969
 + * ensures next compression will not use repcodes from previous block.
 + * Note : only works with regular variant;
 + *        do not use with extDict variant ! */
-+void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
++void ZSTD_invalidateRepCodes(ZSTD_CCtx *cctx)
++{
 +	int i;
-+	for (i=0; i<ZSTD_REP_NUM; i++) cctx->rep[i] = 0;
++	for (i = 0; i < ZSTD_REP_NUM; i++)
++		cctx->rep[i] = 0;
 +}
 +
 +/*! ZSTD_copyCCtx() :
@@ -1935,17 +1943,19 @@ index 0000000..a078969
 +*   @return : 0, or an error code */
 +size_t ZSTD_copyCCtx(ZSTD_CCtx *dstCCtx, const ZSTD_CCtx *srcCCtx, unsigned long long pledgedSrcSize)
 +{
-+	if (srcCCtx->stage!=ZSTDcs_init) return ERROR(stage_wrong);
++	if (srcCCtx->stage != ZSTDcs_init)
-+
++		return ERROR(stage_wrong);
 +
 +	memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));
-+	{	ZSTD_parameters params = srcCCtx->params;
++	{
++		ZSTD_parameters params = srcCCtx->params;
 +		params.fParams.contentSizeFlag = (pledgedSrcSize > 0);
 +		ZSTD_resetCCtx_advanced(dstCCtx, params, pledgedSrcSize, ZSTDcrp_noMemset);
 +	}
 +
 +	/* copy tables */
-+	{	size_t const chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog);
++	{
++		size_t const chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog);
 +		size_t const hSize = ((size_t)1) << srcCCtx->params.cParams.hashLog;
 +		size_t const h3Size = (size_t)1 << srcCCtx->hashLog3;
 +		size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
@@ -1978,15 +1988,16 @@ index 0000000..a078969
 +	return 0;
 +}
 +
-+
 +/*! ZSTD_reduceTable() :
 +*   reduce table indexes by `reducerValue` */
 +static void ZSTD_reduceTable(U32 *const table, U32 const size, U32 const reducerValue)
 +{
 +	U32 u;
 +	for (u = 0; u < size; u++) {
-+		if (table[u] < reducerValue) table[u] = 0;
++		if (table[u] < reducerValue)
-+		else table[u] -= reducerValue;
++			table[u] = 0;
++		else
++			table[u] -= reducerValue;
 +	}
 +}
 +
@@ -1994,16 +2005,21 @@ index 0000000..a078969
 +*   rescale all indexes to avoid future overflow (indexes are U32) */
 +static void ZSTD_reduceIndex(ZSTD_CCtx *zc, const U32 reducerValue)
 +{
-+	{ U32 const hSize = 1 << zc->params.cParams.hashLog;
++	{
-+	  ZSTD_reduceTable(zc->hashTable, hSize, reducerValue); }
++		U32 const hSize = 1 << zc->params.cParams.hashLog;
-+
++		ZSTD_reduceTable(zc->hashTable, hSize, reducerValue);
-+	{ U32 const chainSize = (zc->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << zc->params.cParams.chainLog);
-+	  ZSTD_reduceTable(zc->chainTable, chainSize, reducerValue); }
-+
-+	{ U32 const h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;
-+	  ZSTD_reduceTable(zc->hashTable3, h3Size, reducerValue); }
 +	}
 +
++	{
++		U32 const chainSize = (zc->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << zc->params.cParams.chainLog);
++		ZSTD_reduceTable(zc->chainTable, chainSize, reducerValue);
++	}
++
++	{
++		U32 const h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;
++		ZSTD_reduceTable(zc->hashTable3, h3Size, reducerValue);
++	}
++}
 +
 +/*-*******************************************************
 +*  Block entropic compression
@@ -2013,32 +2029,26 @@ index 0000000..a078969
 +
 +size_t ZSTD_noCompressBlock(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
-+	if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
++	if (srcSize + ZSTD_blockHeaderSize > dstCapacity)
++		return ERROR(dstSize_tooSmall);
 +	memcpy((BYTE *)dst + ZSTD_blockHeaderSize, src, srcSize);
-+	MEM_writeLE24(dst, (U32)(srcSize << 2) + (U32)bt_raw);
++	ZSTD_writeLE24(dst, (U32)(srcSize << 2) + (U32)bt_raw);
 +	return ZSTD_blockHeaderSize + srcSize;
 +}
 +
-+
 +static size_t ZSTD_noCompressLiterals(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	BYTE *const ostart = (BYTE * const)dst;
 +	U32 const flSize = 1 + (srcSize > 31) + (srcSize > 4095);
 +
-+	if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall);
++	if (srcSize + flSize > dstCapacity)
++		return ERROR(dstSize_tooSmall);
 +
-+	switch(flSize)
++	switch (flSize) {
-+	{
++	case 1: /* 2 - 1 - 5 */ ostart[0] = (BYTE)((U32)set_basic + (srcSize << 3)); break;
-+		case 1: /* 2 - 1 - 5 */
++	case 2: /* 2 - 2 - 12 */ ZSTD_writeLE16(ostart, (U16)((U32)set_basic + (1 << 2) + (srcSize << 4))); break;
-+			ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));
-+			break;
-+		case 2: /* 2 - 2 - 12 */
-+			MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));
-+			break;
 +	default: /*note : should not be necessary : flSize is within {1,2,3} */
-+		case 3: /* 2 - 2 - 20 */
++	case 3: /* 2 - 2 - 20 */ ZSTD_writeLE32(ostart, (U32)((U32)set_basic + (3 << 2) + (srcSize << 4))); break;
-+			MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));
-+			break;
 +	}
 +
 +	memcpy(ostart + flSize, src, srcSize);
@@ -2052,30 +2062,20 @@ index 0000000..a078969
 +
 +	(void)dstCapacity; /* dstCapacity already guaranteed to be >=4, hence large enough */
 +
-+	switch(flSize)
++	switch (flSize) {
-+	{
++	case 1: /* 2 - 1 - 5 */ ostart[0] = (BYTE)((U32)set_rle + (srcSize << 3)); break;
-+		case 1: /* 2 - 1 - 5 */
++	case 2: /* 2 - 2 - 12 */ ZSTD_writeLE16(ostart, (U16)((U32)set_rle + (1 << 2) + (srcSize << 4))); break;
-+			ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));
-+			break;
-+		case 2: /* 2 - 2 - 12 */
-+			MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));
-+			break;
 +	default: /*note : should not be necessary : flSize is necessarily within {1,2,3} */
-+		case 3: /* 2 - 2 - 20 */
++	case 3: /* 2 - 2 - 20 */ ZSTD_writeLE32(ostart, (U32)((U32)set_rle + (3 << 2) + (srcSize << 4))); break;
-+			MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));
-+			break;
 +	}
 +
 +	ostart[flSize] = *(const BYTE *)src;
 +	return flSize + 1;
 +}
 +
-+
 +static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; }
 +
-+static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc,
++static size_t ZSTD_compressLiterals(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
-+									 void* dst, size_t dstCapacity,
-+							   const void* src, size_t srcSize)
 +{
 +	size_t const minGain = ZSTD_minGain(srcSize);
 +	size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
@@ -2084,21 +2084,31 @@ index 0000000..a078969
 +	symbolEncodingType_e hType = set_compressed;
 +	size_t cLitSize;
 +
-+
 +/* small ? don't even attempt compression (speed opt) */
 +#define LITERAL_NOENTROPY 63
-+	{	size_t const minLitSize = zc->flagStaticHufTable == HUF_repeat_valid ? 6 : LITERAL_NOENTROPY;
++	{
-+		if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
++		size_t const minLitSize = zc->flagStaticHufTable == HUF_repeat_valid ? 6 : LITERAL_NOENTROPY;
++		if (srcSize <= minLitSize)
++			return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
 +	}
 +
-+	if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */
++	if (dstCapacity < lhSize + 1)
-+	{	HUF_repeat repeat = zc->flagStaticHufTable;
++		return ERROR(dstSize_tooSmall); /* not enough space for compression */
++	{
++		HUF_repeat repeat = zc->flagStaticHufTable;
 +		int const preferRepeat = zc->params.cParams.strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
-+		if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
++		if (repeat == HUF_repeat_valid && lhSize == 3)
-+		cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, zc->tmpCounters, sizeof(zc->tmpCounters), zc->hufTable, &repeat, preferRepeat)
++			singleStream = 1;
-+								: HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, zc->tmpCounters, sizeof(zc->tmpCounters), zc->hufTable, &repeat, preferRepeat);
++		cLitSize = singleStream ? HUF_compress1X_repeat(ostart + lhSize, dstCapacity - lhSize, src, srcSize, 255, 11, zc->tmpCounters,
-+		if (repeat != HUF_repeat_none) { hType = set_repeat; }    /* reused the existing table */
++								sizeof(zc->tmpCounters), zc->hufTable, &repeat, preferRepeat)
-+		else { zc->flagStaticHufTable = HUF_repeat_check; }       /* now have a table to reuse */
++					: HUF_compress4X_repeat(ostart + lhSize, dstCapacity - lhSize, src, srcSize, 255, 11, zc->tmpCounters,
++								sizeof(zc->tmpCounters), zc->hufTable, &repeat, preferRepeat);
++		if (repeat != HUF_repeat_none) {
++			hType = set_repeat;
++		} /* reused the existing table */
++		else {
++			zc->flagStaticHufTable = HUF_repeat_check;
++		} /* now have a table to reuse */
 +	}
 +
 +	if ((cLitSize == 0) | (cLitSize >= srcSize - minGain)) {
@@ -2111,22 +2121,24 @@ index 0000000..a078969
 +	}
 +
 +	/* Build header */
-+	switch(lhSize)
++	switch (lhSize) {
-+	{
 +	case 3: /* 2 - 2 - 10 - 10 */
-+		{	U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);
++	{
-+			MEM_writeLE24(ostart, lhc);
++		U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize << 4) + ((U32)cLitSize << 14);
++		ZSTD_writeLE24(ostart, lhc);
 +		break;
 +	}
 +	case 4: /* 2 - 2 - 14 - 14 */
-+		{	U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);
++	{
-+			MEM_writeLE32(ostart, lhc);
++		U32 const lhc = hType + (2 << 2) + ((U32)srcSize << 4) + ((U32)cLitSize << 18);
++		ZSTD_writeLE32(ostart, lhc);
 +		break;
 +	}
 +	default: /* should not be necessary, lhSize is only {3,4,5} */
 +	case 5:  /* 2 - 2 - 18 - 18 */
-+		{	U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);
++	{
-+			MEM_writeLE32(ostart, lhc);
++		U32 const lhc = hType + (3 << 2) + ((U32)srcSize << 4) + ((U32)cLitSize << 22);
++		ZSTD_writeLE32(ostart, lhc);
 +		ostart[4] = (BYTE)(cLitSize >> 10);
 +		break;
 +	}
@@ -2134,24 +2146,15 @@ index 0000000..a078969
 +	return lhSize + cLitSize;
 +}
 +
-+static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
++static const BYTE LL_Code[64] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 16, 17, 17, 18, 18,
-+								   8,  9, 10, 11, 12, 13, 14, 15,
++				 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23,
-+								  16, 16, 17, 17, 18, 18, 19, 19,
++				 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
-+								  20, 20, 20, 20, 21, 21, 21, 21,
-+								  22, 22, 22, 22, 22, 22, 22, 22,
-+								  23, 23, 23, 23, 23, 23, 23, 23,
-+								  24, 24, 24, 24, 24, 24, 24, 24,
-+								  24, 24, 24, 24, 24, 24, 24, 24 };
-+
-+static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-+								  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-+								  32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-+								  38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-+								  40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-+								  41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-+								  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-+								  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
 +
++static const BYTE ML_Code[128] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
++				  26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38,
++				  38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
++				  40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 42,
++				  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42};
 +
 +void ZSTD_seqToCodes(const seqStore_t *seqStorePtr)
 +{
@@ -2176,9 +2179,7 @@ index 0000000..a078969
 +		mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
 +}
 +
-+MEM_STATIC size_t ZSTD_compressSequences (ZSTD_CCtx* zc,
++ZSTD_STATIC size_t ZSTD_compressSequences(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, size_t srcSize)
-+							  void* dst, size_t dstCapacity,
-+							  size_t srcSize)
 +{
 +	const int longOffsets = zc->params.cParams.windowLog > STREAM_ACCUMULATOR_MIN;
 +	const seqStore_t *seqStorePtr = &(zc->seqStore);
@@ -2200,19 +2201,26 @@ index 0000000..a078969
 +	BYTE scratchBuffer[1 << MAX(MLFSELog, LLFSELog)];
 +
 +	/* Compress literals */
-+	{	const BYTE* const literals = seqStorePtr->litStart;
++	{
++		const BYTE *const literals = seqStorePtr->litStart;
 +		size_t const litSize = seqStorePtr->lit - literals;
 +		size_t const cSize = ZSTD_compressLiterals(zc, op, dstCapacity, literals, litSize);
-+		if (ZSTD_isError(cSize)) return cSize;
++		if (ZSTD_isError(cSize))
++			return cSize;
 +		op += cSize;
 +	}
 +
 +	/* Sequences Header */
-+	if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead */) return ERROR(dstSize_tooSmall);
++	if ((oend - op) < 3 /*max nbSeq Size*/ + 1 /*seqHead */)
-+	if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq;
++		return ERROR(dstSize_tooSmall);
-+	else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
++	if (nbSeq < 0x7F)
-+	else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
++		*op++ = (BYTE)nbSeq;
-+	if (nbSeq==0) goto _check_compressibility;
++	else if (nbSeq < LONGNBSEQ)
++		op[0] = (BYTE)((nbSeq >> 8) + 0x80), op[1] = (BYTE)nbSeq, op += 2;
++	else
++		op[0] = 0xFF, ZSTD_writeLE16(op + 1, (U16)(nbSeq - LONGNBSEQ)), op += 3;
++	if (nbSeq == 0)
++		goto _check_compressibility;
 +
 +	/* seqHead : flags for FSE encoding type */
 +	seqHead = op++;
@@ -2224,7 +2232,8 @@ index 0000000..a078969
 +	ZSTD_seqToCodes(seqStorePtr);
 +
 +	/* CTable for Literal Lengths */
-+	{	U32 max = MaxLL;
++	{
++		U32 max = MaxLL;
 +		size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, zc->tmpCounters);
 +		if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
 +			*op++ = llCodeTable[0];
@@ -2238,17 +2247,25 @@ index 0000000..a078969
 +		} else {
 +			size_t nbSeq_1 = nbSeq;
 +			const U32 tableLog = FSE_optimalTableLog(LLFSELog, nbSeq, max);
-+			if (count[llCodeTable[nbSeq-1]]>1) { count[llCodeTable[nbSeq-1]]--; nbSeq_1--; }
++			if (count[llCodeTable[nbSeq - 1]] > 1) {
++				count[llCodeTable[nbSeq - 1]]--;
++				nbSeq_1--;
++			}
 +			FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-+			{ size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
++			{
-+			  if (FSE_isError(NCountSize)) return NCountSize;
++				size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog); /* overflow protected */
-+			  op += NCountSize; }
++				if (FSE_isError(NCountSize))
++					return NCountSize;
++				op += NCountSize;
++			}
 +			FSE_buildCTable_wksp(CTable_LitLength, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
 +			LLtype = set_compressed;
-+	}   }
++		}
++	}
 +
 +	/* CTable for Offsets */
-+	{	U32 max = MaxOff;
++	{
++		U32 max = MaxOff;
 +		size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, zc->tmpCounters);
 +		if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
 +			*op++ = ofCodeTable[0];
@@ -2262,17 +2279,25 @@ index 0000000..a078969
 +		} else {
 +			size_t nbSeq_1 = nbSeq;
 +			const U32 tableLog = FSE_optimalTableLog(OffFSELog, nbSeq, max);
-+			if (count[ofCodeTable[nbSeq-1]]>1) { count[ofCodeTable[nbSeq-1]]--; nbSeq_1--; }
++			if (count[ofCodeTable[nbSeq - 1]] > 1) {
++				count[ofCodeTable[nbSeq - 1]]--;
++				nbSeq_1--;
++			}
 +			FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-+			{ size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
++			{
-+			  if (FSE_isError(NCountSize)) return NCountSize;
++				size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog); /* overflow protected */
-+			  op += NCountSize; }
++				if (FSE_isError(NCountSize))
++					return NCountSize;
++				op += NCountSize;
++			}
 +			FSE_buildCTable_wksp(CTable_OffsetBits, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
 +			Offtype = set_compressed;
-+	}   }
++		}
++	}
 +
 +	/* CTable for MatchLengths */
-+	{	U32 max = MaxML;
++	{
++		U32 max = MaxML;
 +		size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, zc->tmpCounters);
 +		if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
 +			*op++ = *mlCodeTable;
@@ -2286,20 +2311,28 @@ index 0000000..a078969
 +		} else {
 +			size_t nbSeq_1 = nbSeq;
 +			const U32 tableLog = FSE_optimalTableLog(MLFSELog, nbSeq, max);
-+			if (count[mlCodeTable[nbSeq-1]]>1) { count[mlCodeTable[nbSeq-1]]--; nbSeq_1--; }
++			if (count[mlCodeTable[nbSeq - 1]] > 1) {
++				count[mlCodeTable[nbSeq - 1]]--;
++				nbSeq_1--;
++			}
 +			FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-+			{ size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
++			{
-+			  if (FSE_isError(NCountSize)) return NCountSize;
++				size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog); /* overflow protected */
-+			  op += NCountSize; }
++				if (FSE_isError(NCountSize))
++					return NCountSize;
++				op += NCountSize;
++			}
 +			FSE_buildCTable_wksp(CTable_MatchLength, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
 +			MLtype = set_compressed;
-+	}   }
++		}
++	}
 +
 +	*seqHead = (BYTE)((LLtype << 6) + (Offtype << 4) + (MLtype << 2));
 +	zc->flagStaticTables = 0;
 +
 +	/* Encoding Sequences */
-+	{	BIT_CStream_t blockStream;
++	{
++		BIT_CStream_t blockStream;
 +		FSE_CState_t stateMatchLength;
 +		FSE_CState_t stateOffsetBits;
 +		FSE_CState_t stateLitLength;
@@ -2311,9 +2344,11 @@ index 0000000..a078969
 +		FSE_initCState2(&stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq - 1]);
 +		FSE_initCState2(&stateLitLength, CTable_LitLength, llCodeTable[nbSeq - 1]);
 +		BIT_addBits(&blockStream, sequences[nbSeq - 1].litLength, LL_bits[llCodeTable[nbSeq - 1]]);
-+		if (MEM_32bits()) BIT_flushBits(&blockStream);
++		if (ZSTD_32bits())
++			BIT_flushBits(&blockStream);
 +		BIT_addBits(&blockStream, sequences[nbSeq - 1].matchLength, ML_bits[mlCodeTable[nbSeq - 1]]);
-+		if (MEM_32bits()) BIT_flushBits(&blockStream);
++		if (ZSTD_32bits())
++			BIT_flushBits(&blockStream);
 +		if (longOffsets) {
 +			U32 const ofBits = ofCodeTable[nbSeq - 1];
 +			int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN - 1);
@@ -2321,14 +2356,14 @@ index 0000000..a078969
 +				BIT_addBits(&blockStream, sequences[nbSeq - 1].offset, extraBits);
 +				BIT_flushBits(&blockStream);
 +			}
-+			BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
++			BIT_addBits(&blockStream, sequences[nbSeq - 1].offset >> extraBits, ofBits - extraBits);
-+						ofBits - extraBits);
 +		} else {
 +			BIT_addBits(&blockStream, sequences[nbSeq - 1].offset, ofCodeTable[nbSeq - 1]);
 +		}
 +		BIT_flushBits(&blockStream);
 +
-+		{	size_t n;
++		{
++			size_t n;
 +			for (n = nbSeq - 2; n < nbSeq; n--) { /* intentional underflow */
 +				BYTE const llCode = llCodeTable[n];
 +				BYTE const ofCode = ofCodeTable[n];
@@ -2339,48 +2374,59 @@ index 0000000..a078969
 +				/* (7)*/							    /* (7)*/
 +				FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode); /* 15 */  /* 15 */
 +				FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode); /* 24 */ /* 24 */
-+				if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
++				if (ZSTD_32bits())
++					BIT_flushBits(&blockStream);				  /* (7)*/
 +				FSE_encodeSymbol(&blockStream, &stateLitLength, llCode); /* 16 */ /* 33 */
-+				if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
++				if (ZSTD_32bits() || (ofBits + mlBits + llBits >= 64 - 7 - (LLFSELog + MLFSELog + OffFSELog)))
 +					BIT_flushBits(&blockStream); /* (7)*/
 +				BIT_addBits(&blockStream, sequences[n].litLength, llBits);
-+				if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
++				if (ZSTD_32bits() && ((llBits + mlBits) > 24))
++					BIT_flushBits(&blockStream);
 +				BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
-+				if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
++				if (ZSTD_32bits())
++					BIT_flushBits(&blockStream); /* (7)*/
 +				if (longOffsets) {
 +					int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN - 1);
 +					if (extraBits) {
 +						BIT_addBits(&blockStream, sequences[n].offset, extraBits);
 +						BIT_flushBits(&blockStream); /* (7)*/
 +					}
-+					BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
++					BIT_addBits(&blockStream, sequences[n].offset >> extraBits, ofBits - extraBits); /* 31 */
-+								ofBits - extraBits);                            /* 31 */
 +				} else {
 +					BIT_addBits(&blockStream, sequences[n].offset, ofBits); /* 31 */
 +				}
 +				BIT_flushBits(&blockStream); /* (7)*/
-+		}   }
++			}
++		}
 +
 +		FSE_flushCState(&blockStream, &stateMatchLength);
 +		FSE_flushCState(&blockStream, &stateOffsetBits);
 +		FSE_flushCState(&blockStream, &stateLitLength);
 +
-+		{	size_t const streamSize = BIT_closeCStream(&blockStream);
++		{
-+			if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */
++			size_t const streamSize = BIT_closeCStream(&blockStream);
++			if (streamSize == 0)
++				return ERROR(dstSize_tooSmall); /* not enough space */
 +			op += streamSize;
-+	}   }
++		}
++	}
 +
 +/* check compressibility */
-+_check_compressibility:
++_check_compressibility : {
-+	{	size_t const minGain = ZSTD_minGain(srcSize);
++	size_t const minGain = ZSTD_minGain(srcSize);
 +	size_t const maxCSize = srcSize - minGain;
 +	if ((size_t)(op - ostart) >= maxCSize) {
 +		zc->flagStaticHufTable = HUF_repeat_none;
 +		return 0;
-+	}   }
++	}
++}
 +
 +	/* confirm repcodes */
-+	{ int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->rep[i] = zc->repToConfirm[i]; }
++	{
++		int i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			zc->rep[i] = zc->repToConfirm[i];
++	}
 +
 +	return op - ostart;
 +}
@@ -2390,46 +2436,51 @@ index 0000000..a078969
 +	`offsetCode` : distance to match, or 0 == repCode.
 +	`matchCode` : matchLength - MINMATCH
 +*/
-+MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t matchCode)
++ZSTD_STATIC void ZSTD_storeSeq(seqStore_t *seqStorePtr, size_t litLength, const void *literals, U32 offsetCode, size_t matchCode)
 +{
 +	/* copy Literals */
 +	ZSTD_wildcopy(seqStorePtr->lit, literals, litLength);
 +	seqStorePtr->lit += litLength;
 +
 +	/* literal Length */
-+	if (litLength>0xFFFF) { seqStorePtr->longLengthID = 1; seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); }
++	if (litLength > 0xFFFF) {
++		seqStorePtr->longLengthID = 1;
++		seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
++	}
 +	seqStorePtr->sequences[0].litLength = (U16)litLength;
 +
 +	/* match offset */
 +	seqStorePtr->sequences[0].offset = offsetCode + 1;
 +
 +	/* match Length */
-+	if (matchCode>0xFFFF) { seqStorePtr->longLengthID = 2; seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); }
++	if (matchCode > 0xFFFF) {
++		seqStorePtr->longLengthID = 2;
++		seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
++	}
 +	seqStorePtr->sequences[0].matchLength = (U16)matchCode;
 +
 +	seqStorePtr->sequences++;
 +}
 +
-+
 +/*-*************************************
 +*  Match length counter
 +***************************************/
 +static unsigned ZSTD_NbCommonBytes(register size_t val)
 +{
-+	if (MEM_isLittleEndian()) {
++	if (ZSTD_isLittleEndian()) {
-+		if (MEM_64bits()) {
++		if (ZSTD_64bits()) {
 +			return (__builtin_ctzll((U64)val) >> 3);
 +		} else { /* 32 bits */
 +			return (__builtin_ctz((U32)val) >> 3);
 +		}
 +	} else { /* Big Endian CPU */
-+		if (MEM_64bits()) {
++		if (ZSTD_64bits()) {
 +			return (__builtin_clzll(val) >> 3);
 +		} else { /* 32 bits */
 +			return (__builtin_clz((U32)val) >> 3);
-+	}   }
 +		}
-+
++	}
++}
 +
 +static size_t ZSTD_count(const BYTE *pIn, const BYTE *pMatch, const BYTE *const pInLimit)
 +{
@@ -2437,14 +2488,26 @@ index 0000000..a078969
 +	const BYTE *const pInLoopLimit = pInLimit - (sizeof(size_t) - 1);
 +
 +	while (pIn < pInLoopLimit) {
-+		size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
++		size_t const diff = ZSTD_readST(pMatch) ^ ZSTD_readST(pIn);
-+		if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
++		if (!diff) {
++			pIn += sizeof(size_t);
++			pMatch += sizeof(size_t);
++			continue;
++		}
 +		pIn += ZSTD_NbCommonBytes(diff);
 +		return (size_t)(pIn - pStart);
 +	}
-+	if (MEM_64bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
++	if (ZSTD_64bits())
-+	if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
++		if ((pIn < (pInLimit - 3)) && (ZSTD_read32(pMatch) == ZSTD_read32(pIn))) {
-+	if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
++			pIn += 4;
++			pMatch += 4;
++		}
++	if ((pIn < (pInLimit - 1)) && (ZSTD_read16(pMatch) == ZSTD_read16(pIn))) {
++		pIn += 2;
++		pMatch += 2;
++	}
++	if ((pIn < pInLimit) && (*pMatch == *pIn))
++		pIn++;
 +	return (size_t)(pIn - pStart);
 +}
 +
@@ -2456,42 +2519,41 @@ index 0000000..a078969
 +{
 +	const BYTE *const vEnd = MIN(ip + (mEnd - match), iEnd);
 +	size_t const matchLength = ZSTD_count(ip, match, vEnd);
-+	if (match + matchLength != mEnd) return matchLength;
++	if (match + matchLength != mEnd)
++		return matchLength;
 +	return matchLength + ZSTD_count(ip + matchLength, iStart, iEnd);
 +}
 +
-+
 +/*-*************************************
 +*  Hashes
 +***************************************/
 +static const U32 prime3bytes = 506832829U;
 +static U32 ZSTD_hash3(U32 u, U32 h) { return ((u << (32 - 24)) * prime3bytes) >> (32 - h); }
-+MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); }   /* only in zstd_opt.h */
++ZSTD_STATIC size_t ZSTD_hash3Ptr(const void *ptr, U32 h) { return ZSTD_hash3(ZSTD_readLE32(ptr), h); } /* only in zstd_opt.h */
 +
 +static const U32 prime4bytes = 2654435761U;
 +static U32 ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32 - h); }
-+static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); }
++static size_t ZSTD_hash4Ptr(const void *ptr, U32 h) { return ZSTD_hash4(ZSTD_read32(ptr), h); }
 +
 +static const U64 prime5bytes = 889523592379ULL;
 +static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u << (64 - 40)) * prime5bytes) >> (64 - h)); }
-+static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }
++static size_t ZSTD_hash5Ptr(const void *p, U32 h) { return ZSTD_hash5(ZSTD_readLE64(p), h); }
 +
 +static const U64 prime6bytes = 227718039650203ULL;
 +static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u << (64 - 48)) * prime6bytes) >> (64 - h)); }
-+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
++static size_t ZSTD_hash6Ptr(const void *p, U32 h) { return ZSTD_hash6(ZSTD_readLE64(p), h); }
 +
 +static const U64 prime7bytes = 58295818150454627ULL;
 +static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u << (64 - 56)) * prime7bytes) >> (64 - h)); }
-+static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }
++static size_t ZSTD_hash7Ptr(const void *p, U32 h) { return ZSTD_hash7(ZSTD_readLE64(p), h); }
 +
 +static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
 +static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u)*prime8bytes) >> (64 - h)); }
-+static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }
++static size_t ZSTD_hash8Ptr(const void *p, U32 h) { return ZSTD_hash8(ZSTD_readLE64(p), h); }
 +
 +static size_t ZSTD_hashPtr(const void *p, U32 hBits, U32 mls)
 +{
-+	switch(mls)
++	switch (mls) {
-+	{
 +	// case 3: return ZSTD_hash3Ptr(p, hBits);
 +	default:
 +	case 4: return ZSTD_hash4Ptr(p, hBits);
@@ -2502,7 +2564,6 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +/*-*************************************
 +*  Fast Scan
 +***************************************/
@@ -2521,11 +2582,8 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +FORCE_INLINE
-+void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* cctx,
++void ZSTD_compressBlock_fast_generic(ZSTD_CCtx *cctx, const void *src, size_t srcSize, const U32 mls)
-+							   const void* src, size_t srcSize,
-+							   const U32 mls)
 +{
 +	U32 *const hashTable = cctx->hashTable;
 +	U32 const hBits = cctx->params.cParams.hashLog;
@@ -2543,9 +2601,12 @@ index 0000000..a078969
 +
 +	/* init */
 +	ip += (ip == lowest);
-+	{	U32 const maxRep = (U32)(ip-lowest);
++	{
-+		if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
++		U32 const maxRep = (U32)(ip - lowest);
-+		if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
++		if (offset_2 > maxRep)
++			offsetSaved = offset_2, offset_2 = 0;
++		if (offset_1 > maxRep)
++			offsetSaved = offset_1, offset_1 = 0;
 +	}
 +
 +	/* Main Search Loop */
@@ -2557,19 +2618,23 @@ index 0000000..a078969
 +		const BYTE *match = base + matchIndex;
 +		hashTable[h] = curr; /* update hash table */
 +
-+		if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) {
++		if ((offset_1 > 0) & (ZSTD_read32(ip + 1 - offset_1) == ZSTD_read32(ip + 1))) {
 +			mLength = ZSTD_count(ip + 1 + 4, ip + 1 + 4 - offset_1, iend) + 4;
 +			ip++;
 +			ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, 0, mLength - MINMATCH);
 +		} else {
 +			U32 offset;
-+			if ( (matchIndex <= lowestIndex) || (MEM_read32(match) != MEM_read32(ip)) ) {
++			if ((matchIndex <= lowestIndex) || (ZSTD_read32(match) != ZSTD_read32(ip))) {
 +				ip += ((ip - anchor) >> g_searchStrength) + 1;
 +				continue;
 +			}
 +			mLength = ZSTD_count(ip + 4, match + 4, iend) + 4;
 +			offset = (U32)(ip - match);
-+			while (((ip>anchor) & (match>lowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
++			while (((ip > anchor) & (match > lowest)) && (ip[-1] == match[-1])) {
++				ip--;
++				match--;
++				mLength++;
++			} /* catch up */
 +			offset_2 = offset_1;
 +			offset_1 = offset;
 +
@@ -2585,53 +2650,48 @@ index 0000000..a078969
 +			hashTable[ZSTD_hashPtr(base + curr + 2, hBits, mls)] = curr + 2; /* here because curr+2 could be > iend-8 */
 +			hashTable[ZSTD_hashPtr(ip - 2, hBits, mls)] = (U32)(ip - 2 - base);
 +			/* check immediate repcode */
-+			while ( (ip <= ilimit)
++			while ((ip <= ilimit) && ((offset_2 > 0) & (ZSTD_read32(ip) == ZSTD_read32(ip - offset_2)))) {
-+				 && ( (offset_2>0)
-+				 & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
 +				/* store sequence */
 +				size_t const rLength = ZSTD_count(ip + 4, ip + 4 - offset_2, iend) + 4;
-+				{ U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; }  /* swap offset_2 <=> offset_1 */
++				{
++					U32 const tmpOff = offset_2;
++					offset_2 = offset_1;
++					offset_1 = tmpOff;
++				} /* swap offset_2 <=> offset_1 */
 +				hashTable[ZSTD_hashPtr(ip, hBits, mls)] = (U32)(ip - base);
 +				ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, rLength - MINMATCH);
 +				ip += rLength;
 +				anchor = ip;
 +				continue; /* faster when present ... (?) */
-+	}   }   }
++			}
++		}
++	}
 +
 +	/* save reps for next block */
 +	cctx->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
 +	cctx->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
++static void ZSTD_compressBlock_fast(ZSTD_CCtx *ctx, const void *src, size_t srcSize)
-+static void ZSTD_compressBlock_fast(ZSTD_CCtx* ctx,
-+					   const void* src, size_t srcSize)
 +{
 +	const U32 mls = ctx->params.cParams.searchLength;
-+	switch(mls)
++	switch (mls) {
-+	{
 +	default: /* includes case 3 */
-+	case 4 :
++	case 4: ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 4); return;
-+		ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 4); return;
++	case 5: ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 5); return;
-+	case 5 :
++	case 6: ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 6); return;
-+		ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 5); return;
++	case 7: ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 7); return;
-+	case 6 :
-+		ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 6); return;
-+	case 7 :
-+		ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 7); return;
 +	}
 +}
 +
-+
++static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const U32 mls)
-+static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
-+								 const void* src, size_t srcSize,
-+								 const U32 mls)
 +{
 +	U32 *hashTable = ctx->hashTable;
 +	const U32 hBits = ctx->params.cParams.hashLog;
@@ -2663,28 +2723,33 @@ index 0000000..a078969
 +		size_t mLength;
 +		hashTable[h] = curr; /* update hash table */
 +
-+		if ( (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex))
++		if ((((U32)((dictLimit - 1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex)) &&
-+		   && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
++		    (ZSTD_read32(repMatch) == ZSTD_read32(ip + 1))) {
 +			const BYTE *repMatchEnd = repIndex < dictLimit ? dictEnd : iend;
 +			mLength = ZSTD_count_2segments(ip + 1 + EQUAL_READ32, repMatch + EQUAL_READ32, iend, repMatchEnd, lowPrefixPtr) + EQUAL_READ32;
 +			ip++;
 +			ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, 0, mLength - MINMATCH);
 +		} else {
-+			if ( (matchIndex < lowestIndex) ||
++			if ((matchIndex < lowestIndex) || (ZSTD_read32(match) != ZSTD_read32(ip))) {
-+				 (MEM_read32(match) != MEM_read32(ip)) ) {
 +				ip += ((ip - anchor) >> g_searchStrength) + 1;
 +				continue;
 +			}
-+			{	const BYTE* matchEnd = matchIndex < dictLimit ? dictEnd : iend;
++			{
++				const BYTE *matchEnd = matchIndex < dictLimit ? dictEnd : iend;
 +				const BYTE *lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr;
 +				U32 offset;
 +				mLength = ZSTD_count_2segments(ip + EQUAL_READ32, match + EQUAL_READ32, iend, matchEnd, lowPrefixPtr) + EQUAL_READ32;
-+				while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
++				while (((ip > anchor) & (match > lowMatchPtr)) && (ip[-1] == match[-1])) {
++					ip--;
++					match--;
++					mLength++;
++				} /* catch up */
 +				offset = curr - matchIndex;
 +				offset_2 = offset_1;
 +				offset_1 = offset;
 +				ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, offset + ZSTD_REP_MOVE, mLength - MINMATCH);
-+		}   }
++			}
++		}
 +
 +		/* found a match : store it */
 +		ip += mLength;
@@ -2700,10 +2765,13 @@ index 0000000..a078969
 +				U32 const repIndex2 = curr2 - offset_2;
 +				const BYTE *repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2;
 +				if ((((U32)((dictLimit - 1) - repIndex2) >= 3) & (repIndex2 > lowestIndex)) /* intentional overflow */
-+				   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
++				    && (ZSTD_read32(repMatch2) == ZSTD_read32(ip))) {
 +					const BYTE *const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend;
-+					size_t repLength2 = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch2+EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32;
++					size_t repLength2 =
-+					U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
++					    ZSTD_count_2segments(ip + EQUAL_READ32, repMatch2 + EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32;
++					U32 tmpOffset = offset_2;
++					offset_2 = offset_1;
++					offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */
 +					ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, repLength2 - MINMATCH);
 +					hashTable[ZSTD_hashPtr(ip, hBits, mls)] = curr2;
 +					ip += repLength2;
@@ -2711,38 +2779,34 @@ index 0000000..a078969
 +					continue;
 +				}
 +				break;
-+	}   }   }
++			}
++		}
++	}
 +
 +	/* save reps for next block */
-+	ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
++	ctx->repToConfirm[0] = offset_1;
++	ctx->repToConfirm[1] = offset_2;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
++static void ZSTD_compressBlock_fast_extDict(ZSTD_CCtx *ctx, const void *src, size_t srcSize)
-+static void ZSTD_compressBlock_fast_extDict(ZSTD_CCtx* ctx,
-+						 const void* src, size_t srcSize)
 +{
 +	U32 const mls = ctx->params.cParams.searchLength;
-+	switch(mls)
++	switch (mls) {
-+	{
 +	default: /* includes case 3 */
-+	case 4 :
++	case 4: ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 4); return;
-+		ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 4); return;
++	case 5: ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 5); return;
-+	case 5 :
++	case 6: ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 6); return;
-+		ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 5); return;
++	case 7: ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 7); return;
-+	case 6 :
-+		ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 6); return;
-+	case 7 :
-+		ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 7); return;
 +	}
 +}
 +
-+
 +/*-*************************************
 +*  Double Fast
 +***************************************/
@@ -2764,11 +2828,8 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +FORCE_INLINE
-+void ZSTD_compressBlock_doubleFast_generic(ZSTD_CCtx* cctx,
++void ZSTD_compressBlock_doubleFast_generic(ZSTD_CCtx *cctx, const void *src, size_t srcSize, const U32 mls)
-+								 const void* src, size_t srcSize,
-+								 const U32 mls)
 +{
 +	U32 *const hashLong = cctx->hashTable;
 +	const U32 hBitsL = cctx->params.cParams.hashLog;
@@ -2788,9 +2849,12 @@ index 0000000..a078969
 +
 +	/* init */
 +	ip += (ip == lowest);
-+	{	U32 const maxRep = (U32)(ip-lowest);
++	{
-+		if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
++		U32 const maxRep = (U32)(ip - lowest);
-+		if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
++		if (offset_2 > maxRep)
++			offsetSaved = offset_2, offset_2 = 0;
++		if (offset_1 > maxRep)
++			offsetSaved = offset_1, offset_1 = 0;
 +	}
 +
 +	/* Main Search Loop */
@@ -2805,30 +2869,42 @@ index 0000000..a078969
 +		const BYTE *match = base + matchIndexS;
 +		hashLong[h2] = hashSmall[h] = curr; /* update hash tables */
 +
-+		if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) { /* note : by construction, offset_1 <= curr */
++		if ((offset_1 > 0) & (ZSTD_read32(ip + 1 - offset_1) == ZSTD_read32(ip + 1))) { /* note : by construction, offset_1 <= curr */
 +			mLength = ZSTD_count(ip + 1 + 4, ip + 1 + 4 - offset_1, iend) + 4;
 +			ip++;
 +			ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, 0, mLength - MINMATCH);
 +		} else {
 +			U32 offset;
-+			if ( (matchIndexL > lowestIndex) && (MEM_read64(matchLong) == MEM_read64(ip)) ) {
++			if ((matchIndexL > lowestIndex) && (ZSTD_read64(matchLong) == ZSTD_read64(ip))) {
 +				mLength = ZSTD_count(ip + 8, matchLong + 8, iend) + 8;
 +				offset = (U32)(ip - matchLong);
-+				while (((ip>anchor) & (matchLong>lowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
++				while (((ip > anchor) & (matchLong > lowest)) && (ip[-1] == matchLong[-1])) {
-+			} else if ( (matchIndexS > lowestIndex) && (MEM_read32(match) == MEM_read32(ip)) ) {
++					ip--;
++					matchLong--;
++					mLength++;
++				} /* catch up */
++			} else if ((matchIndexS > lowestIndex) && (ZSTD_read32(match) == ZSTD_read32(ip))) {
 +				size_t const h3 = ZSTD_hashPtr(ip + 1, hBitsL, 8);
 +				U32 const matchIndex3 = hashLong[h3];
 +				const BYTE *match3 = base + matchIndex3;
 +				hashLong[h3] = curr + 1;
-+				if ( (matchIndex3 > lowestIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
++				if ((matchIndex3 > lowestIndex) && (ZSTD_read64(match3) == ZSTD_read64(ip + 1))) {
 +					mLength = ZSTD_count(ip + 9, match3 + 8, iend) + 8;
 +					ip++;
 +					offset = (U32)(ip - match3);
-+					while (((ip>anchor) & (match3>lowest)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
++					while (((ip > anchor) & (match3 > lowest)) && (ip[-1] == match3[-1])) {
++						ip--;
++						match3--;
++						mLength++;
++					} /* catch up */
 +				} else {
 +					mLength = ZSTD_count(ip + 4, match + 4, iend) + 4;
 +					offset = (U32)(ip - match);
-+					while (((ip>anchor) & (match>lowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
++					while (((ip > anchor) & (match > lowest)) && (ip[-1] == match[-1])) {
++						ip--;
++						match--;
++						mLength++;
++					} /* catch up */
 +				}
 +			} else {
 +				ip += ((ip - anchor) >> g_searchStrength) + 1;
@@ -2847,59 +2923,54 @@ index 0000000..a078969
 +
 +		if (ip <= ilimit) {
 +			/* Fill Table */
-+			hashLong[ZSTD_hashPtr(base+curr+2, hBitsL, 8)] =
++			hashLong[ZSTD_hashPtr(base + curr + 2, hBitsL, 8)] = hashSmall[ZSTD_hashPtr(base + curr + 2, hBitsS, mls)] =
-+				hashSmall[ZSTD_hashPtr(base+curr+2, hBitsS, mls)] = curr+2;  /* here because curr+2 could be > iend-8 */
++			    curr + 2; /* here because curr+2 could be > iend-8 */
-+			hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] =
++			hashLong[ZSTD_hashPtr(ip - 2, hBitsL, 8)] = hashSmall[ZSTD_hashPtr(ip - 2, hBitsS, mls)] = (U32)(ip - 2 - base);
-+				hashSmall[ZSTD_hashPtr(ip-2, hBitsS, mls)] = (U32)(ip-2-base);
 +
 +			/* check immediate repcode */
-+			while ( (ip <= ilimit)
++			while ((ip <= ilimit) && ((offset_2 > 0) & (ZSTD_read32(ip) == ZSTD_read32(ip - offset_2)))) {
-+				 && ( (offset_2>0)
-+				 & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
 +				/* store sequence */
 +				size_t const rLength = ZSTD_count(ip + 4, ip + 4 - offset_2, iend) + 4;
-+				{ U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */
++				{
++					U32 const tmpOff = offset_2;
++					offset_2 = offset_1;
++					offset_1 = tmpOff;
++				} /* swap offset_2 <=> offset_1 */
 +				hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip - base);
 +				hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip - base);
 +				ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, rLength - MINMATCH);
 +				ip += rLength;
 +				anchor = ip;
 +				continue; /* faster when present ... (?) */
-+	}   }   }
++			}
++		}
++	}
 +
 +	/* save reps for next block */
 +	cctx->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
 +	cctx->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
 +static void ZSTD_compressBlock_doubleFast(ZSTD_CCtx *ctx, const void *src, size_t srcSize)
 +{
 +	const U32 mls = ctx->params.cParams.searchLength;
-+	switch(mls)
++	switch (mls) {
-+	{
 +	default: /* includes case 3 */
-+	case 4 :
++	case 4: ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 4); return;
-+		ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 4); return;
++	case 5: ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 5); return;
-+	case 5 :
++	case 6: ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 6); return;
-+		ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 5); return;
++	case 7: ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 7); return;
-+	case 6 :
-+		ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 6); return;
-+	case 7 :
-+		ZSTD_compressBlock_doubleFast_generic(ctx, src, srcSize, 7); return;
 +	}
 +}
 +
-+
++static void ZSTD_compressBlock_doubleFast_extDict_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const U32 mls)
-+static void ZSTD_compressBlock_doubleFast_extDict_generic(ZSTD_CCtx* ctx,
-+								 const void* src, size_t srcSize,
-+								 const U32 mls)
 +{
 +	U32 *const hashLong = ctx->hashTable;
 +	U32 const hBitsL = ctx->params.cParams.hashLog;
@@ -2939,44 +3010,56 @@ index 0000000..a078969
 +		size_t mLength;
 +		hashSmall[hSmall] = hashLong[hLong] = curr; /* update hash table */
 +
-+		if ( (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex))
++		if ((((U32)((dictLimit - 1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex)) &&
-+		   && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
++		    (ZSTD_read32(repMatch) == ZSTD_read32(ip + 1))) {
 +			const BYTE *repMatchEnd = repIndex < dictLimit ? dictEnd : iend;
 +			mLength = ZSTD_count_2segments(ip + 1 + 4, repMatch + 4, iend, repMatchEnd, lowPrefixPtr) + 4;
 +			ip++;
 +			ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, 0, mLength - MINMATCH);
 +		} else {
-+			if ((matchLongIndex > lowestIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {
++			if ((matchLongIndex > lowestIndex) && (ZSTD_read64(matchLong) == ZSTD_read64(ip))) {
 +				const BYTE *matchEnd = matchLongIndex < dictLimit ? dictEnd : iend;
 +				const BYTE *lowMatchPtr = matchLongIndex < dictLimit ? dictStart : lowPrefixPtr;
 +				U32 offset;
 +				mLength = ZSTD_count_2segments(ip + 8, matchLong + 8, iend, matchEnd, lowPrefixPtr) + 8;
 +				offset = curr - matchLongIndex;
-+				while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; }   /* catch up */
++				while (((ip > anchor) & (matchLong > lowMatchPtr)) && (ip[-1] == matchLong[-1])) {
++					ip--;
++					matchLong--;
++					mLength++;
++				} /* catch up */
 +				offset_2 = offset_1;
 +				offset_1 = offset;
 +				ZSTD_storeSeq(seqStorePtr, ip - anchor, anchor, offset + ZSTD_REP_MOVE, mLength - MINMATCH);
 +
-+			} else if ((matchIndex > lowestIndex) && (MEM_read32(match) == MEM_read32(ip))) {
++			} else if ((matchIndex > lowestIndex) && (ZSTD_read32(match) == ZSTD_read32(ip))) {
 +				size_t const h3 = ZSTD_hashPtr(ip + 1, hBitsL, 8);
 +				U32 const matchIndex3 = hashLong[h3];
 +				const BYTE *const match3Base = matchIndex3 < dictLimit ? dictBase : base;
 +				const BYTE *match3 = match3Base + matchIndex3;
 +				U32 offset;
 +				hashLong[h3] = curr + 1;
-+				if ( (matchIndex3 > lowestIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
++				if ((matchIndex3 > lowestIndex) && (ZSTD_read64(match3) == ZSTD_read64(ip + 1))) {
 +					const BYTE *matchEnd = matchIndex3 < dictLimit ? dictEnd : iend;
 +					const BYTE *lowMatchPtr = matchIndex3 < dictLimit ? dictStart : lowPrefixPtr;
 +					mLength = ZSTD_count_2segments(ip + 9, match3 + 8, iend, matchEnd, lowPrefixPtr) + 8;
 +					ip++;
 +					offset = curr + 1 - matchIndex3;
-+					while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
++					while (((ip > anchor) & (match3 > lowMatchPtr)) && (ip[-1] == match3[-1])) {
++						ip--;
++						match3--;
++						mLength++;
++					} /* catch up */
 +				} else {
 +					const BYTE *matchEnd = matchIndex < dictLimit ? dictEnd : iend;
 +					const BYTE *lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr;
 +					mLength = ZSTD_count_2segments(ip + 4, match + 4, iend, matchEnd, lowPrefixPtr) + 4;
 +					offset = curr - matchIndex;
-+					while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
++					while (((ip > anchor) & (match > lowMatchPtr)) && (ip[-1] == match[-1])) {
++						ip--;
++						match--;
++						mLength++;
++					} /* catch up */
 +				}
 +				offset_2 = offset_1;
 +				offset_1 = offset;
@@ -2985,7 +3068,8 @@ index 0000000..a078969
 +			} else {
 +				ip += ((ip - anchor) >> g_searchStrength) + 1;
 +				continue;
-+		}   }
++			}
++		}
 +
 +		/* found a match : store it */
 +		ip += mLength;
@@ -3003,10 +3087,13 @@ index 0000000..a078969
 +				U32 const repIndex2 = curr2 - offset_2;
 +				const BYTE *repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2;
 +				if ((((U32)((dictLimit - 1) - repIndex2) >= 3) & (repIndex2 > lowestIndex)) /* intentional overflow */
-+				   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
++				    && (ZSTD_read32(repMatch2) == ZSTD_read32(ip))) {
 +					const BYTE *const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend;
-+					size_t const repLength2 = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch2+EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32;
++					size_t const repLength2 =
-+					U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
++					    ZSTD_count_2segments(ip + EQUAL_READ32, repMatch2 + EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32;
++					U32 tmpOffset = offset_2;
++					offset_2 = offset_1;
++					offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */
 +					ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, repLength2 - MINMATCH);
 +					hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = curr2;
 +					hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = curr2;
@@ -3015,46 +3102,41 @@ index 0000000..a078969
 +					continue;
 +				}
 +				break;
-+	}   }   }
++			}
++		}
++	}
 +
 +	/* save reps for next block */
-+	ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
++	ctx->repToConfirm[0] = offset_1;
++	ctx->repToConfirm[1] = offset_2;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
++static void ZSTD_compressBlock_doubleFast_extDict(ZSTD_CCtx *ctx, const void *src, size_t srcSize)
-+static void ZSTD_compressBlock_doubleFast_extDict(ZSTD_CCtx* ctx,
-+						 const void* src, size_t srcSize)
 +{
 +	U32 const mls = ctx->params.cParams.searchLength;
-+	switch(mls)
++	switch (mls) {
-+	{
 +	default: /* includes case 3 */
-+	case 4 :
++	case 4: ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 4); return;
-+		ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 4); return;
++	case 5: ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 5); return;
-+	case 5 :
++	case 6: ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 6); return;
-+		ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 5); return;
++	case 7: ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 7); return;
-+	case 6 :
-+		ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 6); return;
-+	case 7 :
-+		ZSTD_compressBlock_doubleFast_extDict_generic(ctx, src, srcSize, 7); return;
 +	}
 +}
 +
-+
 +/*-*************************************
 +*  Binary Tree search
 +***************************************/
 +/** ZSTD_insertBt1() : add one or multiple positions to tree.
 +*   ip : assumed <= iend-8 .
 +*   @return : nb of positions added */
-+static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares,
++static U32 ZSTD_insertBt1(ZSTD_CCtx *zc, const BYTE *const ip, const U32 mls, const BYTE *const iend, U32 nbCompares, U32 extDict)
-+						  U32 extDict)
 +{
 +	U32 *const hashTable = zc->hashTable;
 +	U32 const hashLog = zc->params.cParams.hashLog;
@@ -3109,30 +3191,34 @@ index 0000000..a078969
 +			/* match is smaller than curr */
 +			*smallerPtr = matchIndex;	  /* update smaller idx */
 +			commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
-+			if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				smallerPtr = &dummy32;
++				break;
++			}			  /* beyond tree size, stop the search */
 +			smallerPtr = nextPtr + 1; /* new "smaller" => larger of match */
 +			matchIndex = nextPtr[1];  /* new matchIndex larger than previous (closer to curr) */
 +		} else {
 +			/* match is larger than curr */
 +			*largerPtr = matchIndex;
 +			commonLengthLarger = matchLength;
-+			if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				largerPtr = &dummy32;
++				break;
++			} /* beyond tree size, stop the search */
 +			largerPtr = nextPtr;
 +			matchIndex = nextPtr[0];
-+	}   }
++		}
++	}
 +
 +	*smallerPtr = *largerPtr = 0;
-+	if (bestLength > 384) return MIN(192, (U32)(bestLength - 384));   /* speed optimization */
++	if (bestLength > 384)
-+	if (matchEndIdx > curr + 8) return matchEndIdx - curr - 8;
++		return MIN(192, (U32)(bestLength - 384)); /* speed optimization */
++	if (matchEndIdx > curr + 8)
++		return matchEndIdx - curr - 8;
 +	return 1;
 +}
 +
-+
++static size_t ZSTD_insertBtAndFindBestMatch(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iend, size_t *offsetPtr, U32 nbCompares, const U32 mls,
-+static size_t ZSTD_insertBtAndFindBestMatch (
-+						ZSTD_CCtx* zc,
-+						const BYTE* const ip, const BYTE* const iend,
-+						size_t* offsetPtr,
-+						U32 nbCompares, const U32 mls,
 +					    U32 extDict)
 +{
 +	U32 *const hashTable = zc->hashTable;
@@ -3188,17 +3274,24 @@ index 0000000..a078969
 +			/* match is smaller than curr */
 +			*smallerPtr = matchIndex;	  /* update smaller idx */
 +			commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
-+			if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				smallerPtr = &dummy32;
++				break;
++			}			  /* beyond tree size, stop the search */
 +			smallerPtr = nextPtr + 1; /* new "smaller" => larger of match */
 +			matchIndex = nextPtr[1];  /* new matchIndex larger than previous (closer to curr) */
 +		} else {
 +			/* match is larger than curr */
 +			*largerPtr = matchIndex;
 +			commonLengthLarger = matchLength;
-+			if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				largerPtr = &dummy32;
++				break;
++			} /* beyond tree size, stop the search */
 +			largerPtr = nextPtr;
 +			matchIndex = nextPtr[0];
-+	}   }
++		}
++	}
 +
 +	*smallerPtr = *largerPtr = 0;
 +
@@ -3206,7 +3299,6 @@ index 0000000..a078969
 +	return bestLength;
 +}
 +
-+
 +static void ZSTD_updateTree(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iend, const U32 nbCompares, const U32 mls)
 +{
 +	const BYTE *const base = zc->base;
@@ -3218,26 +3310,18 @@ index 0000000..a078969
 +}
 +
 +/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
-+static size_t ZSTD_BtFindBestMatch (
++static size_t ZSTD_BtFindBestMatch(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts, const U32 mls)
-+						ZSTD_CCtx* zc,
-+						const BYTE* const ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 mls)
 +{
-+	if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
++	if (ip < zc->base + zc->nextToUpdate)
++		return 0; /* skipped area */
 +	ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
 +	return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 0);
 +}
 +
-+
++static size_t ZSTD_BtFindBestMatch_selectMLS(ZSTD_CCtx *zc, /* Index table will be updated */
-+static size_t ZSTD_BtFindBestMatch_selectMLS (
++					     const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts, const U32 matchLengthSearch)
-+						ZSTD_CCtx* zc,   /* Index table will be updated */
-+						const BYTE* ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	default: /* includes case 3 */
 +	case 4: return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
 +	case 5: return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
@@ -3246,38 +3330,31 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +static void ZSTD_updateTree_extDict(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iend, const U32 nbCompares, const U32 mls)
 +{
 +	const BYTE *const base = zc->base;
 +	const U32 target = (U32)(ip - base);
 +	U32 idx = zc->nextToUpdate;
 +
-+	while (idx < target) idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 1);
++	while (idx < target)
++		idx += ZSTD_insertBt1(zc, base + idx, mls, iend, nbCompares, 1);
 +}
 +
-+
 +/** Tree updater, providing best match */
-+static size_t ZSTD_BtFindBestMatch_extDict (
++static size_t ZSTD_BtFindBestMatch_extDict(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts,
-+						ZSTD_CCtx* zc,
++					   const U32 mls)
-+						const BYTE* const ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 mls)
 +{
-+	if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
++	if (ip < zc->base + zc->nextToUpdate)
++		return 0; /* skipped area */
 +	ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
 +	return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 1);
 +}
 +
-+
++static size_t ZSTD_BtFindBestMatch_selectMLS_extDict(ZSTD_CCtx *zc, /* Index table will be updated */
-+static size_t ZSTD_BtFindBestMatch_selectMLS_extDict (
++						     const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts,
-+						ZSTD_CCtx* zc,   /* Index table will be updated */
++						     const U32 matchLengthSearch)
-+						const BYTE* ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	default: /* includes case 3 */
 +	case 4: return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
 +	case 5: return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
@@ -3286,8 +3363,6 @@ index 0000000..a078969
 +	}
 +}
 +
-+
-+
 +/* *********************************
 +*  Hash Chain
 +***********************************/
@@ -3317,14 +3392,10 @@ index 0000000..a078969
 +	return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
 +}
 +
-+
-+
 +FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */
-+size_t ZSTD_HcFindBestMatch_generic (
++    size_t
-+						ZSTD_CCtx* zc,   /* Index table will be updated */
++    ZSTD_HcFindBestMatch_generic(ZSTD_CCtx *zc, /* Index table will be updated */
-+						const BYTE* const ip, const BYTE* const iLimit,
++				 const BYTE *const ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts, const U32 mls, const U32 extDict)
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 mls, const U32 extDict)
 +{
 +	U32 *const chainTable = zc->chainTable;
 +	const U32 chainSize = (1 << zc->params.cParams.chainLog);
@@ -3352,29 +3423,30 @@ index 0000000..a078969
 +				currMl = ZSTD_count(ip, match, iLimit);
 +		} else {
 +			match = dictBase + matchIndex;
-+			if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
++			if (ZSTD_read32(match) == ZSTD_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */
 +				currMl = ZSTD_count_2segments(ip + EQUAL_READ32, match + EQUAL_READ32, iLimit, dictEnd, prefixStart) + EQUAL_READ32;
 +		}
 +
 +		/* save best solution */
-+		if (currMl > ml) { ml = currMl; *offsetPtr = curr - matchIndex + ZSTD_REP_MOVE; if (ip+currMl == iLimit) break; /* best possible, and avoid read overflow*/ }
++		if (currMl > ml) {
++			ml = currMl;
++			*offsetPtr = curr - matchIndex + ZSTD_REP_MOVE;
++			if (ip + currMl == iLimit)
++				break; /* best possible, and avoid read overflow*/
++		}
 +
-+		if (matchIndex <= minChain) break;
++		if (matchIndex <= minChain)
++			break;
 +		matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
 +	}
 +
 +	return ml;
 +}
 +
-+
++FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS(ZSTD_CCtx *zc, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts,
-+FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS (
++						   const U32 matchLengthSearch)
-+						ZSTD_CCtx* zc,
-+						const BYTE* ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	default: /* includes case 3 */
 +	case 4: return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 0);
 +	case 5: return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 0);
@@ -3383,15 +3455,10 @@ index 0000000..a078969
 +	}
 +}
 +
-+
++FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS(ZSTD_CCtx *zc, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 maxNbAttempts,
-+FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
++							   const U32 matchLengthSearch)
-+						ZSTD_CCtx* zc,
-+						const BYTE* ip, const BYTE* const iLimit,
-+						size_t* offsetPtr,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	default: /* includes case 3 */
 +	case 4: return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 1);
 +	case 5: return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 1);
@@ -3400,14 +3467,11 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +/* *******************************
 +*  Common parser - lazy strategy
 +*********************************/
 +FORCE_INLINE
-+void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx,
++void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const U32 searchMethod, const U32 depth)
-+									 const void* src, size_t srcSize,
-+									 const U32 searchMethod, const U32 depth)
 +{
 +	seqStore_t *seqStorePtr = &(ctx->seqStore);
 +	const BYTE *const istart = (const BYTE *)src;
@@ -3420,18 +3484,19 @@ index 0000000..a078969
 +	U32 const maxSearches = 1 << ctx->params.cParams.searchLog;
 +	U32 const mls = ctx->params.cParams.searchLength;
 +
-+	typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit,
++	typedef size_t (*searchMax_f)(ZSTD_CCtx * zc, const BYTE *ip, const BYTE *iLimit, size_t *offsetPtr, U32 maxNbAttempts, U32 matchLengthSearch);
-+						size_t* offsetPtr,
-+						U32 maxNbAttempts, U32 matchLengthSearch);
 +	searchMax_f const searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS : ZSTD_HcFindBestMatch_selectMLS;
 +	U32 offset_1 = ctx->rep[0], offset_2 = ctx->rep[1], savedOffset = 0;
 +
 +	/* init */
 +	ip += (ip == base);
 +	ctx->nextToUpdate3 = ctx->nextToUpdate;
-+	{	U32 const maxRep = (U32)(ip-base);
++	{
-+		if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;
++		U32 const maxRep = (U32)(ip - base);
-+		if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0;
++		if (offset_2 > maxRep)
++			savedOffset = offset_2, offset_2 = 0;
++		if (offset_1 > maxRep)
++			savedOffset = offset_1, offset_1 = 0;
 +	}
 +
 +	/* Match Loop */
@@ -3441,14 +3506,16 @@ index 0000000..a078969
 +		const BYTE *start = ip + 1;
 +
 +		/* check repCode */
-+		if ((offset_1>0) & (MEM_read32(ip+1) == MEM_read32(ip+1 - offset_1))) {
++		if ((offset_1 > 0) & (ZSTD_read32(ip + 1) == ZSTD_read32(ip + 1 - offset_1))) {
 +			/* repcode : we take it */
 +			matchLength = ZSTD_count(ip + 1 + EQUAL_READ32, ip + 1 + EQUAL_READ32 - offset_1, iend) + EQUAL_READ32;
-+			if (depth==0) goto _storeSequence;
++			if (depth == 0)
++				goto _storeSequence;
 +		}
 +
 +		/* first search (depth 0) */
-+		{	size_t offsetFound = 99999999;
++		{
++			size_t offsetFound = 99999999;
 +			size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls);
 +			if (ml2 > matchLength)
 +				matchLength = ml2, start = ip, offset = offsetFound;
@@ -3463,107 +3530,103 @@ index 0000000..a078969
 +		if (depth >= 1)
 +			while (ip < ilimit) {
 +				ip++;
-+			if ((offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
++				if ((offset) && ((offset_1 > 0) & (ZSTD_read32(ip) == ZSTD_read32(ip - offset_1)))) {
 +					size_t const mlRep = ZSTD_count(ip + EQUAL_READ32, ip + EQUAL_READ32 - offset_1, iend) + EQUAL_READ32;
 +					int const gain2 = (int)(mlRep * 3);
 +					int const gain1 = (int)(matchLength * 3 - ZSTD_highbit32((U32)offset + 1) + 1);
 +					if ((mlRep >= EQUAL_READ32) && (gain2 > gain1))
 +						matchLength = mlRep, offset = 0, start = ip;
 +				}
-+			{	size_t offset2=99999999;
++				{
++					size_t offset2 = 99999999;
 +					size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
 +					int const gain2 = (int)(ml2 * 4 - ZSTD_highbit32((U32)offset2 + 1)); /* raw approx */
 +					int const gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 4);
 +					if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
 +						matchLength = ml2, offset = offset2, start = ip;
 +						continue; /* search a better one */
-+			}   }
++					}
++				}
 +
 +				/* let's find an even better one */
 +				if ((depth == 2) && (ip < ilimit)) {
 +					ip++;
-+				if ((offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
++					if ((offset) && ((offset_1 > 0) & (ZSTD_read32(ip) == ZSTD_read32(ip - offset_1)))) {
 +						size_t const ml2 = ZSTD_count(ip + EQUAL_READ32, ip + EQUAL_READ32 - offset_1, iend) + EQUAL_READ32;
 +						int const gain2 = (int)(ml2 * 4);
 +						int const gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 1);
 +						if ((ml2 >= EQUAL_READ32) && (gain2 > gain1))
 +							matchLength = ml2, offset = 0, start = ip;
 +					}
-+				{	size_t offset2=99999999;
++					{
++						size_t offset2 = 99999999;
 +						size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
 +						int const gain2 = (int)(ml2 * 4 - ZSTD_highbit32((U32)offset2 + 1)); /* raw approx */
 +						int const gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 7);
 +						if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
 +							matchLength = ml2, offset = offset2, start = ip;
 +							continue;
-+			}   }   }
++						}
++					}
++				}
 +				break; /* nothing found : store previous solution */
 +			}
 +
 +		/* catch up */
 +		if (offset) {
-+			while ((start>anchor) && (start>base+offset-ZSTD_REP_MOVE) && (start[-1] == start[-1-offset+ZSTD_REP_MOVE]))   /* only search for offset within prefix */
++			while ((start > anchor) && (start > base + offset - ZSTD_REP_MOVE) &&
-+				{ start--; matchLength++; }
++			       (start[-1] == start[-1 - offset + ZSTD_REP_MOVE])) /* only search for offset within prefix */
-+			offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
++			{
++				start--;
++				matchLength++;
++			}
++			offset_2 = offset_1;
++			offset_1 = (U32)(offset - ZSTD_REP_MOVE);
 +		}
 +
 +	/* store sequence */
-+_storeSequence:
++	_storeSequence : {
-+		{	size_t const litLength = start - anchor;
++		size_t const litLength = start - anchor;
 +		ZSTD_storeSeq(seqStorePtr, litLength, anchor, (U32)offset, matchLength - MINMATCH);
 +		anchor = ip = start + matchLength;
 +	}
 +
 +		/* check immediate repcode */
-+		while ( (ip <= ilimit)
++		while ((ip <= ilimit) && ((offset_2 > 0) & (ZSTD_read32(ip) == ZSTD_read32(ip - offset_2)))) {
-+			 && ((offset_2>0)
-+			 & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
 +			/* store sequence */
 +			matchLength = ZSTD_count(ip + EQUAL_READ32, ip + EQUAL_READ32 - offset_2, iend) + EQUAL_READ32;
-+			offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap repcodes */
++			offset = offset_2;
++			offset_2 = offset_1;
++			offset_1 = (U32)offset; /* swap repcodes */
 +			ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength - MINMATCH);
 +			ip += matchLength;
 +			anchor = ip;
 +			continue; /* faster when present ... (?) */
-+	}   }
++		}
++	}
 +
 +	/* Save reps for next block */
 +	ctx->repToConfirm[0] = offset_1 ? offset_1 : savedOffset;
 +	ctx->repToConfirm[1] = offset_2 ? offset_2 : savedOffset;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
++static void ZSTD_compressBlock_btlazy2(ZSTD_CCtx *ctx, const void *src, size_t srcSize) { ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 1, 2); }
 +
-+static void ZSTD_compressBlock_btlazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
++static void ZSTD_compressBlock_lazy2(ZSTD_CCtx *ctx, const void *src, size_t srcSize) { ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 2); }
-+{
-+	ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 1, 2);
-+}
 +
-+static void ZSTD_compressBlock_lazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
++static void ZSTD_compressBlock_lazy(ZSTD_CCtx *ctx, const void *src, size_t srcSize) { ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 1); }
-+{
-+	ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 2);
-+}
-+
-+static void ZSTD_compressBlock_lazy(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-+{
-+	ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 1);
-+}
-+
-+static void ZSTD_compressBlock_greedy(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-+{
-+	ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 0);
-+}
 +
++static void ZSTD_compressBlock_greedy(ZSTD_CCtx *ctx, const void *src, size_t srcSize) { ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 0); }
 +
 +FORCE_INLINE
-+void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx,
++void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const U32 searchMethod, const U32 depth)
-+									 const void* src, size_t srcSize,
-+									 const U32 searchMethod, const U32 depth)
 +{
 +	seqStore_t *seqStorePtr = &(ctx->seqStore);
 +	const BYTE *const istart = (const BYTE *)src;
@@ -3582,9 +3645,7 @@ index 0000000..a078969
 +	const U32 maxSearches = 1 << ctx->params.cParams.searchLog;
 +	const U32 mls = ctx->params.cParams.searchLength;
 +
-+	typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit,
++	typedef size_t (*searchMax_f)(ZSTD_CCtx * zc, const BYTE *ip, const BYTE *iLimit, size_t *offsetPtr, U32 maxNbAttempts, U32 matchLengthSearch);
-+						size_t* offsetPtr,
-+						U32 maxNbAttempts, U32 matchLengthSearch);
 +	searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS_extDict : ZSTD_HcFindBestMatch_extDict_selectMLS;
 +
 +	U32 offset_1 = ctx->rep[0], offset_2 = ctx->rep[1];
@@ -3601,19 +3662,24 @@ index 0000000..a078969
 +		U32 curr = (U32)(ip - base);
 +
 +		/* check repCode */
-+		{	const U32 repIndex = (U32)(curr+1 - offset_1);
++		{
++			const U32 repIndex = (U32)(curr + 1 - offset_1);
 +			const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +			const BYTE *const repMatch = repBase + repIndex;
 +			if (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+			if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
++				if (ZSTD_read32(ip + 1) == ZSTD_read32(repMatch)) {
 +					/* repcode detected we should take it */
 +					const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
-+				matchLength = ZSTD_count_2segments(ip+1+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
++					matchLength =
-+				if (depth==0) goto _storeSequence;
++					    ZSTD_count_2segments(ip + 1 + EQUAL_READ32, repMatch + EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
-+		}   }
++					if (depth == 0)
++						goto _storeSequence;
++				}
++		}
 +
 +		/* first search (depth 0) */
-+		{	size_t offsetFound = 99999999;
++		{
++			size_t offsetFound = 99999999;
 +			size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls);
 +			if (ml2 > matchLength)
 +				matchLength = ml2, start = ip, offset = offsetFound;
@@ -3635,25 +3701,30 @@ index 0000000..a078969
 +					const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +					const BYTE *const repMatch = repBase + repIndex;
 +					if (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+				if (MEM_read32(ip) == MEM_read32(repMatch)) {
++						if (ZSTD_read32(ip) == ZSTD_read32(repMatch)) {
 +							/* repcode detected */
 +							const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
-+					size_t const repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
++							size_t const repLength =
++							    ZSTD_count_2segments(ip + EQUAL_READ32, repMatch + EQUAL_READ32, iend, repEnd, prefixStart) +
++							    EQUAL_READ32;
 +							int const gain2 = (int)(repLength * 3);
 +							int const gain1 = (int)(matchLength * 3 - ZSTD_highbit32((U32)offset + 1) + 1);
 +							if ((repLength >= EQUAL_READ32) && (gain2 > gain1))
 +								matchLength = repLength, offset = 0, start = ip;
-+			}   }
++						}
++				}
 +
 +				/* search match, depth 1 */
-+			{	size_t offset2=99999999;
++				{
++					size_t offset2 = 99999999;
 +					size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
 +					int const gain2 = (int)(ml2 * 4 - ZSTD_highbit32((U32)offset2 + 1)); /* raw approx */
 +					int const gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 4);
 +					if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
 +						matchLength = ml2, offset = offset2, start = ip;
 +						continue; /* search a better one */
-+			}   }
++					}
++				}
 +
 +				/* let's find an even better one */
 +				if ((depth == 2) && (ip < ilimit)) {
@@ -3665,25 +3736,31 @@ index 0000000..a078969
 +						const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +						const BYTE *const repMatch = repBase + repIndex;
 +						if (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+					if (MEM_read32(ip) == MEM_read32(repMatch)) {
++							if (ZSTD_read32(ip) == ZSTD_read32(repMatch)) {
 +								/* repcode detected */
 +								const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
-+						size_t repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
++								size_t repLength = ZSTD_count_2segments(ip + EQUAL_READ32, repMatch + EQUAL_READ32, iend,
++													repEnd, prefixStart) +
++										   EQUAL_READ32;
 +								int gain2 = (int)(repLength * 4);
 +								int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 1);
 +								if ((repLength >= EQUAL_READ32) && (gain2 > gain1))
 +									matchLength = repLength, offset = 0, start = ip;
-+				}   }
++							}
++					}
 +
 +					/* search match, depth 2 */
-+				{	size_t offset2=99999999;
++					{
++						size_t offset2 = 99999999;
 +						size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
 +						int const gain2 = (int)(ml2 * 4 - ZSTD_highbit32((U32)offset2 + 1)); /* raw approx */
 +						int const gain1 = (int)(matchLength * 4 - ZSTD_highbit32((U32)offset + 1) + 7);
 +						if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
 +							matchLength = ml2, offset = offset2, start = ip;
 +							continue;
-+			}   }   }
++						}
++					}
++				}
 +				break; /* nothing found : store previous solution */
 +			}
 +
@@ -3692,13 +3769,18 @@ index 0000000..a078969
 +			U32 const matchIndex = (U32)((start - base) - (offset - ZSTD_REP_MOVE));
 +			const BYTE *match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
 +			const BYTE *const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
-+			while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
++			while ((start > anchor) && (match > mStart) && (start[-1] == match[-1])) {
-+			offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
++				start--;
++				match--;
++				matchLength++;
++			} /* catch up */
++			offset_2 = offset_1;
++			offset_1 = (U32)(offset - ZSTD_REP_MOVE);
 +		}
 +
 +	/* store sequence */
-+_storeSequence:
++	_storeSequence : {
-+		{	size_t const litLength = start - anchor;
++		size_t const litLength = start - anchor;
 +		ZSTD_storeSeq(seqStorePtr, litLength, anchor, (U32)offset, matchLength - MINMATCH);
 +		anchor = ip = start + matchLength;
 +	}
@@ -3709,34 +3791,36 @@ index 0000000..a078969
 +			const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +			const BYTE *const repMatch = repBase + repIndex;
 +			if (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+			if (MEM_read32(ip) == MEM_read32(repMatch)) {
++				if (ZSTD_read32(ip) == ZSTD_read32(repMatch)) {
 +					/* repcode detected we should take it */
 +					const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
-+				matchLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
++					matchLength =
-+				offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset;   /* swap offset history */
++					    ZSTD_count_2segments(ip + EQUAL_READ32, repMatch + EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
++					offset = offset_2;
++					offset_2 = offset_1;
++					offset_1 = (U32)offset; /* swap offset history */
 +					ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength - MINMATCH);
 +					ip += matchLength;
 +					anchor = ip;
 +					continue; /* faster when present ... (?) */
 +				}
 +			break;
-+	}   }
++		}
++	}
 +
 +	/* Save reps for next block */
-+	ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
++	ctx->repToConfirm[0] = offset_1;
++	ctx->repToConfirm[1] = offset_2;
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
++void ZSTD_compressBlock_greedy_extDict(ZSTD_CCtx *ctx, const void *src, size_t srcSize) { ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 0); }
-+void ZSTD_compressBlock_greedy_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-+{
-+	ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 0);
-+}
 +
 +static void ZSTD_compressBlock_lazy_extDict(ZSTD_CCtx *ctx, const void *src, size_t srcSize)
 +{
@@ -3753,7 +3837,6 @@ index 0000000..a078969
 +	ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 1, 2);
 +}
 +
-+
 +/* The optimal parser */
 +#include "zstd_opt.h"
 +
@@ -3762,7 +3845,9 @@ index 0000000..a078969
 +#ifdef ZSTD_OPT_H_91842398743
 +	ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0);
 +#else
-+	(void)ctx; (void)src; (void)srcSize;
++	(void)ctx;
++	(void)src;
++	(void)srcSize;
 +	return;
 +#endif
 +}
@@ -3772,7 +3857,9 @@ index 0000000..a078969
 +#ifdef ZSTD_OPT_H_91842398743
 +	ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1);
 +#else
-+	(void)ctx; (void)src; (void)srcSize;
++	(void)ctx;
++	(void)src;
++	(void)srcSize;
 +	return;
 +#endif
 +}
@@ -3782,7 +3869,9 @@ index 0000000..a078969
 +#ifdef ZSTD_OPT_H_91842398743
 +	ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize, 0);
 +#else
-+	(void)ctx; (void)src; (void)srcSize;
++	(void)ctx;
++	(void)src;
++	(void)srcSize;
 +	return;
 +#endif
 +}
@@ -3792,32 +3881,34 @@ index 0000000..a078969
 +#ifdef ZSTD_OPT_H_91842398743
 +	ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize, 1);
 +#else
-+	(void)ctx; (void)src; (void)srcSize;
++	(void)ctx;
++	(void)src;
++	(void)srcSize;
 +	return;
 +#endif
 +}
 +
-+
 +typedef void (*ZSTD_blockCompressor)(ZSTD_CCtx *ctx, const void *src, size_t srcSize);
 +
 +static ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, int extDict)
 +{
 +	static const ZSTD_blockCompressor blockCompressor[2][8] = {
-+		{ ZSTD_compressBlock_fast, ZSTD_compressBlock_doubleFast, ZSTD_compressBlock_greedy, ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy2, ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btopt, ZSTD_compressBlock_btopt2 },
++	    {ZSTD_compressBlock_fast, ZSTD_compressBlock_doubleFast, ZSTD_compressBlock_greedy, ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy2,
-+		{ ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_doubleFast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btopt2_extDict }
++	     ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btopt, ZSTD_compressBlock_btopt2},
-+	};
++	    {ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_doubleFast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,
++	     ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btopt2_extDict}};
 +
 +	return blockCompressor[extDict][(U32)strat];
 +}
 +
-+
 +static size_t ZSTD_compressBlock_internal(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->params.cParams.strategy, zc->lowLimit < zc->dictLimit);
 +	const BYTE *const base = zc->base;
 +	const BYTE *const istart = (const BYTE *)src;
 +	const U32 curr = (U32)(istart - base);
-+	if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) return 0;   /* don't even attempt compression below a certain srcSize */
++	if (srcSize < MIN_CBLOCK_SIZE + ZSTD_blockHeaderSize + 1)
++		return 0; /* don't even attempt compression below a certain srcSize */
 +	ZSTD_resetSeqStore(&(zc->seqStore));
 +	if (curr > zc->nextToUpdate + 384)
 +		zc->nextToUpdate = curr - MIN(192, (U32)(curr - zc->nextToUpdate - 384)); /* update tree not updated after finding very long rep matches */
@@ -3825,7 +3916,6 @@ index 0000000..a078969
 +	return ZSTD_compressSequences(zc, dst, dstCapacity, srcSize);
 +}
 +
-+
 +/*! ZSTD_compress_generic() :
 +*   Compress a chunk of data into one or multiple blocks.
 +*   All blocks will be terminated, all input will be consumed.
@@ -3833,10 +3923,7 @@ index 0000000..a078969
 +*   Frame is supposed already started (header already produced)
 +*   @return : compressed size, or an error code
 +*/
-+static size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
++static size_t ZSTD_compress_generic(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastFrameChunk)
-+									 void* dst, size_t dstCapacity,
-+							   const void* src, size_t srcSize,
-+									 U32 lastFrameChunk)
 +{
 +	size_t blockSize = cctx->blockSize;
 +	size_t remaining = srcSize;
@@ -3852,8 +3939,10 @@ index 0000000..a078969
 +		U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
 +		size_t cSize;
 +
-+		if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE) return ERROR(dstSize_tooSmall);   /* not enough space to store compressed block */
++		if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE)
-+		if (remaining < blockSize) blockSize = remaining;
++			return ERROR(dstSize_tooSmall); /* not enough space to store compressed block */
++		if (remaining < blockSize)
++			blockSize = remaining;
 +
 +		/* preemptive overflow correction */
 +		if (cctx->lowLimit > (3U << 29)) {
@@ -3867,29 +3956,35 @@ index 0000000..a078969
 +			cctx->dictBase += correction;
 +			cctx->lowLimit -= correction;
 +			cctx->dictLimit -= correction;
-+			if (cctx->nextToUpdate < correction) cctx->nextToUpdate = 0;
++			if (cctx->nextToUpdate < correction)
-+			else cctx->nextToUpdate -= correction;
++				cctx->nextToUpdate = 0;
++			else
++				cctx->nextToUpdate -= correction;
 +		}
 +
 +		if ((U32)(ip + blockSize - cctx->base) > cctx->loadedDictEnd + maxDist) {
 +			/* enforce maxDist */
 +			U32 const newLowLimit = (U32)(ip + blockSize - cctx->base) - maxDist;
-+			if (cctx->lowLimit < newLowLimit) cctx->lowLimit = newLowLimit;
++			if (cctx->lowLimit < newLowLimit)
-+			if (cctx->dictLimit < cctx->lowLimit) cctx->dictLimit = cctx->lowLimit;
++				cctx->lowLimit = newLowLimit;
++			if (cctx->dictLimit < cctx->lowLimit)
++				cctx->dictLimit = cctx->lowLimit;
 +		}
 +
 +		cSize = ZSTD_compressBlock_internal(cctx, op + ZSTD_blockHeaderSize, dstCapacity - ZSTD_blockHeaderSize, ip, blockSize);
-+		if (ZSTD_isError(cSize)) return cSize;
++		if (ZSTD_isError(cSize))
++			return cSize;
 +
 +		if (cSize == 0) { /* block is not compressible */
 +			U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw) << 1) + (U32)(blockSize << 3);
-+			if (blockSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
++			if (blockSize + ZSTD_blockHeaderSize > dstCapacity)
-+			MEM_writeLE32(op, cBlockHeader24);   /* no pb, 4th byte will be overwritten */
++				return ERROR(dstSize_tooSmall);
++			ZSTD_writeLE32(op, cBlockHeader24); /* no pb, 4th byte will be overwritten */
 +			memcpy(op + ZSTD_blockHeaderSize, ip, blockSize);
 +			cSize = ZSTD_blockHeaderSize + blockSize;
 +		} else {
 +			U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed) << 1) + (U32)(cSize << 3);
-+			MEM_writeLE24(op, cBlockHeader24);
++			ZSTD_writeLE24(op, cBlockHeader24);
 +			cSize += ZSTD_blockHeaderSize;
 +		}
 +
@@ -3899,63 +3994,83 @@ index 0000000..a078969
 +		op += cSize;
 +	}
 +
-+	if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
++	if (lastFrameChunk && (op > ostart))
++		cctx->stage = ZSTDcs_ending;
 +	return op - ostart;
 +}
 +
-+
++static size_t ZSTD_writeFrameHeader(void *dst, size_t dstCapacity, ZSTD_parameters params, U64 pledgedSrcSize, U32 dictID)
-+static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
++{
-+									ZSTD_parameters params, U64 pledgedSrcSize, U32 dictID)
++	BYTE *const op = (BYTE *)dst;
-+{   BYTE* const op = (BYTE*)dst;
 +	U32 const dictIDSizeCode = (dictID > 0) + (dictID >= 256) + (dictID >= 65536); /* 0-3 */
 +	U32 const checksumFlag = params.fParams.checksumFlag > 0;
 +	U32 const windowSize = 1U << params.cParams.windowLog;
 +	U32 const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
 +	BYTE const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
-+	U32   const fcsCode = params.fParams.contentSizeFlag ?
++	U32 const fcsCode = params.fParams.contentSizeFlag ? (pledgedSrcSize >= 256) + (pledgedSrcSize >= 65536 + 256) + (pledgedSrcSize >= 0xFFFFFFFFU)
-+					 (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) :   /* 0-3 */
++							   : /* 0-3 */
 +				0;
 +	BYTE const frameHeaderDecriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag << 2) + (singleSegment << 5) + (fcsCode << 6));
 +	size_t pos;
 +
-+	if (dstCapacity < ZSTD_frameHeaderSize_max) return ERROR(dstSize_tooSmall);
++	if (dstCapacity < ZSTD_frameHeaderSize_max)
++		return ERROR(dstSize_tooSmall);
 +
-+	MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
++	ZSTD_writeLE32(dst, ZSTD_MAGICNUMBER);
-+	op[4] = frameHeaderDecriptionByte; pos=5;
++	op[4] = frameHeaderDecriptionByte;
-+	if (!singleSegment) op[pos++] = windowLogByte;
++	pos = 5;
-+	switch(dictIDSizeCode)
++	if (!singleSegment)
-+	{
++		op[pos++] = windowLogByte;
++	switch (dictIDSizeCode) {
 +	default: /* impossible */
 +	case 0: break;
-+		case 1 : op[pos] = (BYTE)(dictID); pos++; break;
++	case 1:
-+		case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;
++		op[pos] = (BYTE)(dictID);
-+		case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;
++		pos++;
++		break;
++	case 2:
++		ZSTD_writeLE16(op + pos, (U16)dictID);
++		pos += 2;
++		break;
++	case 3:
++		ZSTD_writeLE32(op + pos, dictID);
++		pos += 4;
++		break;
 +	}
-+	switch(fcsCode)
++	switch (fcsCode) {
-+	{
 +	default: /* impossible */
-+		case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;
++	case 0:
-+		case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;
++		if (singleSegment)
-+		case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;
++			op[pos++] = (BYTE)(pledgedSrcSize);
-+		case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;
++		break;
++	case 1:
++		ZSTD_writeLE16(op + pos, (U16)(pledgedSrcSize - 256));
++		pos += 2;
++		break;
++	case 2:
++		ZSTD_writeLE32(op + pos, (U32)(pledgedSrcSize));
++		pos += 4;
++		break;
++	case 3:
++		ZSTD_writeLE64(op + pos, (U64)(pledgedSrcSize));
++		pos += 8;
++		break;
 +	}
 +	return pos;
 +}
 +
-+
++static size_t ZSTD_compressContinue_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame, U32 lastFrameChunk)
-+static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
-+							  void* dst, size_t dstCapacity,
-+						const void* src, size_t srcSize,
-+							   U32 frame, U32 lastFrameChunk)
 +{
 +	const BYTE *const ip = (const BYTE *)src;
 +	size_t fhSize = 0;
 +
-+	if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong);   /* missing init (ZSTD_compressBegin) */
++	if (cctx->stage == ZSTDcs_created)
++		return ERROR(stage_wrong); /* missing init (ZSTD_compressBegin) */
 +
 +	if (frame && (cctx->stage == ZSTDcs_init)) {
 +		fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->params, cctx->frameContentSize, cctx->dictID);
-+		if (ZSTD_isError(fhSize)) return fhSize;
++		if (ZSTD_isError(fhSize))
++			return fhSize;
 +		dstCapacity -= fhSize;
 +		dst = (char *)dst + fhSize;
 +		cctx->stage = ZSTDcs_ongoing;
@@ -3970,7 +4085,8 @@ index 0000000..a078969
 +		cctx->dictBase = cctx->base;
 +		cctx->base -= delta;
 +		cctx->nextToUpdate = cctx->dictLimit;
-+		if (cctx->dictLimit - cctx->lowLimit < HASH_READ_SIZE) cctx->lowLimit = cctx->dictLimit;   /* too small extDict */
++		if (cctx->dictLimit - cctx->lowLimit < HASH_READ_SIZE)
++			cctx->lowLimit = cctx->dictLimit; /* too small extDict */
 +	}
 +
 +	/* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
@@ -3983,33 +4099,27 @@ index 0000000..a078969
 +	cctx->nextSrc = ip + srcSize;
 +
 +	if (srcSize) {
-+		size_t const cSize = frame ?
++		size_t const cSize = frame ? ZSTD_compress_generic(cctx, dst, dstCapacity, src, srcSize, lastFrameChunk)
-+							 ZSTD_compress_generic (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
++					   : ZSTD_compressBlock_internal(cctx, dst, dstCapacity, src, srcSize);
-+							 ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
++		if (ZSTD_isError(cSize))
-+		if (ZSTD_isError(cSize)) return cSize;
++			return cSize;
 +		return cSize + fhSize;
 +	} else
 +		return fhSize;
 +}
 +
-+
++size_t ZSTD_compressContinue(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
-+size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
-+							  void* dst, size_t dstCapacity,
-+						const void* src, size_t srcSize)
 +{
 +	return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 0);
 +}
 +
-+
++size_t ZSTD_getBlockSizeMax(ZSTD_CCtx *cctx) { return MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, 1 << cctx->params.cParams.windowLog); }
-+size_t ZSTD_getBlockSizeMax(ZSTD_CCtx* cctx)
-+{
-+	return MIN (ZSTD_BLOCKSIZE_ABSOLUTEMAX, 1 << cctx->params.cParams.windowLog);
-+}
 +
 +size_t ZSTD_compressBlock(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	size_t const blockSizeMax = ZSTD_getBlockSizeMax(cctx);
-+	if (srcSize > blockSizeMax) return ERROR(srcSize_wrong);
++	if (srcSize > blockSizeMax)
++		return ERROR(srcSize_wrong);
 +	return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0, 0);
 +}
 +
@@ -4030,17 +4140,13 @@ index 0000000..a078969
 +	zc->loadedDictEnd = zc->forceWindow ? 0 : (U32)(iend - zc->base);
 +
 +	zc->nextSrc = iend;
-+	if (srcSize <= HASH_READ_SIZE) return 0;
++	if (srcSize <= HASH_READ_SIZE)
++		return 0;
 +
-+	switch(zc->params.cParams.strategy)
++	switch (zc->params.cParams.strategy) {
-+	{
++	case ZSTD_fast: ZSTD_fillHashTable(zc, iend, zc->params.cParams.searchLength); break;
-+	case ZSTD_fast:
-+		ZSTD_fillHashTable (zc, iend, zc->params.cParams.searchLength);
-+		break;
 +
-+	case ZSTD_dfast:
++	case ZSTD_dfast: ZSTD_fillDoubleHashTable(zc, iend, zc->params.cParams.searchLength); break;
-+		ZSTD_fillDoubleHashTable (zc, iend, zc->params.cParams.searchLength);
-+		break;
 +
 +	case ZSTD_greedy:
 +	case ZSTD_lazy:
@@ -4064,21 +4170,22 @@ index 0000000..a078969
 +	return 0;
 +}
 +
-+
 +/* Dictionaries that assign zero probability to symbols that show up causes problems
 +   when FSE encoding.  Refuse dictionaries that assign zero probability to symbols
 +   that we may encounter during compression.
 +   NOTE: This behavior is not standard and could be improved in the future. */
-+static size_t ZSTD_checkDictNCount(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue) {
++static size_t ZSTD_checkDictNCount(short *normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue)
++{
 +	U32 s;
-+	if (dictMaxSymbolValue < maxSymbolValue) return ERROR(dictionary_corrupted);
++	if (dictMaxSymbolValue < maxSymbolValue)
++		return ERROR(dictionary_corrupted);
 +	for (s = 0; s <= maxSymbolValue; ++s) {
-+		if (normalizedCounter[s] == 0) return ERROR(dictionary_corrupted);
++		if (normalizedCounter[s] == 0)
++			return ERROR(dictionary_corrupted);
 +	}
 +	return 0;
 +}
 +
-+
 +/* Dictionary format :
 + * See :
 + * https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
@@ -4097,52 +4204,69 @@ index 0000000..a078969
 +	BYTE scratchBuffer[1 << MAX(MLFSELog, LLFSELog)];
 +
 +	dictPtr += 4; /* skip magic number */
-+	cctx->dictID = cctx->params.fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr);
++	cctx->dictID = cctx->params.fParams.noDictIDFlag ? 0 : ZSTD_readLE32(dictPtr);
 +	dictPtr += 4;
 +
-+	{	size_t const hufHeaderSize = HUF_readCTable(cctx->hufTable, 255, dictPtr, dictEnd-dictPtr);
++	{
-+		if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted);
++		size_t const hufHeaderSize = HUF_readCTable(cctx->hufTable, 255, dictPtr, dictEnd - dictPtr);
++		if (HUF_isError(hufHeaderSize))
++			return ERROR(dictionary_corrupted);
 +		dictPtr += hufHeaderSize;
 +	}
 +
-+	{	unsigned offcodeLog;
++	{
++		unsigned offcodeLog;
 +		size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(offcodeHeaderSize))
-+		if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (offcodeLog > OffFSELog)
++			return ERROR(dictionary_corrupted);
 +		/* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
-+		CHECK_E (FSE_buildCTable_wksp(cctx->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog, scratchBuffer, sizeof(scratchBuffer)), dictionary_corrupted);
++		CHECK_E(FSE_buildCTable_wksp(cctx->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog, scratchBuffer, sizeof(scratchBuffer)),
++			dictionary_corrupted);
 +		dictPtr += offcodeHeaderSize;
 +	}
 +
-+	{	short matchlengthNCount[MaxML+1];
++	{
++		short matchlengthNCount[MaxML + 1];
 +		unsigned matchlengthMaxValue = MaxML, matchlengthLog;
 +		size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(matchlengthHeaderSize))
-+		if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (matchlengthLog > MLFSELog)
++			return ERROR(dictionary_corrupted);
 +		/* Every match length code must have non-zero probability */
 +		CHECK_F(ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
-+		CHECK_E (FSE_buildCTable_wksp(cctx->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, scratchBuffer, sizeof(scratchBuffer)), dictionary_corrupted);
++		CHECK_E(
++		    FSE_buildCTable_wksp(cctx->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, scratchBuffer, sizeof(scratchBuffer)),
++		    dictionary_corrupted);
 +		dictPtr += matchlengthHeaderSize;
 +	}
 +
-+	{	short litlengthNCount[MaxLL+1];
++	{
++		short litlengthNCount[MaxLL + 1];
 +		unsigned litlengthMaxValue = MaxLL, litlengthLog;
 +		size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(litlengthHeaderSize))
-+		if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (litlengthLog > LLFSELog)
++			return ERROR(dictionary_corrupted);
 +		/* Every literal length code must have non-zero probability */
 +		CHECK_F(ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
-+		CHECK_E(FSE_buildCTable_wksp(cctx->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, scratchBuffer, sizeof(scratchBuffer)), dictionary_corrupted);
++		CHECK_E(FSE_buildCTable_wksp(cctx->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, scratchBuffer, sizeof(scratchBuffer)),
++			dictionary_corrupted);
 +		dictPtr += litlengthHeaderSize;
 +	}
 +
-+	if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
++	if (dictPtr + 12 > dictEnd)
-+	cctx->rep[0] = MEM_readLE32(dictPtr+0);
++		return ERROR(dictionary_corrupted);
-+	cctx->rep[1] = MEM_readLE32(dictPtr+4);
++	cctx->rep[0] = ZSTD_readLE32(dictPtr + 0);
-+	cctx->rep[2] = MEM_readLE32(dictPtr+8);
++	cctx->rep[1] = ZSTD_readLE32(dictPtr + 4);
++	cctx->rep[2] = ZSTD_readLE32(dictPtr + 8);
 +	dictPtr += 12;
 +
-+	{	size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
++	{
++		size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
 +		U32 offcodeMax = MaxOff;
 +		if (dictContentSize <= ((U32)-1) - 128 KB) {
 +			U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */
@@ -4151,11 +4275,15 @@ index 0000000..a078969
 +		/* All offset values <= dictContentSize + 128 KB must be representable */
 +		CHECK_F(ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff)));
 +		/* All repCodes must be <= dictContentSize and != 0*/
-+		{	U32 u;
++		{
++			U32 u;
 +			for (u = 0; u < 3; u++) {
-+				if (cctx->rep[u] == 0) return ERROR(dictionary_corrupted);
++				if (cctx->rep[u] == 0)
-+				if (cctx->rep[u] > dictContentSize) return ERROR(dictionary_corrupted);
++					return ERROR(dictionary_corrupted);
-+		}   }
++				if (cctx->rep[u] > dictContentSize)
++					return ERROR(dictionary_corrupted);
++			}
++		}
 +
 +		cctx->flagStaticTables = 1;
 +		cctx->flagStaticHufTable = HUF_repeat_valid;
@@ -4167,10 +4295,11 @@ index 0000000..a078969
 +*   @return : 0, or an error code */
 +static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx *cctx, const void *dict, size_t dictSize)
 +{
-+	if ((dict==NULL) || (dictSize<=8)) return 0;
++	if ((dict == NULL) || (dictSize <= 8))
++		return 0;
 +
 +	/* dict as pure content */
-+	if ((MEM_readLE32(dict) != ZSTD_DICT_MAGIC) || (cctx->forceRawDict))
++	if ((ZSTD_readLE32(dict) != ZSTD_DICT_MAGIC) || (cctx->forceRawDict))
 +		return ZSTD_loadDictionaryContent(cctx, dict, dictSize);
 +
 +	/* dict as zstd dictionary */
@@ -4179,40 +4308,29 @@ index 0000000..a078969
 +
 +/*! ZSTD_compressBegin_internal() :
 +*   @return : 0, or an error code */
-+static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
++static size_t ZSTD_compressBegin_internal(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_parameters params, U64 pledgedSrcSize)
-+							 const void* dict, size_t dictSize,
-+								   ZSTD_parameters params, U64 pledgedSrcSize)
 +{
 +	ZSTD_compResetPolicy_e const crp = dictSize ? ZSTDcrp_fullReset : ZSTDcrp_continue;
 +	CHECK_F(ZSTD_resetCCtx_advanced(cctx, params, pledgedSrcSize, crp));
 +	return ZSTD_compress_insertDictionary(cctx, dict, dictSize);
 +}
 +
-+
 +/*! ZSTD_compressBegin_advanced() :
 +*   @return : 0, or an error code */
-+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
++size_t ZSTD_compressBegin_advanced(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize)
-+							 const void* dict, size_t dictSize,
-+								   ZSTD_parameters params, unsigned long long pledgedSrcSize)
 +{
 +	/* compression parameters verification and optimization */
 +	CHECK_F(ZSTD_checkCParams(params.cParams));
 +	return ZSTD_compressBegin_internal(cctx, dict, dictSize, params, pledgedSrcSize);
 +}
 +
-+
 +size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, int compressionLevel)
 +{
 +	ZSTD_parameters const params = ZSTD_getParams(compressionLevel, 0, dictSize);
 +	return ZSTD_compressBegin_internal(cctx, dict, dictSize, params, 0);
 +}
 +
-+
++size_t ZSTD_compressBegin(ZSTD_CCtx *cctx, int compressionLevel) { return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel); }
-+size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
-+{
-+	return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
-+}
-+
 +
 +/*! ZSTD_writeEpilogue() :
 +*   Ends a frame.
@@ -4223,12 +4341,14 @@ index 0000000..a078969
 +	BYTE *op = ostart;
 +	size_t fhSize = 0;
 +
-+	if (cctx->stage == ZSTDcs_created) return ERROR(stage_wrong);  /* init missing */
++	if (cctx->stage == ZSTDcs_created)
++		return ERROR(stage_wrong); /* init missing */
 +
 +	/* special case : empty frame */
 +	if (cctx->stage == ZSTDcs_init) {
 +		fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->params, 0, 0);
-+		if (ZSTD_isError(fhSize)) return fhSize;
++		if (ZSTD_isError(fhSize))
++			return fhSize;
 +		dstCapacity -= fhSize;
 +		op += fhSize;
 +		cctx->stage = ZSTDcs_ongoing;
@@ -4237,16 +4357,18 @@ index 0000000..a078969
 +	if (cctx->stage != ZSTDcs_ending) {
 +		/* write one last empty block, make it the "last" block */
 +		U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw) << 1) + 0;
-+		if (dstCapacity<4) return ERROR(dstSize_tooSmall);
++		if (dstCapacity < 4)
-+		MEM_writeLE32(op, cBlockHeader24);
++			return ERROR(dstSize_tooSmall);
++		ZSTD_writeLE32(op, cBlockHeader24);
 +		op += ZSTD_blockHeaderSize;
 +		dstCapacity -= ZSTD_blockHeaderSize;
 +	}
 +
 +	if (cctx->params.fParams.checksumFlag) {
 +		U32 const checksum = (U32)xxh64_digest(&cctx->xxhState);
-+		if (dstCapacity<4) return ERROR(dstSize_tooSmall);
++		if (dstCapacity < 4)
-+		MEM_writeLE32(op, checksum);
++			return ERROR(dstSize_tooSmall);
++		ZSTD_writeLE32(op, checksum);
 +		op += 4;
 +	}
 +
@@ -4254,42 +4376,36 @@ index 0000000..a078969
 +	return op - ostart;
 +}
 +
-+
++size_t ZSTD_compressEnd(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
-+size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
-+						 void* dst, size_t dstCapacity,
-+				   const void* src, size_t srcSize)
 +{
 +	size_t endResult;
 +	size_t const cSize = ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 1);
-+	if (ZSTD_isError(cSize)) return cSize;
++	if (ZSTD_isError(cSize))
++		return cSize;
 +	endResult = ZSTD_writeEpilogue(cctx, (char *)dst + cSize, dstCapacity - cSize);
-+	if (ZSTD_isError(endResult)) return endResult;
++	if (ZSTD_isError(endResult))
++		return endResult;
 +	return cSize + endResult;
 +}
 +
-+
++static size_t ZSTD_compress_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize,
-+static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
-+							   void* dst, size_t dstCapacity,
-+						 const void* src, size_t srcSize,
-+						 const void* dict,size_t dictSize,
 +				     ZSTD_parameters params)
 +{
 +	CHECK_F(ZSTD_compressBegin_internal(cctx, dict, dictSize, params, srcSize));
 +	return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
 +}
 +
-+size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, ZSTD_parameters params)
++size_t ZSTD_compress_usingDict(ZSTD_CCtx *ctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize,
++			       ZSTD_parameters params)
 +{
 +	return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
 +}
 +
-+
 +size_t ZSTD_compressCCtx(ZSTD_CCtx *ctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, ZSTD_parameters params)
 +{
 +	return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, NULL, 0, params);
 +}
 +
-+
 +/* =====  Dictionary API  ===== */
 +
 +struct ZSTD_CDict_s {
@@ -4299,17 +4415,15 @@ index 0000000..a078969
 +	ZSTD_CCtx *refContext;
 +}; /* typedef'd tp ZSTD_CDict within "zstd.h" */
 +
-+size_t ZSTD_CDictWorkspaceBound(ZSTD_compressionParameters cParams)
++size_t ZSTD_CDictWorkspaceBound(ZSTD_compressionParameters cParams) { return ZSTD_CCtxWorkspaceBound(cParams) + ZSTD_ALIGN(sizeof(ZSTD_CDict)); }
-+{
-+	return ZSTD_CCtxWorkspaceBound(cParams) + ZSTD_ALIGN(sizeof(ZSTD_CDict));
-+}
 +
-+static ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize, unsigned byReference,
++static ZSTD_CDict *ZSTD_createCDict_advanced(const void *dictBuffer, size_t dictSize, unsigned byReference, ZSTD_parameters params, ZSTD_customMem customMem)
-+											 ZSTD_parameters params, ZSTD_customMem customMem)
 +{
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +
-+	{	ZSTD_CDict* const cdict = (ZSTD_CDict*) ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
++	{
++		ZSTD_CDict *const cdict = (ZSTD_CDict *)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
 +		ZSTD_CCtx *const cctx = ZSTD_createCCtx_advanced(customMem);
 +
 +		if (!cdict || !cctx) {
@@ -4323,19 +4437,25 @@ index 0000000..a078969
 +			cdict->dictContent = dictBuffer;
 +		} else {
 +			void *const internalBuffer = ZSTD_malloc(dictSize, customMem);
-+			if (!internalBuffer) { ZSTD_free(cctx, customMem); ZSTD_free(cdict, customMem); return NULL; }
++			if (!internalBuffer) {
++				ZSTD_free(cctx, customMem);
++				ZSTD_free(cdict, customMem);
++				return NULL;
++			}
 +			memcpy(internalBuffer, dictBuffer, dictSize);
 +			cdict->dictBuffer = internalBuffer;
 +			cdict->dictContent = internalBuffer;
 +		}
 +
-+		{	size_t const errorCode = ZSTD_compressBegin_advanced(cctx, cdict->dictContent, dictSize, params, 0);
++		{
++			size_t const errorCode = ZSTD_compressBegin_advanced(cctx, cdict->dictContent, dictSize, params, 0);
 +			if (ZSTD_isError(errorCode)) {
 +				ZSTD_free(cdict->dictBuffer, customMem);
 +				ZSTD_free(cdict, customMem);
 +				ZSTD_freeCCtx(cctx);
 +				return NULL;
-+		}   }
++			}
++		}
 +
 +		cdict->refContext = cctx;
 +		cdict->dictContentSize = dictSize;
@@ -4351,8 +4471,10 @@ index 0000000..a078969
 +
 +size_t ZSTD_freeCDict(ZSTD_CDict *cdict)
 +{
-+	if (cdict==NULL) return 0;   /* support free on NULL */
++	if (cdict == NULL)
-+	{	ZSTD_customMem const cMem = cdict->refContext->customMem;
++		return 0; /* support free on NULL */
++	{
++		ZSTD_customMem const cMem = cdict->refContext->customMem;
 +		ZSTD_freeCCtx(cdict->refContext);
 +		ZSTD_free(cdict->dictBuffer, cMem);
 +		ZSTD_free(cdict, cMem);
@@ -4360,13 +4482,12 @@ index 0000000..a078969
 +	}
 +}
 +
-+static ZSTD_parameters ZSTD_getParamsFromCDict(const ZSTD_CDict* cdict) {
++static ZSTD_parameters ZSTD_getParamsFromCDict(const ZSTD_CDict *cdict) { return ZSTD_getParamsFromCCtx(cdict->refContext); }
-+	return ZSTD_getParamsFromCCtx(cdict->refContext);
-+}
 +
 +size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx *cctx, const ZSTD_CDict *cdict, unsigned long long pledgedSrcSize)
 +{
-+	if (cdict->dictContentSize) CHECK_F(ZSTD_copyCCtx(cctx, cdict->refContext, pledgedSrcSize))
++	if (cdict->dictContentSize)
++		CHECK_F(ZSTD_copyCCtx(cctx, cdict->refContext, pledgedSrcSize))
 +	else {
 +		ZSTD_parameters params = cdict->refContext->params;
 +		params.fParams.contentSizeFlag = (pledgedSrcSize > 0);
@@ -4379,10 +4500,7 @@ index 0000000..a078969
 +*   Compression using a digested Dictionary.
 +*   Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times.
 +*   Note that compression level is decided during dictionary creation */
-+size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
++size_t ZSTD_compress_usingCDict(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const ZSTD_CDict *cdict)
-+								void* dst, size_t dstCapacity,
-+								const void* src, size_t srcSize,
-+								const ZSTD_CDict* cdict)
 +{
 +	CHECK_F(ZSTD_compressBegin_usingCDict(cctx, cdict, srcSize));
 +
@@ -4396,8 +4514,6 @@ index 0000000..a078969
 +	return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
 +}
 +
-+
-+
 +/* ******************************************************************
 +*  Streaming
 +********************************************************************/
@@ -4440,21 +4556,28 @@ index 0000000..a078969
 +{
 +	ZSTD_CStream *zcs;
 +
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +
 +	zcs = (ZSTD_CStream *)ZSTD_malloc(sizeof(ZSTD_CStream), customMem);
-+	if (zcs==NULL) return NULL;
++	if (zcs == NULL)
++		return NULL;
 +	memset(zcs, 0, sizeof(ZSTD_CStream));
 +	memcpy(&zcs->customMem, &customMem, sizeof(ZSTD_customMem));
 +	zcs->cctx = ZSTD_createCCtx_advanced(customMem);
-+	if (zcs->cctx == NULL) { ZSTD_freeCStream(zcs); return NULL; }
++	if (zcs->cctx == NULL) {
++		ZSTD_freeCStream(zcs);
++		return NULL;
++	}
 +	return zcs;
 +}
 +
 +size_t ZSTD_freeCStream(ZSTD_CStream *zcs)
 +{
-+	if (zcs==NULL) return 0;   /* support free on NULL */
++	if (zcs == NULL)
-+	{	ZSTD_customMem const cMem = zcs->customMem;
++		return 0; /* support free on NULL */
++	{
++		ZSTD_customMem const cMem = zcs->customMem;
 +		ZSTD_freeCCtx(zcs->cctx);
 +		zcs->cctx = NULL;
 +		ZSTD_freeCDict(zcs->cdictLocal);
@@ -4468,7 +4591,6 @@ index 0000000..a078969
 +	}
 +}
 +
-+
 +/*======   Initialization   ======*/
 +
 +size_t ZSTD_CStreamInSize(void) { return ZSTD_BLOCKSIZE_ABSOLUTEMAX; }
@@ -4476,10 +4598,13 @@ index 0000000..a078969
 +
 +static size_t ZSTD_resetCStream_internal(ZSTD_CStream *zcs, unsigned long long pledgedSrcSize)
 +{
-+	if (zcs->inBuffSize==0) return ERROR(stage_wrong);   /* zcs has not been init at least once => can't reset */
++	if (zcs->inBuffSize == 0)
++		return ERROR(stage_wrong); /* zcs has not been init at least once => can't reset */
 +
-+	if (zcs->cdict) CHECK_F(ZSTD_compressBegin_usingCDict(zcs->cctx, zcs->cdict, pledgedSrcSize))
++	if (zcs->cdict)
-+	else CHECK_F(ZSTD_compressBegin_advanced(zcs->cctx, NULL, 0, zcs->params, pledgedSrcSize));
++		CHECK_F(ZSTD_compressBegin_usingCDict(zcs->cctx, zcs->cdict, pledgedSrcSize))
++	else
++		CHECK_F(ZSTD_compressBegin_advanced(zcs->cctx, NULL, 0, zcs->params, pledgedSrcSize));
 +
 +	zcs->inToCompress = 0;
 +	zcs->inBuffPos = 0;
@@ -4500,17 +4625,17 @@ index 0000000..a078969
 +	return ZSTD_resetCStream_internal(zcs, pledgedSrcSize);
 +}
 +
-+static size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
++static size_t ZSTD_initCStream_advanced(ZSTD_CStream *zcs, const void *dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize)
-+								 const void* dict, size_t dictSize,
-+								 ZSTD_parameters params, unsigned long long pledgedSrcSize)
 +{
 +	/* allocate buffers */
-+	{	size_t const neededInBuffSize = (size_t)1 << params.cParams.windowLog;
++	{
++		size_t const neededInBuffSize = (size_t)1 << params.cParams.windowLog;
 +		if (zcs->inBuffSize < neededInBuffSize) {
 +			zcs->inBuffSize = neededInBuffSize;
 +			ZSTD_free(zcs->inBuff, zcs->customMem);
 +			zcs->inBuff = (char *)ZSTD_malloc(neededInBuffSize, zcs->customMem);
-+			if (zcs->inBuff == NULL) return ERROR(memory_allocation);
++			if (zcs->inBuff == NULL)
++				return ERROR(memory_allocation);
 +		}
 +		zcs->blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, neededInBuffSize);
 +	}
@@ -4518,15 +4643,18 @@ index 0000000..a078969
 +		zcs->outBuffSize = ZSTD_compressBound(zcs->blockSize) + 1;
 +		ZSTD_free(zcs->outBuff, zcs->customMem);
 +		zcs->outBuff = (char *)ZSTD_malloc(zcs->outBuffSize, zcs->customMem);
-+		if (zcs->outBuff == NULL) return ERROR(memory_allocation);
++		if (zcs->outBuff == NULL)
++			return ERROR(memory_allocation);
 +	}
 +
 +	if (dict && dictSize >= 8) {
 +		ZSTD_freeCDict(zcs->cdictLocal);
 +		zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize, 0, params, zcs->customMem);
-+		if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
++		if (zcs->cdictLocal == NULL)
++			return ERROR(memory_allocation);
 +		zcs->cdict = zcs->cdictLocal;
-+	} else zcs->cdict = NULL;
++	} else
++		zcs->cdict = NULL;
 +
 +	zcs->checksum = params.fParams.checksumFlag > 0;
 +	zcs->params = params;
@@ -4540,7 +4668,9 @@ index 0000000..a078969
 +	ZSTD_CStream *const zcs = ZSTD_createCStream_advanced(stackMem);
 +	if (zcs) {
 +		size_t const code = ZSTD_initCStream_advanced(zcs, NULL, 0, params, pledgedSrcSize);
-+		if (ZSTD_isError(code)) { return NULL; }
++		if (ZSTD_isError(code)) {
++			return NULL;
++		}
 +	}
 +	return zcs;
 +}
@@ -4562,17 +4692,14 @@ index 0000000..a078969
 +
 +typedef enum { zsf_gather, zsf_flush, zsf_end } ZSTD_flush_e;
 +
-+MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
++ZSTD_STATIC size_t ZSTD_limitCopy(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	size_t const length = MIN(dstCapacity, srcSize);
 +	memcpy(dst, src, length);
 +	return length;
 +}
 +
-+static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
++static size_t ZSTD_compressStream_generic(ZSTD_CStream *zcs, void *dst, size_t *dstCapacityPtr, const void *src, size_t *srcSizePtr, ZSTD_flush_e const flush)
-+							  void* dst, size_t* dstCapacityPtr,
-+						const void* src, size_t* srcSizePtr,
-+							  ZSTD_flush_e const flush)
 +{
 +	U32 someMoreWork = 1;
 +	const char *const istart = (const char *)src;
@@ -4583,21 +4710,25 @@ index 0000000..a078969
 +	char *op = ostart;
 +
 +	while (someMoreWork) {
-+		switch(zcs->stage)
++		switch (zcs->stage) {
-+		{
++		case zcss_init:
-+		case zcss_init: return ERROR(init_missing);   /* call ZBUFF_compressInit() first ! */
++			return ERROR(init_missing); /* call ZBUFF_compressInit() first ! */
 +
 +		case zcss_load:
 +			/* complete inBuffer */
-+			{	size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
++			{
++				size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
 +				size_t const loaded = ZSTD_limitCopy(zcs->inBuff + zcs->inBuffPos, toLoad, ip, iend - ip);
 +				zcs->inBuffPos += loaded;
 +				ip += loaded;
 +				if ((zcs->inBuffPos == zcs->inToCompress) || (!flush && (toLoad != loaded))) {
-+					someMoreWork = 0; break;  /* not enough input to get a full block : stop there, wait for more */
++					someMoreWork = 0;
-+			}   }
++					break; /* not enough input to get a full block : stop there, wait for more */
++				}
++			}
 +			/* compress curr block (note : this stage cannot be stopped in the middle) */
-+			{	void* cDst;
++			{
++				void *cDst;
 +				size_t cSize;
 +				size_t const iSize = zcs->inBuffPos - zcs->inToCompress;
 +				size_t oSize = oend - op;
@@ -4605,28 +4736,35 @@ index 0000000..a078969
 +					cDst = op; /* compress directly into output buffer (avoid flush stage) */
 +				else
 +					cDst = zcs->outBuff, oSize = zcs->outBuffSize;
-+				cSize = (flush == zsf_end) ?
++				cSize = (flush == zsf_end) ? ZSTD_compressEnd(zcs->cctx, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize)
-+						ZSTD_compressEnd(zcs->cctx, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize) :
++							   : ZSTD_compressContinue(zcs->cctx, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize);
-+						ZSTD_compressContinue(zcs->cctx, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize);
++				if (ZSTD_isError(cSize))
-+				if (ZSTD_isError(cSize)) return cSize;
++					return cSize;
-+				if (flush == zsf_end) zcs->frameEnded = 1;
++				if (flush == zsf_end)
++					zcs->frameEnded = 1;
 +				/* prepare next block */
 +				zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
 +				if (zcs->inBuffTarget > zcs->inBuffSize)
 +					zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize; /* note : inBuffSize >= blockSize */
 +				zcs->inToCompress = zcs->inBuffPos;
-+				if (cDst == op) { op += cSize; break; }   /* no need to flush */
++				if (cDst == op) {
++					op += cSize;
++					break;
++				} /* no need to flush */
 +				zcs->outBuffContentSize = cSize;
 +				zcs->outBuffFlushedSize = 0;
 +				zcs->stage = zcss_flush; /* pass-through to flush stage */
 +			}
 +
-+		case zcss_flush:
++		case zcss_flush: {
-+			{	size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
++			size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
 +			size_t const flushed = ZSTD_limitCopy(op, oend - op, zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
 +			op += flushed;
 +			zcs->outBuffFlushedSize += flushed;
-+				if (toFlush!=flushed) { someMoreWork = 0; break; }  /* dst too small to store flushed data : stop there */
++			if (toFlush != flushed) {
++				someMoreWork = 0;
++				break;
++			} /* dst too small to store flushed data : stop there */
 +			zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
 +			zcs->stage = zcss_load;
 +			break;
@@ -4644,9 +4782,12 @@ index 0000000..a078969
 +	*srcSizePtr = ip - istart;
 +	*dstCapacityPtr = op - ostart;
 +	zcs->inputProcessed += *srcSizePtr;
-+	if (zcs->frameEnded) return 0;
++	if (zcs->frameEnded)
-+	{	size_t hintInSize = zcs->inBuffTarget - zcs->inBuffPos;
++		return 0;
-+		if (hintInSize==0) hintInSize = zcs->blockSize;
++	{
++		size_t hintInSize = zcs->inBuffTarget - zcs->inBuffPos;
++		if (hintInSize == 0)
++			hintInSize = zcs->blockSize;
 +		return hintInSize;
 +	}
 +}
@@ -4655,15 +4796,13 @@ index 0000000..a078969
 +{
 +	size_t sizeRead = input->size - input->pos;
 +	size_t sizeWritten = output->size - output->pos;
-+	size_t const result = ZSTD_compressStream_generic(zcs,
++	size_t const result =
-+													  (char*)(output->dst) + output->pos, &sizeWritten,
++	    ZSTD_compressStream_generic(zcs, (char *)(output->dst) + output->pos, &sizeWritten, (const char *)(input->src) + input->pos, &sizeRead, zsf_gather);
-+													  (const char*)(input->src) + input->pos, &sizeRead, zsf_gather);
 +	input->pos += sizeRead;
 +	output->pos += sizeWritten;
 +	return result;
 +}
 +
-+
 +/*======   Finalize   ======*/
 +
 +/*! ZSTD_flushStream() :
@@ -4672,16 +4811,15 @@ index 0000000..a078969
 +{
 +	size_t srcSize = 0;
 +	size_t sizeWritten = output->size - output->pos;
-+	size_t const result = ZSTD_compressStream_generic(zcs,
++	size_t const result = ZSTD_compressStream_generic(zcs, (char *)(output->dst) + output->pos, &sizeWritten, &srcSize,
-+													 (char*)(output->dst) + output->pos, &sizeWritten,
++							  &srcSize, /* use a valid src address instead of NULL */
-+													 &srcSize, &srcSize, /* use a valid src address instead of NULL */
 +							  zsf_flush);
 +	output->pos += sizeWritten;
-+	if (ZSTD_isError(result)) return result;
++	if (ZSTD_isError(result))
++		return result;
 +	return zcs->outBuffContentSize - zcs->outBuffFlushedSize; /* remaining to flush */
 +}
 +
-+
 +size_t ZSTD_endStream(ZSTD_CStream *zcs, ZSTD_outBuffer *output)
 +{
 +	BYTE *const ostart = (BYTE *)(output->dst) + output->pos;
@@ -4695,7 +4833,8 @@ index 0000000..a078969
 +		/* flush whatever remains */
 +		size_t srcSize = 0;
 +		size_t sizeWritten = output->size - output->pos;
-+		size_t const notEnded = ZSTD_compressStream_generic(zcs, ostart, &sizeWritten, &srcSize, &srcSize, zsf_end);  /* use a valid src address instead of NULL */
++		size_t const notEnded =
++		    ZSTD_compressStream_generic(zcs, ostart, &sizeWritten, &srcSize, &srcSize, zsf_end); /* use a valid src address instead of NULL */
 +		size_t const remainingToFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
 +		op += sizeWritten;
 +		if (remainingToFlush) {
@@ -4704,23 +4843,23 @@ index 0000000..a078969
 +		}
 +		/* create epilogue */
 +		zcs->stage = zcss_final;
-+		zcs->outBuffContentSize = !notEnded ? 0 :
++		zcs->outBuffContentSize = !notEnded ? 0 : ZSTD_compressEnd(zcs->cctx, zcs->outBuff, zcs->outBuffSize, NULL,
-+			ZSTD_compressEnd(zcs->cctx, zcs->outBuff, zcs->outBuffSize, NULL, 0);  /* write epilogue, including final empty block, into outBuff */
++									   0); /* write epilogue, including final empty block, into outBuff */
 +	}
 +
 +	/* flush epilogue */
-+	{	size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
++	{
++		size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
 +		size_t const flushed = ZSTD_limitCopy(op, oend - op, zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
 +		op += flushed;
 +		zcs->outBuffFlushedSize += flushed;
 +		output->pos += op - ostart;
-+		if (toFlush==flushed) zcs->stage = zcss_init;  /* end reached */
++		if (toFlush == flushed)
++			zcs->stage = zcss_init; /* end reached */
 +		return toFlush - flushed;
 +	}
 +}
 +
-+
-+
 +/*-=====  Pre-defined compression levels  =====-*/
 +
 +#define ZSTD_DEFAULT_CLEVEL 1
@@ -4728,7 +4867,8 @@ index 0000000..a078969
 +int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
 +
 +static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL + 1] = {
-+{   /* "default" */
++    {
++	/* "default" */
 +	/* W,  C,  H,  S,  L, TL, strat */
 +	{18, 12, 12, 1, 7, 16, ZSTD_fast},    /* level  0 - never used */
 +	{19, 13, 14, 1, 7, 16, ZSTD_fast},    /* level  1 */
@@ -4754,7 +4894,8 @@ index 0000000..a078969
 +	{26, 26, 23, 7, 3, 256, ZSTD_btopt2}, /* level 21 */
 +	{27, 27, 25, 9, 3, 512, ZSTD_btopt2}, /* level 22 */
 +    },
-+{   /* for srcSize <= 256 KB */
++    {
++	/* for srcSize <= 256 KB */
 +	/* W,  C,  H,  S,  L,  T, strat */
 +	{0, 0, 0, 0, 0, 0, ZSTD_fast},	 /* level  0 - not used */
 +	{18, 13, 14, 1, 6, 8, ZSTD_fast},      /* level  1 */
@@ -4780,7 +4921,8 @@ index 0000000..a078969
 +	{18, 19, 18, 12, 3, 512, ZSTD_btopt2}, /* level 21.*/
 +	{18, 19, 18, 13, 3, 512, ZSTD_btopt2}, /* level 22.*/
 +    },
-+{   /* for srcSize <= 128 KB */
++    {
++	/* for srcSize <= 128 KB */
 +	/* W,  C,  H,  S,  L,  T, strat */
 +	{17, 12, 12, 1, 7, 8, ZSTD_fast},      /* level  0 - not used */
 +	{17, 12, 13, 1, 6, 8, ZSTD_fast},      /* level  1 */
@@ -4806,7 +4948,8 @@ index 0000000..a078969
 +	{17, 18, 17, 10, 3, 256, ZSTD_btopt2}, /* level 21.*/
 +	{17, 18, 17, 11, 3, 512, ZSTD_btopt2}, /* level 22.*/
 +    },
-+{   /* for srcSize <= 16 KB */
++    {
++	/* for srcSize <= 16 KB */
 +	/* W,  C,  H,  S,  L,  T, strat */
 +	{14, 12, 12, 1, 7, 6, ZSTD_fast},      /* level  0 - not used */
 +	{14, 14, 14, 1, 6, 6, ZSTD_fast},      /* level  1 */
@@ -4843,13 +4986,18 @@ index 0000000..a078969
 +	size_t const addedSize = srcSize ? 0 : 500;
 +	U64 const rSize = srcSize + dictSize ? srcSize + dictSize + addedSize : (U64)-1;
 +	U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB); /* intentional underflow for srcSizeHint == 0 */
-+	if (compressionLevel <= 0) compressionLevel = ZSTD_DEFAULT_CLEVEL;   /* 0 == default; no negative compressionLevel yet */
++	if (compressionLevel <= 0)
-+	if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL;
++		compressionLevel = ZSTD_DEFAULT_CLEVEL; /* 0 == default; no negative compressionLevel yet */
++	if (compressionLevel > ZSTD_MAX_CLEVEL)
++		compressionLevel = ZSTD_MAX_CLEVEL;
 +	cp = ZSTD_defaultCParameters[tableID][compressionLevel];
-+	if (MEM_32bits()) {   /* auto-correction, for 32-bits mode */
++	if (ZSTD_32bits()) { /* auto-correction, for 32-bits mode */
-+		if (cp.windowLog > ZSTD_WINDOWLOG_MAX) cp.windowLog = ZSTD_WINDOWLOG_MAX;
++		if (cp.windowLog > ZSTD_WINDOWLOG_MAX)
-+		if (cp.chainLog > ZSTD_CHAINLOG_MAX) cp.chainLog = ZSTD_CHAINLOG_MAX;
++			cp.windowLog = ZSTD_WINDOWLOG_MAX;
-+		if (cp.hashLog > ZSTD_HASHLOG_MAX) cp.hashLog = ZSTD_HASHLOG_MAX;
++		if (cp.chainLog > ZSTD_CHAINLOG_MAX)
++			cp.chainLog = ZSTD_CHAINLOG_MAX;
++		if (cp.hashLog > ZSTD_HASHLOG_MAX)
++			cp.hashLog = ZSTD_HASHLOG_MAX;
 +	}
 +	cp = ZSTD_adjustCParams(cp, srcSize, dictSize);
 +	return cp;
@@ -4858,7 +5006,8 @@ index 0000000..a078969
 +/*! ZSTD_getParams() :
 +*   same as ZSTD_getCParams(), but @return a `ZSTD_parameters` object (instead of `ZSTD_compressionParameters`).
 +*   All fields of `ZSTD_frameParameters` are set to default (0) */
-+ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSize, size_t dictSize) {
++ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSize, size_t dictSize)
++{
 +	ZSTD_parameters params;
 +	ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSize, dictSize);
 +	memset(&params, 0, sizeof(params));
@@ -4908,10 +5057,10 @@ index 0000000..a078969
 +MODULE_DESCRIPTION("Zstd Compressor");
 diff --git a/lib/zstd/decompress.c b/lib/zstd/decompress.c
 new file mode 100644
-index 0000000..bd76a75
+index 0000000..2926b36
 --- /dev/null
 +++ b/lib/zstd/decompress.c
-@@ -0,0 +1,2356 @@
+@@ -0,0 +1,2508 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -4928,7 +5077,6 @@ index 0000000..bd76a75
 + * ("BSD").
 + */
 +
-+
 +/* ***************************************************************
 +*  Tuning parameters
 +*****************************************************************/
@@ -4941,17 +5089,16 @@ index 0000000..bd76a75
 +#define ZSTD_MAXWINDOWSIZE_DEFAULT ((1 << ZSTD_WINDOWLOG_MAX) + 1) /* defined within zstd.h */
 +#endif
 +
-+
 +/*-*******************************************************
 +*  Dependencies
 +*********************************************************/
++#include "fse.h"
++#include "huf.h"
++#include "mem.h" /* low level memory routines */
++#include "zstd_internal.h"
 +#include <linux/kernel.h>
 +#include <linux/module.h>
 +#include <linux/string.h> /* memcpy, memmove, memset */
-+#include "mem.h"         /* low level memory routines */
-+#include "fse.h"
-+#include "huf.h"
-+#include "zstd_internal.h"
 +
 +#define ZSTD_PREFETCH(ptr) __builtin_prefetch(ptr, 0, 0)
 +
@@ -4962,20 +5109,24 @@ index 0000000..bd76a75
 +#define FSE_isError ERR_isError
 +#define HUF_isError ERR_isError
 +
-+
 +/*_*******************************************************
 +*  Memory operations
 +**********************************************************/
 +static void ZSTD_copy4(void *dst, const void *src) { memcpy(dst, src, 4); }
 +
-+
 +/*-*************************************************************
 +*   Context management
 +***************************************************************/
-+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
++typedef enum {
-+			   ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
++	ZSTDds_getFrameHeaderSize,
-+			   ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
++	ZSTDds_decodeFrameHeader,
-+			   ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
++	ZSTDds_decodeBlockHeader,
++	ZSTDds_decompressBlock,
++	ZSTDds_decompressLastBlock,
++	ZSTDds_checkChecksum,
++	ZSTDds_decodeSkippableHeader,
++	ZSTDds_skipFrame
++} ZSTD_dStage;
 +
 +typedef struct {
 +	FSE_DTable LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
@@ -4985,8 +5136,7 @@ index 0000000..bd76a75
 +	U32 rep[ZSTD_REP_NUM];
 +} ZSTD_entropyTables_t;
 +
-+struct ZSTD_DCtx_s
++struct ZSTD_DCtx_s {
-+{
 +	const FSE_DTable *LLTptr;
 +	const FSE_DTable *MLTptr;
 +	const FSE_DTable *OFTptr;
@@ -5013,10 +5163,7 @@ index 0000000..bd76a75
 +	BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
 +}; /* typedef'd to ZSTD_DCtx within "zstd.h" */
 +
-+size_t ZSTD_DCtxWorkspaceBound(void)
++size_t ZSTD_DCtxWorkspaceBound(void) { return ZSTD_ALIGN(sizeof(ZSTD_stack)) + ZSTD_ALIGN(sizeof(ZSTD_DCtx)); }
-+{
-+	return ZSTD_ALIGN(sizeof(ZSTD_stack)) + ZSTD_ALIGN(sizeof(ZSTD_DCtx));
-+}
 +
 +size_t ZSTD_decompressBegin(ZSTD_DCtx *dctx)
 +{
@@ -5029,7 +5176,7 @@ index 0000000..bd76a75
 +	dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
 +	dctx->litEntropy = dctx->fseEntropy = 0;
 +	dctx->dictID = 0;
-+	MEM_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
++	ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
 +	memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */
 +	dctx->LLTptr = dctx->entropy.LLTable;
 +	dctx->MLTptr = dctx->entropy.MLTable;
@@ -5042,10 +5189,12 @@ index 0000000..bd76a75
 +{
 +	ZSTD_DCtx *dctx;
 +
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +
 +	dctx = (ZSTD_DCtx *)ZSTD_malloc(sizeof(ZSTD_DCtx), customMem);
-+	if (!dctx) return NULL;
++	if (!dctx)
++		return NULL;
 +	memcpy(&dctx->customMem, &customMem, sizeof(customMem));
 +	ZSTD_decompressBegin(dctx);
 +	return dctx;
@@ -5059,7 +5208,8 @@ index 0000000..bd76a75
 +
 +size_t ZSTD_freeDCtx(ZSTD_DCtx *dctx)
 +{
-+	if (dctx==NULL) return 0;   /* support free on NULL */
++	if (dctx == NULL)
++		return 0; /* support free on NULL */
 +	ZSTD_free(dctx, dctx->customMem);
 +	return 0; /* reserved as a potential error code in the future */
 +}
@@ -5072,7 +5222,6 @@ index 0000000..bd76a75
 +
 +static void ZSTD_refDDict(ZSTD_DCtx *dstDCtx, const ZSTD_DDict *ddict);
 +
-+
 +/*-*************************************************************
 +*   Decompression section
 +***************************************************************/
@@ -5084,31 +5233,34 @@ index 0000000..bd76a75
 + *  Note 3 : Skippable Frame Identifiers are considered valid. */
 +unsigned ZSTD_isFrame(const void *buffer, size_t size)
 +{
-+	if (size < 4) return 0;
++	if (size < 4)
-+	{	U32 const magic = MEM_readLE32(buffer);
++		return 0;
-+		if (magic == ZSTD_MAGICNUMBER) return 1;
++	{
-+		if ((magic & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
++		U32 const magic = ZSTD_readLE32(buffer);
++		if (magic == ZSTD_MAGICNUMBER)
++			return 1;
++		if ((magic & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START)
++			return 1;
 +	}
 +	return 0;
 +}
 +
-+
 +/** ZSTD_frameHeaderSize() :
 +*   srcSize must be >= ZSTD_frameHeaderSize_prefix.
 +*   @return : size of the Frame Header */
 +static size_t ZSTD_frameHeaderSize(const void *src, size_t srcSize)
 +{
-+	if (srcSize < ZSTD_frameHeaderSize_prefix) return ERROR(srcSize_wrong);
++	if (srcSize < ZSTD_frameHeaderSize_prefix)
-+	{	BYTE const fhd = ((const BYTE*)src)[4];
++		return ERROR(srcSize_wrong);
++	{
++		BYTE const fhd = ((const BYTE *)src)[4];
 +		U32 const dictID = fhd & 3;
 +		U32 const singleSegment = (fhd >> 5) & 1;
 +		U32 const fcsId = fhd >> 6;
-+		return ZSTD_frameHeaderSize_prefix + !singleSegment + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
++		return ZSTD_frameHeaderSize_prefix + !singleSegment + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId] + (singleSegment && !fcsId);
-+				+ (singleSegment && !fcsId);
 +	}
 +}
 +
-+
 +/** ZSTD_getFrameParams() :
 +*   decode Frame Header, or require larger `srcSize`.
 +*   @return : 0, `fparamsPtr` is correctly filled,
@@ -5118,12 +5270,14 @@ index 0000000..bd76a75
 +{
 +	const BYTE *ip = (const BYTE *)src;
 +
-+	if (srcSize < ZSTD_frameHeaderSize_prefix) return ZSTD_frameHeaderSize_prefix;
++	if (srcSize < ZSTD_frameHeaderSize_prefix)
-+	if (MEM_readLE32(src) != ZSTD_MAGICNUMBER) {
++		return ZSTD_frameHeaderSize_prefix;
-+		if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
++	if (ZSTD_readLE32(src) != ZSTD_MAGICNUMBER) {
-+			if (srcSize < ZSTD_skippableHeaderSize) return ZSTD_skippableHeaderSize; /* magic number + skippable frame length */
++		if ((ZSTD_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
++			if (srcSize < ZSTD_skippableHeaderSize)
++				return ZSTD_skippableHeaderSize; /* magic number + skippable frame length */
 +			memset(fparamsPtr, 0, sizeof(*fparamsPtr));
-+			fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4);
++			fparamsPtr->frameContentSize = ZSTD_readLE32((const char *)src + 4);
 +			fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */
 +			return 0;
 +		}
@@ -5131,10 +5285,14 @@ index 0000000..bd76a75
 +	}
 +
 +	/* ensure there is enough `srcSize` to fully read/decode frame header */
-+	{ size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize);
++	{
-+	  if (srcSize < fhsize) return fhsize; }
++		size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize);
++		if (srcSize < fhsize)
++			return fhsize;
++	}
 +
-+	{	BYTE const fhdByte = ip[4];
++	{
++		BYTE const fhdByte = ip[4];
 +		size_t pos = 5;
 +		U32 const dictIDSizeCode = fhdByte & 3;
 +		U32 const checksumFlag = (fhdByte >> 2) & 1;
@@ -5144,33 +5302,47 @@ index 0000000..bd76a75
 +		U32 windowSize = 0;
 +		U32 dictID = 0;
 +		U64 frameContentSize = 0;
-+		if ((fhdByte & 0x08) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits, which must be zero */
++		if ((fhdByte & 0x08) != 0)
++			return ERROR(frameParameter_unsupported); /* reserved bits, which must be zero */
 +		if (!singleSegment) {
 +			BYTE const wlByte = ip[pos++];
 +			U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
-+			if (windowLog > ZSTD_WINDOWLOG_MAX) return ERROR(frameParameter_windowTooLarge);  /* avoids issue with 1 << windowLog */
++			if (windowLog > ZSTD_WINDOWLOG_MAX)
++				return ERROR(frameParameter_windowTooLarge); /* avoids issue with 1 << windowLog */
 +			windowSize = (1U << windowLog);
 +			windowSize += (windowSize >> 3) * (wlByte & 7);
 +		}
 +
-+		switch(dictIDSizeCode)
++		switch (dictIDSizeCode) {
-+		{
 +		default: /* impossible */
 +		case 0: break;
-+			case 1 : dictID = ip[pos]; pos++; break;
++		case 1:
-+			case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
++			dictID = ip[pos];
-+			case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
++			pos++;
++			break;
++		case 2:
++			dictID = ZSTD_readLE16(ip + pos);
++			pos += 2;
++			break;
++		case 3:
++			dictID = ZSTD_readLE32(ip + pos);
++			pos += 4;
++			break;
 +		}
-+		switch(fcsID)
++		switch (fcsID) {
-+		{
 +		default: /* impossible */
-+			case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
++		case 0:
-+			case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
++			if (singleSegment)
-+			case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
++				frameContentSize = ip[pos];
-+			case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
++			break;
++		case 1: frameContentSize = ZSTD_readLE16(ip + pos) + 256; break;
++		case 2: frameContentSize = ZSTD_readLE32(ip + pos); break;
++		case 3: frameContentSize = ZSTD_readLE64(ip + pos); break;
 +		}
-+		if (!windowSize) windowSize = (U32)frameContentSize;
++		if (!windowSize)
-+		if (windowSize > windowSizeMax) return ERROR(frameParameter_windowTooLarge);
++			windowSize = (U32)frameContentSize;
++		if (windowSize > windowSizeMax)
++			return ERROR(frameParameter_windowTooLarge);
 +		fparamsPtr->frameContentSize = frameContentSize;
 +		fparamsPtr->windowSize = windowSize;
 +		fparamsPtr->dictID = dictID;
@@ -5188,7 +5360,8 @@ index 0000000..bd76a75
 +{
 +	{
 +		ZSTD_frameParams fParams;
-+		if (ZSTD_getFrameParams(&fParams, src, srcSize) != 0) return ZSTD_CONTENTSIZE_ERROR;
++		if (ZSTD_getFrameParams(&fParams, src, srcSize) != 0)
++			return ZSTD_CONTENTSIZE_ERROR;
 +		if (fParams.windowSize == 0) {
 +			/* Either skippable or empty frame, size == 0 either way */
 +			return 0;
@@ -5210,14 +5383,13 @@ index 0000000..bd76a75
 +	{
 +		unsigned long long totalDstSize = 0;
 +		while (srcSize >= ZSTD_frameHeaderSize_prefix) {
-+			const U32 magicNumber = MEM_readLE32(src);
++			const U32 magicNumber = ZSTD_readLE32(src);
 +
 +			if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
 +				size_t skippableSize;
 +				if (srcSize < ZSTD_skippableHeaderSize)
 +					return ERROR(srcSize_wrong);
-+				skippableSize = MEM_readLE32((const BYTE *)src + 4) +
++				skippableSize = ZSTD_readLE32((const BYTE *)src + 4) + ZSTD_skippableHeaderSize;
-+								ZSTD_skippableHeaderSize;
 +				if (srcSize < skippableSize) {
 +					return ZSTD_CONTENTSIZE_ERROR;
 +				}
@@ -5229,10 +5401,12 @@ index 0000000..bd76a75
 +
 +			{
 +				unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
-+				if (ret >= ZSTD_CONTENTSIZE_ERROR) return ret;
++				if (ret >= ZSTD_CONTENTSIZE_ERROR)
++					return ret;
 +
 +				/* check for overflow */
-+				if (totalDstSize + ret < totalDstSize) return ZSTD_CONTENTSIZE_ERROR;
++				if (totalDstSize + ret < totalDstSize)
++					return ZSTD_CONTENTSIZE_ERROR;
 +				totalDstSize += ret;
 +			}
 +			{
@@ -5260,16 +5434,18 @@ index 0000000..bd76a75
 +static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx *dctx, const void *src, size_t headerSize)
 +{
 +	size_t const result = ZSTD_getFrameParams(&(dctx->fParams), src, headerSize);
-+	if (ZSTD_isError(result)) return result;  /* invalid header */
++	if (ZSTD_isError(result))
-+	if (result>0) return ERROR(srcSize_wrong);   /* headerSize too small */
++		return result; /* invalid header */
-+	if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);
++	if (result > 0)
-+	if (dctx->fParams.checksumFlag) xxh64_reset(&dctx->xxhState, 0);
++		return ERROR(srcSize_wrong); /* headerSize too small */
++	if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID))
++		return ERROR(dictionary_wrong);
++	if (dctx->fParams.checksumFlag)
++		xxh64_reset(&dctx->xxhState, 0);
 +	return 0;
 +}
 +
-+
++typedef struct {
-+typedef struct
-+{
 +	blockType_e blockType;
 +	U32 lastBlock;
 +	U32 origSize;
@@ -5279,59 +5455,68 @@ index 0000000..bd76a75
 +*   Provides the size of compressed block from block header `src` */
 +size_t ZSTD_getcBlockSize(const void *src, size_t srcSize, blockProperties_t *bpPtr)
 +{
-+	if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
++	if (srcSize < ZSTD_blockHeaderSize)
-+	{	U32 const cBlockHeader = MEM_readLE24(src);
++		return ERROR(srcSize_wrong);
++	{
++		U32 const cBlockHeader = ZSTD_readLE24(src);
 +		U32 const cSize = cBlockHeader >> 3;
 +		bpPtr->lastBlock = cBlockHeader & 1;
 +		bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
 +		bpPtr->origSize = cSize; /* only useful for RLE */
-+		if (bpPtr->blockType == bt_rle) return 1;
++		if (bpPtr->blockType == bt_rle)
-+		if (bpPtr->blockType == bt_reserved) return ERROR(corruption_detected);
++			return 1;
++		if (bpPtr->blockType == bt_reserved)
++			return ERROR(corruption_detected);
 +		return cSize;
 +	}
 +}
 +
-+
 +static size_t ZSTD_copyRawBlock(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
-+	if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
++	if (srcSize > dstCapacity)
++		return ERROR(dstSize_tooSmall);
 +	memcpy(dst, src, srcSize);
 +	return srcSize;
 +}
 +
-+
 +static size_t ZSTD_setRleBlock(void *dst, size_t dstCapacity, const void *src, size_t srcSize, size_t regenSize)
 +{
-+	if (srcSize != 1) return ERROR(srcSize_wrong);
++	if (srcSize != 1)
-+	if (regenSize > dstCapacity) return ERROR(dstSize_tooSmall);
++		return ERROR(srcSize_wrong);
++	if (regenSize > dstCapacity)
++		return ERROR(dstSize_tooSmall);
 +	memset(dst, *(const BYTE *)src, regenSize);
 +	return regenSize;
 +}
 +
 +/*! ZSTD_decodeLiteralsBlock() :
 +	@return : nb of bytes read from src (< srcSize ) */
-+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
++size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx *dctx, const void *src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
-+						  const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
 +{
-+	if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
++	if (srcSize < MIN_CBLOCK_SIZE)
++		return ERROR(corruption_detected);
 +
-+	{	const BYTE* const istart = (const BYTE*) src;
++	{
++		const BYTE *const istart = (const BYTE *)src;
 +		symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
 +
-+		switch(litEncType)
++		switch (litEncType) {
-+		{
 +		case set_repeat:
-+			if (dctx->litEntropy==0) return ERROR(dictionary_corrupted);
++			if (dctx->litEntropy == 0)
++				return ERROR(dictionary_corrupted);
 +		/* fall-through */
 +		case set_compressed:
-+			if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */
++			if (srcSize < 5)
-+			{	size_t lhSize, litSize, litCSize;
++				return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */
++			{
++				size_t lhSize, litSize, litCSize;
 +				U32 singleStream = 0;
 +				U32 const lhlCode = (istart[0] >> 2) & 3;
-+				U32 const lhc = MEM_readLE32(istart);
++				U32 const lhc = ZSTD_readLE32(istart);
-+				switch(lhlCode)
++				switch (lhlCode) {
-+				{
++				case 0:
-+				case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */
++				case 1:
++				default: /* note : default is impossible, since lhlCode into [0..3] */
 +					/* 2 - 2 - 10 - 10 */
 +					singleStream = !lhlCode;
 +					lhSize = 3;
@@ -5351,47 +5536,52 @@ index 0000000..bd76a75
 +					litCSize = (lhc >> 22) + (istart[4] << 10);
 +					break;
 +				}
-+				if (litSize > ZSTD_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
++				if (litSize > ZSTD_BLOCKSIZE_ABSOLUTEMAX)
-+				if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
++					return ERROR(corruption_detected);
++				if (litCSize + lhSize > srcSize)
++					return ERROR(corruption_detected);
 +
-+				if (HUF_isError((litEncType==set_repeat) ?
++				if (HUF_isError(
-+									( singleStream ?
++					(litEncType == set_repeat)
-+										HUF_decompress1X_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr) :
++					    ? (singleStream ? HUF_decompress1X_usingDTable(dctx->litBuffer, litSize, istart + lhSize, litCSize, dctx->HUFptr)
-+										HUF_decompress4X_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr) ) :
++							    : HUF_decompress4X_usingDTable(dctx->litBuffer, litSize, istart + lhSize, litCSize, dctx->HUFptr))
-+									( singleStream ?
++					    : (singleStream
-+										HUF_decompress1X2_DCtx(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) :
++						   ? HUF_decompress1X2_DCtx(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart + lhSize, litCSize)
-+										HUF_decompress4X_hufOnly (dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize)) ))
++						   : HUF_decompress4X_hufOnly(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart + lhSize, litCSize))))
 +					return ERROR(corruption_detected);
 +
 +				dctx->litPtr = dctx->litBuffer;
 +				dctx->litSize = litSize;
 +				dctx->litEntropy = 1;
-+				if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
++				if (litEncType == set_compressed)
++					dctx->HUFptr = dctx->entropy.hufTable;
 +				memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
 +				return litCSize + lhSize;
 +			}
 +
-+		case set_basic:
++		case set_basic: {
-+			{	size_t litSize, lhSize;
++			size_t litSize, lhSize;
 +			U32 const lhlCode = ((istart[0]) >> 2) & 3;
-+				switch(lhlCode)
++			switch (lhlCode) {
-+				{
++			case 0:
-+				case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
++			case 2:
++			default: /* note : default is impossible, since lhlCode into [0..3] */
 +				lhSize = 1;
 +				litSize = istart[0] >> 3;
 +				break;
 +			case 1:
 +				lhSize = 2;
-+					litSize = MEM_readLE16(istart) >> 4;
++				litSize = ZSTD_readLE16(istart) >> 4;
 +				break;
 +			case 3:
 +				lhSize = 3;
-+					litSize = MEM_readLE24(istart) >> 4;
++				litSize = ZSTD_readLE24(istart) >> 4;
 +				break;
 +			}
 +
 +			if (lhSize + litSize + WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
-+					if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
++				if (litSize + lhSize > srcSize)
++					return ERROR(corruption_detected);
 +				memcpy(dctx->litBuffer, istart + lhSize, litSize);
 +				dctx->litPtr = dctx->litBuffer;
 +				dctx->litSize = litSize;
@@ -5404,26 +5594,29 @@ index 0000000..bd76a75
 +			return lhSize + litSize;
 +		}
 +
-+		case set_rle:
++		case set_rle: {
-+			{	U32 const lhlCode = ((istart[0]) >> 2) & 3;
++			U32 const lhlCode = ((istart[0]) >> 2) & 3;
 +			size_t litSize, lhSize;
-+				switch(lhlCode)
++			switch (lhlCode) {
-+				{
++			case 0:
-+				case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
++			case 2:
++			default: /* note : default is impossible, since lhlCode into [0..3] */
 +				lhSize = 1;
 +				litSize = istart[0] >> 3;
 +				break;
 +			case 1:
 +				lhSize = 2;
-+					litSize = MEM_readLE16(istart) >> 4;
++				litSize = ZSTD_readLE16(istart) >> 4;
 +				break;
 +			case 3:
 +				lhSize = 3;
-+					litSize = MEM_readLE24(istart) >> 4;
++				litSize = ZSTD_readLE24(istart) >> 4;
-+					if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
++				if (srcSize < 4)
++					return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
 +				break;
 +			}
-+				if (litSize > ZSTD_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
++			if (litSize > ZSTD_BLOCKSIZE_ABSOLUTEMAX)
++				return ERROR(corruption_detected);
 +			memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
 +			dctx->litPtr = dctx->litBuffer;
 +			dctx->litSize = litSize;
@@ -5435,7 +5628,6 @@ index 0000000..bd76a75
 +	}
 +}
 +
-+
 +typedef union {
 +	FSE_decode_t realData;
 +	U32 alignedBy4;
@@ -5617,58 +5809,65 @@ index 0000000..bd76a75
 +	@return : nb bytes read from src,
 +			  or an error code if it fails, testable with ZSTD_isError()
 +*/
-+static size_t ZSTD_buildSeqTable(FSE_DTable* DTableSpace, const FSE_DTable** DTablePtr,
++static size_t ZSTD_buildSeqTable(FSE_DTable *DTableSpace, const FSE_DTable **DTablePtr, symbolEncodingType_e type, U32 max, U32 maxLog, const void *src,
-+								 symbolEncodingType_e type, U32 max, U32 maxLog,
++				 size_t srcSize, const FSE_decode_t4 *defaultTable, U32 flagRepeatTable)
-+								 const void* src, size_t srcSize,
-+								 const FSE_decode_t4* defaultTable, U32 flagRepeatTable)
 +{
 +	const void *const tmpPtr = defaultTable; /* bypass strict aliasing */
-+	switch(type)
++	switch (type) {
-+	{
 +	case set_rle:
-+		if (!srcSize) return ERROR(srcSize_wrong);
++		if (!srcSize)
-+		if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
++			return ERROR(srcSize_wrong);
++		if ((*(const BYTE *)src) > max)
++			return ERROR(corruption_detected);
 +		FSE_buildDTable_rle(DTableSpace, *(const BYTE *)src);
 +		*DTablePtr = DTableSpace;
 +		return 1;
-+	case set_basic :
++	case set_basic: *DTablePtr = (const FSE_DTable *)tmpPtr; return 0;
-+		*DTablePtr = (const FSE_DTable*)tmpPtr;
-+		return 0;
 +	case set_repeat:
-+		if (!flagRepeatTable) return ERROR(corruption_detected);
++		if (!flagRepeatTable)
++			return ERROR(corruption_detected);
 +		return 0;
 +	default: /* impossible */
-+	case set_compressed :
++	case set_compressed: {
-+		{	U32 tableLog;
++		U32 tableLog;
 +		S16 norm[MaxSeq + 1];
 +		size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
-+			if (FSE_isError(headerSize)) return ERROR(corruption_detected);
++		if (FSE_isError(headerSize))
-+			if (tableLog > maxLog) return ERROR(corruption_detected);
++			return ERROR(corruption_detected);
++		if (tableLog > maxLog)
++			return ERROR(corruption_detected);
 +		FSE_buildDTable(DTableSpace, norm, max, tableLog);
 +		*DTablePtr = DTableSpace;
 +		return headerSize;
-+	}   }
++	}
++	}
 +}
 +
-+size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
++size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx *dctx, int *nbSeqPtr, const void *src, size_t srcSize)
-+							 const void* src, size_t srcSize)
 +{
 +	const BYTE *const istart = (const BYTE *const)src;
 +	const BYTE *const iend = istart + srcSize;
 +	const BYTE *ip = istart;
 +
 +	/* check */
-+	if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
++	if (srcSize < MIN_SEQUENCES_SIZE)
++		return ERROR(srcSize_wrong);
 +
 +	/* SeqHead */
-+	{	int nbSeq = *ip++;
++	{
-+		if (!nbSeq) { *nbSeqPtr=0; return 1; }
++		int nbSeq = *ip++;
++		if (!nbSeq) {
++			*nbSeqPtr = 0;
++			return 1;
++		}
 +		if (nbSeq > 0x7F) {
 +			if (nbSeq == 0xFF) {
-+				if (ip+2 > iend) return ERROR(srcSize_wrong);
++				if (ip + 2 > iend)
-+				nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
++					return ERROR(srcSize_wrong);
++				nbSeq = ZSTD_readLE16(ip) + LONGNBSEQ, ip += 2;
 +			} else {
-+				if (ip >= iend) return ERROR(srcSize_wrong);
++				if (ip >= iend)
++					return ERROR(srcSize_wrong);
 +				nbSeq = ((nbSeq - 0x80) << 8) + *ip++;
 +			}
 +		}
@@ -5676,29 +5875,34 @@ index 0000000..bd76a75
 +	}
 +
 +	/* FSE table descriptors */
-+	if (ip+4 > iend) return ERROR(srcSize_wrong); /* minimum possible size */
++	if (ip + 4 > iend)
-+	{	symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
++		return ERROR(srcSize_wrong); /* minimum possible size */
++	{
++		symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
 +		symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
 +		symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
 +		ip++;
 +
 +		/* Build DTables */
-+		{	size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
++		{
-+													  LLtype, MaxLL, LLFSELog,
++			size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, LLtype, MaxLL, LLFSELog, ip, iend - ip,
-+													  ip, iend-ip, LL_defaultDTable, dctx->fseEntropy);
++								  LL_defaultDTable, dctx->fseEntropy);
-+			if (ZSTD_isError(llhSize)) return ERROR(corruption_detected);
++			if (ZSTD_isError(llhSize))
++				return ERROR(corruption_detected);
 +			ip += llhSize;
 +		}
-+		{	size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
++		{
-+													  OFtype, MaxOff, OffFSELog,
++			size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, OFtype, MaxOff, OffFSELog, ip, iend - ip,
-+													  ip, iend-ip, OF_defaultDTable, dctx->fseEntropy);
++								  OF_defaultDTable, dctx->fseEntropy);
-+			if (ZSTD_isError(ofhSize)) return ERROR(corruption_detected);
++			if (ZSTD_isError(ofhSize))
++				return ERROR(corruption_detected);
 +			ip += ofhSize;
 +		}
-+		{	size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
++		{
-+													  MLtype, MaxML, MLFSELog,
++			size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, MLtype, MaxML, MLFSELog, ip, iend - ip,
-+													  ip, iend-ip, ML_defaultDTable, dctx->fseEntropy);
++								  ML_defaultDTable, dctx->fseEntropy);
-+			if (ZSTD_isError(mlhSize)) return ERROR(corruption_detected);
++			if (ZSTD_isError(mlhSize))
++				return ERROR(corruption_detected);
 +			ip += mlhSize;
 +		}
 +	}
@@ -5706,7 +5910,6 @@ index 0000000..bd76a75
 +	return ip - istart;
 +}
 +
-+
 +typedef struct {
 +	size_t litLength;
 +	size_t matchLength;
@@ -5725,12 +5928,9 @@ index 0000000..bd76a75
 +	uPtrDiff gotoDict;
 +} seqState_t;
 +
-+
 +FORCE_NOINLINE
-+size_t ZSTD_execSequenceLast7(BYTE* op,
++size_t ZSTD_execSequenceLast7(BYTE *op, BYTE *const oend, seq_t sequence, const BYTE **litPtr, const BYTE *const litLimit, const BYTE *const base,
-+							  BYTE* const oend, seq_t sequence,
++			      const BYTE *const vBase, const BYTE *const dictEnd)
-+							  const BYTE** litPtr, const BYTE* const litLimit,
-+							  const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
 +{
 +	BYTE *const oLitEnd = op + sequence.litLength;
 +	size_t const sequenceLength = sequence.litLength + sequence.matchLength;
@@ -5740,9 +5940,12 @@ index 0000000..bd76a75
 +	const BYTE *match = oLitEnd - sequence.offset;
 +
 +	/* check */
-+	if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
++	if (oMatchEnd > oend)
-+	if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
++		return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
-+	if (oLitEnd <= oend_w) return ERROR(GENERIC);   /* Precondition */
++	if (iLitEnd > litLimit)
++		return ERROR(corruption_detected); /* over-read beyond lit buffer */
++	if (oLitEnd <= oend_w)
++		return ERROR(GENERIC); /* Precondition */
 +
 +	/* copy literals */
 +	if (op < oend_w) {
@@ -5750,31 +5953,33 @@ index 0000000..bd76a75
 +		*litPtr += oend_w - op;
 +		op = oend_w;
 +	}
-+	while (op < oLitEnd) *op++ = *(*litPtr)++;
++	while (op < oLitEnd)
++		*op++ = *(*litPtr)++;
 +
 +	/* copy Match */
 +	if (sequence.offset > (size_t)(oLitEnd - base)) {
 +		/* offset beyond prefix */
-+		if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
++		if (sequence.offset > (size_t)(oLitEnd - vBase))
++			return ERROR(corruption_detected);
 +		match = dictEnd - (base - match);
 +		if (match + sequence.matchLength <= dictEnd) {
 +			memmove(oLitEnd, match, sequence.matchLength);
 +			return sequenceLength;
 +		}
 +		/* span extDict & currPrefixSegment */
-+		{	size_t const length1 = dictEnd - match;
++		{
++			size_t const length1 = dictEnd - match;
 +			memmove(oLitEnd, match, length1);
 +			op = oLitEnd + length1;
 +			sequence.matchLength -= length1;
 +			match = base;
-+	}   }
++		}
-+	while (op < oMatchEnd) *op++ = *match++;
++	}
++	while (op < oMatchEnd)
++		*op++ = *match++;
 +	return sequenceLength;
 +}
 +
-+
-+
-+
 +static seq_t ZSTD_decodeSequence(seqState_t *seqState)
 +{
 +	seq_t seq;
@@ -5788,30 +5993,26 @@ index 0000000..bd76a75
 +	U32 const ofBits = ofCode;
 +	U32 const totalBits = llBits + mlBits + ofBits;
 +
-+	static const U32 LL_base[MaxLL+1] = {
++	static const U32 LL_base[MaxLL + 1] = {0,  1,  2,  3,  4,  5,  6,  7,  8,    9,     10,    11,    12,    13,     14,     15,     16,     18,
-+							 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15,
++					       20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000};
-+							16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
-+							0x2000, 0x4000, 0x8000, 0x10000 };
 +
-+	static const U32 ML_base[MaxML+1] = {
++	static const U32 ML_base[MaxML + 1] = {3,  4,  5,  6,  7,  8,  9,  10,   11,    12,    13,    14,    15,     16,     17,     18,     19,     20,
-+							 3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,   14,    15,    16,    17,    18,
++					       21, 22, 23, 24, 25, 26, 27, 28,   29,    30,    31,    32,    33,     34,     35,     37,     39,     41,
-+							19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,   30,    31,    32,    33,    34,
++					       43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 0x1003, 0x2003, 0x4003, 0x8003, 0x10003};
-+							35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
-+							0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
 +
-+	static const U32 OF_base[MaxOff+1] = {
++	static const U32 OF_base[MaxOff + 1] = {0,       1,	1,	5,	0xD,      0x1D,      0x3D,      0x7D,      0xFD,     0x1FD,
-+							 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
++						0x3FD,   0x7FD,    0xFFD,    0x1FFD,   0x3FFD,   0x7FFD,    0xFFFD,    0x1FFFD,   0x3FFFD,  0x7FFFD,
-+							 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
++						0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD};
-+							 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
-+							 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD };
 +
 +	/* sequence */
-+	{	size_t offset;
++	{
++		size_t offset;
 +		if (!ofCode)
 +			offset = 0;
 +		else {
 +			offset = OF_base[ofCode] + BIT_readBitsFast(&seqState->DStream, ofBits); /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
-+			if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
++			if (ZSTD_32bits())
++				BIT_reloadDStream(&seqState->DStream);
 +		}
 +
 +		if (ofCode <= 1) {
@@ -5819,7 +6020,8 @@ index 0000000..bd76a75
 +			if (offset) {
 +				size_t temp = (offset == 3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
 +				temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
-+				if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
++				if (offset != 1)
++					seqState->prevOffset[2] = seqState->prevOffset[1];
 +				seqState->prevOffset[1] = seqState->prevOffset[0];
 +				seqState->prevOffset[0] = offset = temp;
 +			} else {
@@ -5834,27 +6036,26 @@ index 0000000..bd76a75
 +	}
 +
 +	seq.matchLength = ML_base[mlCode] + ((mlCode > 31) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0); /* <=  16 bits */
-+	if (MEM_32bits() && (mlBits+llBits>24)) BIT_reloadDStream(&seqState->DStream);
++	if (ZSTD_32bits() && (mlBits + llBits > 24))
++		BIT_reloadDStream(&seqState->DStream);
 +
 +	seq.litLength = LL_base[llCode] + ((llCode > 15) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0); /* <=  16 bits */
-+	if (MEM_32bits() ||
++	if (ZSTD_32bits() || (totalBits > 64 - 7 - (LLFSELog + MLFSELog + OffFSELog)))
-+	   (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BIT_reloadDStream(&seqState->DStream);
++		BIT_reloadDStream(&seqState->DStream);
 +
 +	/* ANS state update */
 +	FSE_updateState(&seqState->stateLL, &seqState->DStream); /* <=  9 bits */
 +	FSE_updateState(&seqState->stateML, &seqState->DStream); /* <=  9 bits */
-+	if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
++	if (ZSTD_32bits())
++		BIT_reloadDStream(&seqState->DStream);		   /* <= 18 bits */
 +	FSE_updateState(&seqState->stateOffb, &seqState->DStream); /* <=  8 bits */
 +
 +	return seq;
 +}
 +
-+
 +FORCE_INLINE
-+size_t ZSTD_execSequence(BYTE* op,
++size_t ZSTD_execSequence(BYTE *op, BYTE *const oend, seq_t sequence, const BYTE **litPtr, const BYTE *const litLimit, const BYTE *const base,
-+						 BYTE* const oend, seq_t sequence,
++			 const BYTE *const vBase, const BYTE *const dictEnd)
-+						 const BYTE** litPtr, const BYTE* const litLimit,
-+						 const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
 +{
 +	BYTE *const oLitEnd = op + sequence.litLength;
 +	size_t const sequenceLength = sequence.litLength + sequence.matchLength;
@@ -5864,38 +6065,46 @@ index 0000000..bd76a75
 +	const BYTE *match = oLitEnd - sequence.offset;
 +
 +	/* check */
-+	if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
++	if (oMatchEnd > oend)
-+	if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
++		return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
-+	if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd);
++	if (iLitEnd > litLimit)
++		return ERROR(corruption_detected); /* over-read beyond lit buffer */
++	if (oLitEnd > oend_w)
++		return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd);
 +
 +	/* copy Literals */
 +	ZSTD_copy8(op, *litPtr);
 +	if (sequence.litLength > 8)
-+		ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
++		ZSTD_wildcopy(op + 8, (*litPtr) + 8,
++			      sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
 +	op = oLitEnd;
 +	*litPtr = iLitEnd; /* update for next sequence */
 +
 +	/* copy Match */
 +	if (sequence.offset > (size_t)(oLitEnd - base)) {
 +		/* offset beyond prefix */
-+		if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
++		if (sequence.offset > (size_t)(oLitEnd - vBase))
++			return ERROR(corruption_detected);
 +		match = dictEnd + (match - base);
 +		if (match + sequence.matchLength <= dictEnd) {
 +			memmove(oLitEnd, match, sequence.matchLength);
 +			return sequenceLength;
 +		}
 +		/* span extDict & currPrefixSegment */
-+		{	size_t const length1 = dictEnd - match;
++		{
++			size_t const length1 = dictEnd - match;
 +			memmove(oLitEnd, match, length1);
 +			op = oLitEnd + length1;
 +			sequence.matchLength -= length1;
 +			match = base;
 +			if (op > oend_w || sequence.matchLength < MINMATCH) {
 +				U32 i;
-+			  for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
++				for (i = 0; i < sequence.matchLength; ++i)
++					op[i] = match[i];
 +				return sequenceLength;
 +			}
-+	}   }
++		}
++	}
 +	/* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */
 +
 +	/* match within prefix */
@@ -5914,7 +6123,8 @@ index 0000000..bd76a75
 +	} else {
 +		ZSTD_copy8(op, match);
 +	}
-+	op += 8; match += 8;
++	op += 8;
++	match += 8;
 +
 +	if (oMatchEnd > oend - (16 - MINMATCH)) {
 +		if (op < oend_w) {
@@ -5922,18 +6132,15 @@ index 0000000..bd76a75
 +			match += oend_w - op;
 +			op = oend_w;
 +		}
-+		while (op < oMatchEnd) *op++ = *match++;
++		while (op < oMatchEnd)
++			*op++ = *match++;
 +	} else {
 +		ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength - 8); /* works even if matchLength < 8 */
 +	}
 +	return sequenceLength;
 +}
 +
-+
++static size_t ZSTD_decompressSequences(ZSTD_DCtx *dctx, void *dst, size_t maxDstSize, const void *seqStart, size_t seqSize)
-+static size_t ZSTD_decompressSequences(
-+							   ZSTD_DCtx* dctx,
-+							   void* dst, size_t maxDstSize,
-+						 const void* seqStart, size_t seqSize)
 +{
 +	const BYTE *ip = (const BYTE *)seqStart;
 +	const BYTE *const iend = ip + seqSize;
@@ -5948,8 +6155,10 @@ index 0000000..bd76a75
 +	int nbSeq;
 +
 +	/* Build Decoding Tables */
-+	{	size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, seqSize);
++	{
-+		if (ZSTD_isError(seqHSize)) return seqHSize;
++		size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, seqSize);
++		if (ZSTD_isError(seqHSize))
++			return seqHSize;
 +		ip += seqHSize;
 +	}
 +
@@ -5957,7 +6166,11 @@ index 0000000..bd76a75
 +	if (nbSeq) {
 +		seqState_t seqState;
 +		dctx->fseEntropy = 1;
-+		{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				seqState.prevOffset[i] = dctx->entropy.rep[i];
++		}
 +		CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend - ip), corruption_detected);
 +		FSE_initDState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
 +		FSE_initDState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
@@ -5965,21 +6178,31 @@ index 0000000..bd76a75
 +
 +		for (; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq;) {
 +			nbSeq--;
-+			{	seq_t const sequence = ZSTD_decodeSequence(&seqState);
++			{
++				seq_t const sequence = ZSTD_decodeSequence(&seqState);
 +				size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
-+				if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
++				if (ZSTD_isError(oneSeqSize))
++					return oneSeqSize;
 +				op += oneSeqSize;
-+		}   }
++			}
++		}
 +
 +		/* check if reached exact end */
-+		if (nbSeq) return ERROR(corruption_detected);
++		if (nbSeq)
++			return ERROR(corruption_detected);
 +		/* save reps for next block */
-+		{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]);
++		}
 +	}
 +
 +	/* last literal segment */
-+	{	size_t const lastLLSize = litEnd - litPtr;
++	{
-+		if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
++		size_t const lastLLSize = litEnd - litPtr;
++		if (lastLLSize > (size_t)(oend - op))
++			return ERROR(dstSize_tooSmall);
 +		memcpy(op, litPtr, lastLLSize);
 +		op += lastLLSize;
 +	}
@@ -5987,7 +6210,6 @@ index 0000000..bd76a75
 +	return op - ostart;
 +}
 +
-+
 +FORCE_INLINE seq_t ZSTD_decodeSequenceLong_generic(seqState_t *seqState, int const longOffsets)
 +{
 +	seq_t seq;
@@ -6001,36 +6223,34 @@ index 0000000..bd76a75
 +	U32 const ofBits = ofCode;
 +	U32 const totalBits = llBits + mlBits + ofBits;
 +
-+	static const U32 LL_base[MaxLL+1] = {
++	static const U32 LL_base[MaxLL + 1] = {0,  1,  2,  3,  4,  5,  6,  7,  8,    9,     10,    11,    12,    13,     14,     15,     16,     18,
-+							 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15,
++					       20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000};
-+							16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
-+							0x2000, 0x4000, 0x8000, 0x10000 };
 +
-+	static const U32 ML_base[MaxML+1] = {
++	static const U32 ML_base[MaxML + 1] = {3,  4,  5,  6,  7,  8,  9,  10,   11,    12,    13,    14,    15,     16,     17,     18,     19,     20,
-+							 3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,   14,    15,    16,    17,    18,
++					       21, 22, 23, 24, 25, 26, 27, 28,   29,    30,    31,    32,    33,     34,     35,     37,     39,     41,
-+							19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,   30,    31,    32,    33,    34,
++					       43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 0x1003, 0x2003, 0x4003, 0x8003, 0x10003};
-+							35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
-+							0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
 +
-+	static const U32 OF_base[MaxOff+1] = {
++	static const U32 OF_base[MaxOff + 1] = {0,       1,	1,	5,	0xD,      0x1D,      0x3D,      0x7D,      0xFD,     0x1FD,
-+							 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
++						0x3FD,   0x7FD,    0xFFD,    0x1FFD,   0x3FFD,   0x7FFD,    0xFFFD,    0x1FFFD,   0x3FFFD,  0x7FFFD,
-+							 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
++						0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD};
-+							 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
-+							 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD };
 +
 +	/* sequence */
-+	{	size_t offset;
++	{
++		size_t offset;
 +		if (!ofCode)
 +			offset = 0;
 +		else {
 +			if (longOffsets) {
 +				int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN);
 +				offset = OF_base[ofCode] + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
-+				if (MEM_32bits() || extraBits) BIT_reloadDStream(&seqState->DStream);
++				if (ZSTD_32bits() || extraBits)
-+				if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
++					BIT_reloadDStream(&seqState->DStream);
++				if (extraBits)
++					offset += BIT_readBitsFast(&seqState->DStream, extraBits);
 +			} else {
 +				offset = OF_base[ofCode] + BIT_readBitsFast(&seqState->DStream, ofBits); /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
-+				if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
++				if (ZSTD_32bits())
++					BIT_reloadDStream(&seqState->DStream);
 +			}
 +		}
 +
@@ -6039,7 +6259,8 @@ index 0000000..bd76a75
 +			if (offset) {
 +				size_t temp = (offset == 3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
 +				temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
-+				if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
++				if (offset != 1)
++					seqState->prevOffset[2] = seqState->prevOffset[1];
 +				seqState->prevOffset[1] = seqState->prevOffset[0];
 +				seqState->prevOffset[0] = offset = temp;
 +			} else {
@@ -6054,28 +6275,33 @@ index 0000000..bd76a75
 +	}
 +
 +	seq.matchLength = ML_base[mlCode] + ((mlCode > 31) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0); /* <=  16 bits */
-+	if (MEM_32bits() && (mlBits+llBits>24)) BIT_reloadDStream(&seqState->DStream);
++	if (ZSTD_32bits() && (mlBits + llBits > 24))
++		BIT_reloadDStream(&seqState->DStream);
 +
 +	seq.litLength = LL_base[llCode] + ((llCode > 15) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0); /* <=  16 bits */
-+	if (MEM_32bits() ||
++	if (ZSTD_32bits() || (totalBits > 64 - 7 - (LLFSELog + MLFSELog + OffFSELog)))
-+	   (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BIT_reloadDStream(&seqState->DStream);
++		BIT_reloadDStream(&seqState->DStream);
 +
-+	{	size_t const pos = seqState->pos + seq.litLength;
++	{
++		size_t const pos = seqState->pos + seq.litLength;
 +		seq.match = seqState->base + pos - seq.offset; /* single memory segment */
-+		if (seq.offset > pos) seq.match += seqState->gotoDict;   /* separate memory segment */
++		if (seq.offset > pos)
++			seq.match += seqState->gotoDict; /* separate memory segment */
 +		seqState->pos = pos + seq.matchLength;
 +	}
 +
 +	/* ANS state update */
 +	FSE_updateState(&seqState->stateLL, &seqState->DStream); /* <=  9 bits */
 +	FSE_updateState(&seqState->stateML, &seqState->DStream); /* <=  9 bits */
-+	if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
++	if (ZSTD_32bits())
++		BIT_reloadDStream(&seqState->DStream);		   /* <= 18 bits */
 +	FSE_updateState(&seqState->stateOffb, &seqState->DStream); /* <=  8 bits */
 +
 +	return seq;
 +}
 +
-+static seq_t ZSTD_decodeSequenceLong(seqState_t* seqState, unsigned const windowSize) {
++static seq_t ZSTD_decodeSequenceLong(seqState_t *seqState, unsigned const windowSize)
++{
 +	if (ZSTD_highbit32(windowSize) > STREAM_ACCUMULATOR_MIN) {
 +		return ZSTD_decodeSequenceLong_generic(seqState, 1);
 +	} else {
@@ -6084,10 +6310,8 @@ index 0000000..bd76a75
 +}
 +
 +FORCE_INLINE
-+size_t ZSTD_execSequenceLong(BYTE* op,
++size_t ZSTD_execSequenceLong(BYTE *op, BYTE *const oend, seq_t sequence, const BYTE **litPtr, const BYTE *const litLimit, const BYTE *const base,
-+								BYTE* const oend, seq_t sequence,
++			     const BYTE *const vBase, const BYTE *const dictEnd)
-+								const BYTE** litPtr, const BYTE* const litLimit,
-+								const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
 +{
 +	BYTE *const oLitEnd = op + sequence.litLength;
 +	size_t const sequenceLength = sequence.litLength + sequence.matchLength;
@@ -6097,37 +6321,45 @@ index 0000000..bd76a75
 +	const BYTE *match = sequence.match;
 +
 +	/* check */
-+	if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
++	if (oMatchEnd > oend)
-+	if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
++		return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
-+	if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd);
++	if (iLitEnd > litLimit)
++		return ERROR(corruption_detected); /* over-read beyond lit buffer */
++	if (oLitEnd > oend_w)
++		return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd);
 +
 +	/* copy Literals */
 +	ZSTD_copy8(op, *litPtr);
 +	if (sequence.litLength > 8)
-+		ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
++		ZSTD_wildcopy(op + 8, (*litPtr) + 8,
++			      sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
 +	op = oLitEnd;
 +	*litPtr = iLitEnd; /* update for next sequence */
 +
 +	/* copy Match */
 +	if (sequence.offset > (size_t)(oLitEnd - base)) {
 +		/* offset beyond prefix */
-+		if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
++		if (sequence.offset > (size_t)(oLitEnd - vBase))
++			return ERROR(corruption_detected);
 +		if (match + sequence.matchLength <= dictEnd) {
 +			memmove(oLitEnd, match, sequence.matchLength);
 +			return sequenceLength;
 +		}
 +		/* span extDict & currPrefixSegment */
-+		{	size_t const length1 = dictEnd - match;
++		{
++			size_t const length1 = dictEnd - match;
 +			memmove(oLitEnd, match, length1);
 +			op = oLitEnd + length1;
 +			sequence.matchLength -= length1;
 +			match = base;
 +			if (op > oend_w || sequence.matchLength < MINMATCH) {
 +				U32 i;
-+			  for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
++				for (i = 0; i < sequence.matchLength; ++i)
++					op[i] = match[i];
 +				return sequenceLength;
 +			}
-+	}   }
++		}
++	}
 +	/* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */
 +
 +	/* match within prefix */
@@ -6146,7 +6378,8 @@ index 0000000..bd76a75
 +	} else {
 +		ZSTD_copy8(op, match);
 +	}
-+	op += 8; match += 8;
++	op += 8;
++	match += 8;
 +
 +	if (oMatchEnd > oend - (16 - MINMATCH)) {
 +		if (op < oend_w) {
@@ -6154,17 +6387,15 @@ index 0000000..bd76a75
 +			match += oend_w - op;
 +			op = oend_w;
 +		}
-+		while (op < oMatchEnd) *op++ = *match++;
++		while (op < oMatchEnd)
++			*op++ = *match++;
 +	} else {
 +		ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength - 8); /* works even if matchLength < 8 */
 +	}
 +	return sequenceLength;
 +}
 +
-+static size_t ZSTD_decompressSequencesLong(
++static size_t ZSTD_decompressSequencesLong(ZSTD_DCtx *dctx, void *dst, size_t maxDstSize, const void *seqStart, size_t seqSize)
-+							   ZSTD_DCtx* dctx,
-+							   void* dst, size_t maxDstSize,
-+						 const void* seqStart, size_t seqSize)
 +{
 +	const BYTE *ip = (const BYTE *)seqStart;
 +	const BYTE *const iend = ip + seqSize;
@@ -6180,8 +6411,10 @@ index 0000000..bd76a75
 +	int nbSeq;
 +
 +	/* Build Decoding Tables */
-+	{	size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, seqSize);
++	{
-+		if (ZSTD_isError(seqHSize)) return seqHSize;
++		size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, seqSize);
++		if (ZSTD_isError(seqHSize))
++			return seqHSize;
 +		ip += seqHSize;
 +	}
 +
@@ -6195,7 +6428,11 @@ index 0000000..bd76a75
 +		seqState_t seqState;
 +		int seqNb;
 +		dctx->fseEntropy = 1;
-+		{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				seqState.prevOffset[i] = dctx->entropy.rep[i];
++		}
 +		seqState.base = base;
 +		seqState.pos = (size_t)(op - base);
 +		seqState.gotoDict = (uPtrDiff)dictEnd - (uPtrDiff)base; /* cast to avoid undefined behaviour */
@@ -6208,34 +6445,45 @@ index 0000000..bd76a75
 +		for (seqNb = 0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && seqNb < seqAdvance; seqNb++) {
 +			sequences[seqNb] = ZSTD_decodeSequenceLong(&seqState, windowSize);
 +		}
-+		if (seqNb<seqAdvance) return ERROR(corruption_detected);
++		if (seqNb < seqAdvance)
++			return ERROR(corruption_detected);
 +
 +		/* decode and decompress */
 +		for (; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && seqNb < nbSeq; seqNb++) {
 +			seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, windowSize);
-+			size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
++			size_t const oneSeqSize =
-+			if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
++			    ZSTD_execSequenceLong(op, oend, sequences[(seqNb - ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
++			if (ZSTD_isError(oneSeqSize))
++				return oneSeqSize;
 +			ZSTD_PREFETCH(sequence.match);
 +			sequences[seqNb & STOSEQ_MASK] = sequence;
 +			op += oneSeqSize;
 +		}
-+		if (seqNb<nbSeq) return ERROR(corruption_detected);
++		if (seqNb < nbSeq)
++			return ERROR(corruption_detected);
 +
 +		/* finish queue */
 +		seqNb -= seqAdvance;
 +		for (; seqNb < nbSeq; seqNb++) {
 +			size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb & STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
-+			if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
++			if (ZSTD_isError(oneSeqSize))
++				return oneSeqSize;
 +			op += oneSeqSize;
 +		}
 +
 +		/* save reps for next block */
-+		{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]);
++		}
 +	}
 +
 +	/* last literal segment */
-+	{	size_t const lastLLSize = litEnd - litPtr;
++	{
-+		if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
++		size_t const lastLLSize = litEnd - litPtr;
++		if (lastLLSize > (size_t)(oend - op))
++			return ERROR(dstSize_tooSmall);
 +		memcpy(op, litPtr, lastLLSize);
 +		op += lastLLSize;
 +	}
@@ -6243,18 +6491,18 @@ index 0000000..bd76a75
 +	return op - ostart;
 +}
 +
-+
++static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
-+static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
-+							void* dst, size_t dstCapacity,
-+					  const void* src, size_t srcSize)
 +{ /* blockType == blockCompressed */
 +	const BYTE *ip = (const BYTE *)src;
 +
-+	if (srcSize >= ZSTD_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong);
++	if (srcSize >= ZSTD_BLOCKSIZE_ABSOLUTEMAX)
++		return ERROR(srcSize_wrong);
 +
 +	/* Decode literals section */
-+	{	size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
++	{
-+		if (ZSTD_isError(litCSize)) return litCSize;
++		size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
++		if (ZSTD_isError(litCSize))
++			return litCSize;
 +		ip += litCSize;
 +		srcSize -= litCSize;
 +	}
@@ -6267,7 +6515,6 @@ index 0000000..bd76a75
 +	return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
 +}
 +
-+
 +static void ZSTD_checkContinuity(ZSTD_DCtx *dctx, const void *dst)
 +{
 +	if (dst != dctx->previousDstEnd) { /* not contiguous */
@@ -6278,9 +6525,7 @@ index 0000000..bd76a75
 +	}
 +}
 +
-+size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
++size_t ZSTD_decompressBlock(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
-+							void* dst, size_t dstCapacity,
-+					  const void* src, size_t srcSize)
 +{
 +	size_t dSize;
 +	ZSTD_checkContinuity(dctx, dst);
@@ -6289,7 +6534,6 @@ index 0000000..bd76a75
 +	return dSize;
 +}
 +
-+
 +/** ZSTD_insertBlock() :
 +	insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
 +size_t ZSTD_insertBlock(ZSTD_DCtx *dctx, const void *blockStart, size_t blockSize)
@@ -6299,10 +6543,10 @@ index 0000000..bd76a75
 +	return blockSize;
 +}
 +
-+
 +size_t ZSTD_generateNxBytes(void *dst, size_t dstCapacity, BYTE byte, size_t length)
 +{
-+	if (length > dstCapacity) return ERROR(dstSize_tooSmall);
++	if (length > dstCapacity)
++		return ERROR(dstSize_tooSmall);
 +	memset(dst, byte, length);
 +	return length;
 +}
@@ -6314,9 +6558,8 @@ index 0000000..bd76a75
 + *  @return : the compressed size of the frame starting at `src` */
 +size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
 +{
-+	if (srcSize >= ZSTD_skippableHeaderSize &&
++	if (srcSize >= ZSTD_skippableHeaderSize && (ZSTD_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
-+			(MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
++		return ZSTD_skippableHeaderSize + ZSTD_readLE32((const BYTE *)src + 4);
-+		return ZSTD_skippableHeaderSize + MEM_readLE32((const BYTE*)src + 4);
 +	} else {
 +		const BYTE *ip = (const BYTE *)src;
 +		const BYTE *const ipstart = ip;
@@ -6324,12 +6567,16 @@ index 0000000..bd76a75
 +		ZSTD_frameParams fParams;
 +
 +		size_t const headerSize = ZSTD_frameHeaderSize(ip, remainingSize);
-+		if (ZSTD_isError(headerSize)) return headerSize;
++		if (ZSTD_isError(headerSize))
++			return headerSize;
 +
 +		/* Frame Header */
-+		{	size_t const ret = ZSTD_getFrameParams(&fParams, ip, remainingSize);
++		{
-+			if (ZSTD_isError(ret)) return ret;
++			size_t const ret = ZSTD_getFrameParams(&fParams, ip, remainingSize);
-+			if (ret > 0) return ERROR(srcSize_wrong);
++			if (ZSTD_isError(ret))
++				return ret;
++			if (ret > 0)
++				return ERROR(srcSize_wrong);
 +		}
 +
 +		ip += headerSize;
@@ -6339,18 +6586,22 @@ index 0000000..bd76a75
 +		while (1) {
 +			blockProperties_t blockProperties;
 +			size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
-+			if (ZSTD_isError(cBlockSize)) return cBlockSize;
++			if (ZSTD_isError(cBlockSize))
++				return cBlockSize;
 +
-+			if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) return ERROR(srcSize_wrong);
++			if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
++				return ERROR(srcSize_wrong);
 +
 +			ip += ZSTD_blockHeaderSize + cBlockSize;
 +			remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
 +
-+			if (blockProperties.lastBlock) break;
++			if (blockProperties.lastBlock)
++				break;
 +		}
 +
 +		if (fParams.checksumFlag) { /* Frame content checksum */
-+			if (remainingSize < 4) return ERROR(srcSize_wrong);
++			if (remainingSize < 4)
++				return ERROR(srcSize_wrong);
 +			ip += 4;
 +			remainingSize -= 4;
 +		}
@@ -6361,9 +6612,7 @@ index 0000000..bd76a75
 +
 +/*! ZSTD_decompressFrame() :
 +*   @dctx must be properly initialized */
-+static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
++static size_t ZSTD_decompressFrame(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void **srcPtr, size_t *srcSizePtr)
-+								 void* dst, size_t dstCapacity,
-+								 const void** srcPtr, size_t *srcSizePtr)
 +{
 +	const BYTE *ip = (const BYTE *)(*srcPtr);
 +	BYTE *const ostart = (BYTE * const)dst;
@@ -6372,14 +6621,19 @@ index 0000000..bd76a75
 +	size_t remainingSize = *srcSizePtr;
 +
 +	/* check */
-+	if (remainingSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
++	if (remainingSize < ZSTD_frameHeaderSize_min + ZSTD_blockHeaderSize)
++		return ERROR(srcSize_wrong);
 +
 +	/* Frame Header */
-+	{	size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_frameHeaderSize_prefix);
++	{
-+		if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
++		size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_frameHeaderSize_prefix);
-+		if (remainingSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
++		if (ZSTD_isError(frameHeaderSize))
++			return frameHeaderSize;
++		if (remainingSize < frameHeaderSize + ZSTD_blockHeaderSize)
++			return ERROR(srcSize_wrong);
 +		CHECK_F(ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize));
-+		ip += frameHeaderSize; remainingSize -= frameHeaderSize;
++		ip += frameHeaderSize;
++		remainingSize -= frameHeaderSize;
 +	}
 +
 +	/* Loop on each block */
@@ -6387,42 +6641,41 @@ index 0000000..bd76a75
 +		size_t decodedSize;
 +		blockProperties_t blockProperties;
 +		size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
-+		if (ZSTD_isError(cBlockSize)) return cBlockSize;
++		if (ZSTD_isError(cBlockSize))
++			return cBlockSize;
 +
 +		ip += ZSTD_blockHeaderSize;
 +		remainingSize -= ZSTD_blockHeaderSize;
-+		if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
++		if (cBlockSize > remainingSize)
++			return ERROR(srcSize_wrong);
 +
-+		switch(blockProperties.blockType)
++		switch (blockProperties.blockType) {
-+		{
++		case bt_compressed: decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend - op, ip, cBlockSize); break;
-+		case bt_compressed:
++		case bt_raw: decodedSize = ZSTD_copyRawBlock(op, oend - op, ip, cBlockSize); break;
-+			decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
++		case bt_rle: decodedSize = ZSTD_generateNxBytes(op, oend - op, *ip, blockProperties.origSize); break;
-+			break;
-+		case bt_raw :
-+			decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
-+			break;
-+		case bt_rle :
-+			decodedSize = ZSTD_generateNxBytes(op, oend-op, *ip, blockProperties.origSize);
-+			break;
 +		case bt_reserved:
-+		default:
++		default: return ERROR(corruption_detected);
-+			return ERROR(corruption_detected);
 +		}
 +
-+		if (ZSTD_isError(decodedSize)) return decodedSize;
++		if (ZSTD_isError(decodedSize))
-+		if (dctx->fParams.checksumFlag) xxh64_update(&dctx->xxhState, op, decodedSize);
++			return decodedSize;
++		if (dctx->fParams.checksumFlag)
++			xxh64_update(&dctx->xxhState, op, decodedSize);
 +		op += decodedSize;
 +		ip += cBlockSize;
 +		remainingSize -= cBlockSize;
-+		if (blockProperties.lastBlock) break;
++		if (blockProperties.lastBlock)
++			break;
 +	}
 +
 +	if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
 +		U32 const checkCalc = (U32)xxh64_digest(&dctx->xxhState);
 +		U32 checkRead;
-+		if (remainingSize<4) return ERROR(checksum_wrong);
++		if (remainingSize < 4)
-+		checkRead = MEM_readLE32(ip);
++			return ERROR(checksum_wrong);
-+		if (checkRead != checkCalc) return ERROR(checksum_wrong);
++		checkRead = ZSTD_readLE32(ip);
++		if (checkRead != checkCalc)
++			return ERROR(checksum_wrong);
 +		ip += 4;
 +		remainingSize -= 4;
 +	}
@@ -6436,10 +6689,7 @@ index 0000000..bd76a75
 +static const void *ZSTD_DDictDictContent(const ZSTD_DDict *ddict);
 +static size_t ZSTD_DDictDictSize(const ZSTD_DDict *ddict);
 +
-+static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
++static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize,
-+										void* dst, size_t dstCapacity,
-+								  const void* src, size_t srcSize,
-+								  const void *dict, size_t dictSize,
 +					const ZSTD_DDict *ddict)
 +{
 +	void *const dststart = dst;
@@ -6457,14 +6707,13 @@ index 0000000..bd76a75
 +	while (srcSize >= ZSTD_frameHeaderSize_prefix) {
 +		U32 magicNumber;
 +
-+		magicNumber = MEM_readLE32(src);
++		magicNumber = ZSTD_readLE32(src);
 +		if (magicNumber != ZSTD_MAGICNUMBER) {
 +			if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
 +				size_t skippableSize;
 +				if (srcSize < ZSTD_skippableHeaderSize)
 +					return ERROR(srcSize_wrong);
-+				skippableSize = MEM_readLE32((const BYTE *)src + 4) +
++				skippableSize = ZSTD_readLE32((const BYTE *)src + 4) + ZSTD_skippableHeaderSize;
-+								ZSTD_skippableHeaderSize;
 +				if (srcSize < skippableSize) {
 +					return ERROR(srcSize_wrong);
 +				}
@@ -6487,9 +6736,10 @@ index 0000000..bd76a75
 +		}
 +		ZSTD_checkContinuity(dctx, dst);
 +
-+		{	const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
++		{
-+													&src, &srcSize);
++			const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity, &src, &srcSize);
-+			if (ZSTD_isError(res)) return res;
++			if (ZSTD_isError(res))
++				return res;
 +			/* don't need to bounds check this, ZSTD_decompressFrame will have
 +			 * already */
 +			dst = (BYTE *)dst + res;
@@ -6497,7 +6747,8 @@ index 0000000..bd76a75
 +		}
 +	}
 +
-+	if (srcSize) return ERROR(srcSize_wrong); /* input not entirely consumed */
++	if (srcSize)
++		return ERROR(srcSize_wrong); /* input not entirely consumed */
 +
 +	return (BYTE *)dst - (BYTE *)dststart;
 +}
@@ -6507,37 +6758,29 @@ index 0000000..bd76a75
 +	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
 +}
 +
-+
 +size_t ZSTD_decompressDCtx(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	return ZSTD_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
 +}
 +
-+
 +/*-**************************************
 +*   Advanced Streaming Decompression API
 +*   Bufferless and synchronous
 +****************************************/
 +size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx *dctx) { return dctx->expected; }
 +
-+ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
++ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx *dctx)
-+	switch(dctx->stage)
 +{
++	switch (dctx->stage) {
 +	default: /* should not happen */
 +	case ZSTDds_getFrameHeaderSize:
-+	case ZSTDds_decodeFrameHeader:
++	case ZSTDds_decodeFrameHeader: return ZSTDnit_frameHeader;
-+		return ZSTDnit_frameHeader;
++	case ZSTDds_decodeBlockHeader: return ZSTDnit_blockHeader;
-+	case ZSTDds_decodeBlockHeader:
++	case ZSTDds_decompressBlock: return ZSTDnit_block;
-+		return ZSTDnit_blockHeader;
++	case ZSTDds_decompressLastBlock: return ZSTDnit_lastBlock;
-+	case ZSTDds_decompressBlock:
++	case ZSTDds_checkChecksum: return ZSTDnit_checksum;
-+		return ZSTDnit_block;
-+	case ZSTDds_decompressLastBlock:
-+		return ZSTDnit_lastBlock;
-+	case ZSTDds_checkChecksum:
-+		return ZSTDnit_checksum;
 +	case ZSTDds_decodeSkippableHeader:
-+	case ZSTDds_skipFrame:
++	case ZSTDds_skipFrame: return ZSTDnit_skippableFrame;
-+		return ZSTDnit_skippableFrame;
 +	}
 +}
 +
@@ -6549,21 +6792,24 @@ index 0000000..bd76a75
 +size_t ZSTD_decompressContinue(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	/* Sanity check */
-+	if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
++	if (srcSize != dctx->expected)
-+	if (dstCapacity) ZSTD_checkContinuity(dctx, dst);
++		return ERROR(srcSize_wrong);
++	if (dstCapacity)
++		ZSTD_checkContinuity(dctx, dst);
 +
-+	switch (dctx->stage)
++	switch (dctx->stage) {
-+	{
 +	case ZSTDds_getFrameHeaderSize:
-+		if (srcSize != ZSTD_frameHeaderSize_prefix) return ERROR(srcSize_wrong);      /* impossible */
++		if (srcSize != ZSTD_frameHeaderSize_prefix)
-+		if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */
++			return ERROR(srcSize_wrong);					/* impossible */
++		if ((ZSTD_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
 +			memcpy(dctx->headerBuffer, src, ZSTD_frameHeaderSize_prefix);
 +			dctx->expected = ZSTD_skippableHeaderSize - ZSTD_frameHeaderSize_prefix; /* magic number + skippable frame length */
 +			dctx->stage = ZSTDds_decodeSkippableHeader;
 +			return 0;
 +		}
 +		dctx->headerSize = ZSTD_frameHeaderSize(src, ZSTD_frameHeaderSize_prefix);
-+		if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
++		if (ZSTD_isError(dctx->headerSize))
++			return dctx->headerSize;
 +		memcpy(dctx->headerBuffer, src, ZSTD_frameHeaderSize_prefix);
 +		if (dctx->headerSize > ZSTD_frameHeaderSize_prefix) {
 +			dctx->expected = dctx->headerSize - ZSTD_frameHeaderSize_prefix;
@@ -6579,10 +6825,11 @@ index 0000000..bd76a75
 +		dctx->stage = ZSTDds_decodeBlockHeader;
 +		return 0;
 +
-+	case ZSTDds_decodeBlockHeader:
++	case ZSTDds_decodeBlockHeader: {
-+		{	blockProperties_t bp;
++		blockProperties_t bp;
 +		size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-+			if (ZSTD_isError(cBlockSize)) return cBlockSize;
++		if (ZSTD_isError(cBlockSize))
++			return cBlockSize;
 +		dctx->expected = cBlockSize;
 +		dctx->bType = bp.blockType;
 +		dctx->rleSize = bp.origSize;
@@ -6606,25 +6853,19 @@ index 0000000..bd76a75
 +		return 0;
 +	}
 +	case ZSTDds_decompressLastBlock:
-+	case ZSTDds_decompressBlock:
++	case ZSTDds_decompressBlock: {
-+		{	size_t rSize;
++		size_t rSize;
-+			switch(dctx->bType)
++		switch (dctx->bType) {
-+			{
++		case bt_compressed: rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); break;
-+			case bt_compressed:
++		case bt_raw: rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); break;
-+				rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
++		case bt_rle: rSize = ZSTD_setRleBlock(dst, dstCapacity, src, srcSize, dctx->rleSize); break;
-+				break;
-+			case bt_raw :
-+				rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
-+				break;
-+			case bt_rle :
-+				rSize = ZSTD_setRleBlock(dst, dstCapacity, src, srcSize, dctx->rleSize);
-+				break;
 +		case bt_reserved: /* should never happen */
-+			default:
++		default: return ERROR(corruption_detected);
-+				return ERROR(corruption_detected);
 +		}
-+			if (ZSTD_isError(rSize)) return rSize;
++		if (ZSTD_isError(rSize))
-+			if (dctx->fParams.checksumFlag) xxh64_update(&dctx->xxhState, dst, rSize);
++			return rSize;
++		if (dctx->fParams.checksumFlag)
++			xxh64_update(&dctx->xxhState, dst, rSize);
 +
 +		if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
 +			if (dctx->fParams.checksumFlag) {	/* another round for frame checksum */
@@ -6641,22 +6882,23 @@ index 0000000..bd76a75
 +		}
 +		return rSize;
 +	}
-+	case ZSTDds_checkChecksum:
++	case ZSTDds_checkChecksum: {
-+		{	U32 const h32 = (U32)xxh64_digest(&dctx->xxhState);
++		U32 const h32 = (U32)xxh64_digest(&dctx->xxhState);
-+			U32 const check32 = MEM_readLE32(src);   /* srcSize == 4, guaranteed by dctx->expected */
++		U32 const check32 = ZSTD_readLE32(src); /* srcSize == 4, guaranteed by dctx->expected */
-+			if (check32 != h32) return ERROR(checksum_wrong);
++		if (check32 != h32)
++			return ERROR(checksum_wrong);
 +		dctx->expected = 0;
 +		dctx->stage = ZSTDds_getFrameHeaderSize;
 +		return 0;
 +	}
-+	case ZSTDds_decodeSkippableHeader:
++	case ZSTDds_decodeSkippableHeader: {
-+		{	memcpy(dctx->headerBuffer + ZSTD_frameHeaderSize_prefix, src, dctx->expected);
++		memcpy(dctx->headerBuffer + ZSTD_frameHeaderSize_prefix, src, dctx->expected);
-+			dctx->expected = MEM_readLE32(dctx->headerBuffer + 4);
++		dctx->expected = ZSTD_readLE32(dctx->headerBuffer + 4);
 +		dctx->stage = ZSTDds_skipFrame;
 +		return 0;
 +	}
-+	case ZSTDds_skipFrame:
++	case ZSTDds_skipFrame: {
-+		{	dctx->expected = 0;
++		dctx->expected = 0;
 +		dctx->stage = ZSTDds_getFrameHeaderSize;
 +		return 0;
 +	}
@@ -6665,7 +6907,6 @@ index 0000000..bd76a75
 +	}
 +}
 +
-+
 +static size_t ZSTD_refDictContent(ZSTD_DCtx *dctx, const void *dict, size_t dictSize)
 +{
 +	dctx->dictEnd = dctx->previousDstEnd;
@@ -6683,66 +6924,87 @@ index 0000000..bd76a75
 +	const BYTE *dictPtr = (const BYTE *)dict;
 +	const BYTE *const dictEnd = dictPtr + dictSize;
 +
-+	if (dictSize <= 8) return ERROR(dictionary_corrupted);
++	if (dictSize <= 8)
++		return ERROR(dictionary_corrupted);
 +	dictPtr += 8; /* skip header = magic + dictID */
 +
-+
++	{
-+	{	size_t const hSize = HUF_readDTableX4(entropy->hufTable, dictPtr, dictEnd-dictPtr);
++		size_t const hSize = HUF_readDTableX4(entropy->hufTable, dictPtr, dictEnd - dictPtr);
-+		if (HUF_isError(hSize)) return ERROR(dictionary_corrupted);
++		if (HUF_isError(hSize))
++			return ERROR(dictionary_corrupted);
 +		dictPtr += hSize;
 +	}
 +
-+	{	short offcodeNCount[MaxOff+1];
++	{
++		short offcodeNCount[MaxOff + 1];
 +		U32 offcodeMaxValue = MaxOff, offcodeLog;
 +		size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(offcodeHeaderSize))
-+		if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (offcodeLog > OffFSELog)
++			return ERROR(dictionary_corrupted);
 +		CHECK_E(FSE_buildDTable(entropy->OFTable, offcodeNCount, offcodeMaxValue, offcodeLog), dictionary_corrupted);
 +		dictPtr += offcodeHeaderSize;
 +	}
 +
-+	{	short matchlengthNCount[MaxML+1];
++	{
++		short matchlengthNCount[MaxML + 1];
 +		unsigned matchlengthMaxValue = MaxML, matchlengthLog;
 +		size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(matchlengthHeaderSize))
-+		if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (matchlengthLog > MLFSELog)
++			return ERROR(dictionary_corrupted);
 +		CHECK_E(FSE_buildDTable(entropy->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog), dictionary_corrupted);
 +		dictPtr += matchlengthHeaderSize;
 +	}
 +
-+	{	short litlengthNCount[MaxLL+1];
++	{
++		short litlengthNCount[MaxLL + 1];
 +		unsigned litlengthMaxValue = MaxLL, litlengthLog;
 +		size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd - dictPtr);
-+		if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
++		if (FSE_isError(litlengthHeaderSize))
-+		if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
++			return ERROR(dictionary_corrupted);
++		if (litlengthLog > LLFSELog)
++			return ERROR(dictionary_corrupted);
 +		CHECK_E(FSE_buildDTable(entropy->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog), dictionary_corrupted);
 +		dictPtr += litlengthHeaderSize;
 +	}
 +
-+	if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
++	if (dictPtr + 12 > dictEnd)
-+	{	int i;
++		return ERROR(dictionary_corrupted);
++	{
++		int i;
 +		size_t const dictContentSize = (size_t)(dictEnd - (dictPtr + 12));
 +		for (i = 0; i < 3; i++) {
-+			U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
++			U32 const rep = ZSTD_readLE32(dictPtr);
-+			if (rep==0 || rep >= dictContentSize) return ERROR(dictionary_corrupted);
++			dictPtr += 4;
++			if (rep == 0 || rep >= dictContentSize)
++				return ERROR(dictionary_corrupted);
 +			entropy->rep[i] = rep;
-+	}   }
++		}
++	}
 +
 +	return dictPtr - (const BYTE *)dict;
 +}
 +
 +static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx *dctx, const void *dict, size_t dictSize)
 +{
-+	if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
++	if (dictSize < 8)
-+	{	U32 const magic = MEM_readLE32(dict);
++		return ZSTD_refDictContent(dctx, dict, dictSize);
++	{
++		U32 const magic = ZSTD_readLE32(dict);
 +		if (magic != ZSTD_DICT_MAGIC) {
 +			return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
-+	}   }
++		}
-+	dctx->dictID = MEM_readLE32((const char*)dict + 4);
++	}
++	dctx->dictID = ZSTD_readLE32((const char *)dict + 4);
 +
 +	/* load entropy tables */
-+	{	size_t const eSize = ZSTD_loadEntropy(&dctx->entropy, dict, dictSize);
++	{
-+		if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted);
++		size_t const eSize = ZSTD_loadEntropy(&dctx->entropy, dict, dictSize);
++		if (ZSTD_isError(eSize))
++			return ERROR(dictionary_corrupted);
 +		dict = (const char *)dict + eSize;
 +		dictSize -= eSize;
 +	}
@@ -6755,11 +7017,11 @@ index 0000000..bd76a75
 +size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx *dctx, const void *dict, size_t dictSize)
 +{
 +	CHECK_F(ZSTD_decompressBegin(dctx));
-+	if (dict && dictSize) CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted);
++	if (dict && dictSize)
++		CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted);
 +	return 0;
 +}
 +
-+
 +/* ======   ZSTD_DDict   ====== */
 +
 +struct ZSTD_DDict_s {
@@ -6772,20 +7034,11 @@ index 0000000..bd76a75
 +	ZSTD_customMem cMem;
 +}; /* typedef'd to ZSTD_DDict within "zstd.h" */
 +
-+size_t ZSTD_DDictWorkspaceBound(void)
++size_t ZSTD_DDictWorkspaceBound(void) { return ZSTD_ALIGN(sizeof(ZSTD_stack)) + ZSTD_ALIGN(sizeof(ZSTD_DDict)); }
-+{
-+	return ZSTD_ALIGN(sizeof(ZSTD_stack)) + ZSTD_ALIGN(sizeof(ZSTD_DDict));
-+}
 +
-+static const void* ZSTD_DDictDictContent(const ZSTD_DDict* ddict)
++static const void *ZSTD_DDictDictContent(const ZSTD_DDict *ddict) { return ddict->dictContent; }
-+{
-+	return ddict->dictContent;
-+}
 +
-+static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict)
++static size_t ZSTD_DDictDictSize(const ZSTD_DDict *ddict) { return ddict->dictSize; }
-+{
-+	return ddict->dictSize;
-+}
 +
 +static void ZSTD_refDDict(ZSTD_DCtx *dstDCtx, const ZSTD_DDict *ddict)
 +{
@@ -6817,11 +7070,14 @@ index 0000000..bd76a75
 +{
 +	ddict->dictID = 0;
 +	ddict->entropyPresent = 0;
-+	if (ddict->dictSize < 8) return 0;
++	if (ddict->dictSize < 8)
-+	{	U32 const magic = MEM_readLE32(ddict->dictContent);
++		return 0;
-+		if (magic != ZSTD_DICT_MAGIC) return 0;   /* pure content mode */
++	{
++		U32 const magic = ZSTD_readLE32(ddict->dictContent);
++		if (magic != ZSTD_DICT_MAGIC)
++			return 0; /* pure content mode */
 +	}
-+	ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + 4);
++	ddict->dictID = ZSTD_readLE32((const char *)ddict->dictContent + 4);
 +
 +	/* load entropy tables */
 +	CHECK_E(ZSTD_loadEntropy(&ddict->entropy, ddict->dictContent, ddict->dictSize), dictionary_corrupted);
@@ -6829,13 +7085,15 @@ index 0000000..bd76a75
 +	return 0;
 +}
 +
-+
 +static ZSTD_DDict *ZSTD_createDDict_advanced(const void *dict, size_t dictSize, unsigned byReference, ZSTD_customMem customMem)
 +{
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +
-+	{	ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
++	{
-+		if (!ddict) return NULL;
++		ZSTD_DDict *const ddict = (ZSTD_DDict *)ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
++		if (!ddict)
++			return NULL;
 +		ddict->cMem = customMem;
 +
 +		if ((byReference) || (!dict) || (!dictSize)) {
@@ -6843,7 +7101,10 @@ index 0000000..bd76a75
 +			ddict->dictContent = dict;
 +		} else {
 +			void *const internalBuffer = ZSTD_malloc(dictSize, customMem);
-+			if (!internalBuffer) { ZSTD_freeDDict(ddict); return NULL; }
++			if (!internalBuffer) {
++				ZSTD_freeDDict(ddict);
++				return NULL;
++			}
 +			memcpy(internalBuffer, dict, dictSize);
 +			ddict->dictBuffer = internalBuffer;
 +			ddict->dictContent = internalBuffer;
@@ -6851,11 +7112,13 @@ index 0000000..bd76a75
 +		ddict->dictSize = dictSize;
 +		ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
 +		/* parse dictionary content */
-+		{	size_t const errorCode = ZSTD_loadEntropy_inDDict(ddict);
++		{
++			size_t const errorCode = ZSTD_loadEntropy_inDDict(ddict);
 +			if (ZSTD_isError(errorCode)) {
 +				ZSTD_freeDDict(ddict);
 +				return NULL;
-+		}   }
++			}
++		}
 +
 +		return ddict;
 +	}
@@ -6871,11 +7134,12 @@ index 0000000..bd76a75
 +	return ZSTD_createDDict_advanced(dict, dictSize, 1, stackMem);
 +}
 +
-+
 +size_t ZSTD_freeDDict(ZSTD_DDict *ddict)
 +{
-+	if (ddict==NULL) return 0;   /* support free on NULL */
++	if (ddict == NULL)
-+	{	ZSTD_customMem const cMem = ddict->cMem;
++		return 0; /* support free on NULL */
++	{
++		ZSTD_customMem const cMem = ddict->cMem;
 +		ZSTD_free(ddict->dictBuffer, cMem);
 +		ZSTD_free(ddict, cMem);
 +		return 0;
@@ -6888,9 +7152,11 @@ index 0000000..bd76a75
 + *  It can still be loaded, but as a content-only dictionary. */
 +unsigned ZSTD_getDictID_fromDict(const void *dict, size_t dictSize)
 +{
-+	if (dictSize < 8) return 0;
++	if (dictSize < 8)
-+	if (MEM_readLE32(dict) != ZSTD_DICT_MAGIC) return 0;
++		return 0;
-+	return MEM_readLE32((const char*)dict + 4);
++	if (ZSTD_readLE32(dict) != ZSTD_DICT_MAGIC)
++		return 0;
++	return ZSTD_readLE32((const char *)dict + 4);
 +}
 +
 +/*! ZSTD_getDictID_fromDDict() :
@@ -6899,7 +7165,8 @@ index 0000000..bd76a75
 + *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
 +unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict *ddict)
 +{
-+	if (ddict==NULL) return 0;
++	if (ddict == NULL)
++		return 0;
 +	return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
 +}
 +
@@ -6917,32 +7184,25 @@ index 0000000..bd76a75
 +{
 +	ZSTD_frameParams zfp = {0, 0, 0, 0};
 +	size_t const hError = ZSTD_getFrameParams(&zfp, src, srcSize);
-+	if (ZSTD_isError(hError)) return 0;
++	if (ZSTD_isError(hError))
++		return 0;
 +	return zfp.dictID;
 +}
 +
-+
 +/*! ZSTD_decompress_usingDDict() :
 +*   Decompression using a pre-digested Dictionary
 +*   Use dictionary without significant overhead. */
-+size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
++size_t ZSTD_decompress_usingDDict(ZSTD_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const ZSTD_DDict *ddict)
-+								  void* dst, size_t dstCapacity,
-+							const void* src, size_t srcSize,
-+							const ZSTD_DDict* ddict)
 +{
 +	/* pass content and size in case legacy frames are encountered */
-+	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
++	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, NULL, 0, ddict);
-+									 NULL, 0,
-+									 ddict);
 +}
 +
-+
 +/*=====================================
 +*   Streaming decompression
 +*====================================*/
 +
-+typedef enum { zdss_init, zdss_loadHeader,
++typedef enum { zdss_init, zdss_loadHeader, zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
-+			   zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
 +
 +/* *** Resource management *** */
 +struct ZSTD_DStream_s {
@@ -6969,7 +7229,8 @@ index 0000000..bd76a75
 +	U32 hostageByte;
 +}; /* typedef'd to ZSTD_DStream within "zstd.h" */
 +
-+size_t ZSTD_DStreamWorkspaceBound(size_t maxWindowSize) {
++size_t ZSTD_DStreamWorkspaceBound(size_t maxWindowSize)
++{
 +	size_t const blockSize = MIN(maxWindowSize, ZSTD_BLOCKSIZE_ABSOLUTEMAX);
 +	size_t const inBuffSize = blockSize;
 +	size_t const outBuffSize = maxWindowSize + blockSize + WILDCOPY_OVERLENGTH * 2;
@@ -6980,14 +7241,19 @@ index 0000000..bd76a75
 +{
 +	ZSTD_DStream *zds;
 +
-+	if (!customMem.customAlloc || !customMem.customFree) return NULL;
++	if (!customMem.customAlloc || !customMem.customFree)
++		return NULL;
 +
 +	zds = (ZSTD_DStream *)ZSTD_malloc(sizeof(ZSTD_DStream), customMem);
-+	if (zds==NULL) return NULL;
++	if (zds == NULL)
++		return NULL;
 +	memset(zds, 0, sizeof(ZSTD_DStream));
 +	memcpy(&zds->customMem, &customMem, sizeof(ZSTD_customMem));
 +	zds->dctx = ZSTD_createDCtx_advanced(customMem);
-+	if (zds->dctx == NULL) { ZSTD_freeDStream(zds); return NULL; }
++	if (zds->dctx == NULL) {
++		ZSTD_freeDStream(zds);
++		return NULL;
++	}
 +	zds->stage = zdss_init;
 +	zds->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
 +	return zds;
@@ -6997,7 +7263,9 @@ index 0000000..bd76a75
 +{
 +	ZSTD_customMem const stackMem = ZSTD_initStack(workspace, workspaceSize);
 +	ZSTD_DStream *zds = ZSTD_createDStream_advanced(stackMem);
-+	if (!zds) { return NULL; }
++	if (!zds) {
++		return NULL;
++	}
 +
 +	zds->maxWindowSize = maxWindowSize;
 +	zds->stage = zdss_loadHeader;
@@ -7021,8 +7289,10 @@ index 0000000..bd76a75
 +
 +size_t ZSTD_freeDStream(ZSTD_DStream *zds)
 +{
-+	if (zds==NULL) return 0;   /* support free on null */
++	if (zds == NULL)
-+	{	ZSTD_customMem const cMem = zds->customMem;
++		return 0; /* support free on null */
++	{
++		ZSTD_customMem const cMem = zds->customMem;
 +		ZSTD_freeDCtx(zds->dctx);
 +		zds->dctx = NULL;
 +		ZSTD_freeDDict(zds->ddictLocal);
@@ -7036,7 +7306,6 @@ index 0000000..bd76a75
 +	}
 +}
 +
-+
 +/* *** Initialization *** */
 +
 +size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_ABSOLUTEMAX + ZSTD_blockHeaderSize; }
@@ -7053,14 +7322,13 @@ index 0000000..bd76a75
 +
 +/* *****   Decompression   ***** */
 +
-+MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
++ZSTD_STATIC size_t ZSTD_limitCopy(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 +{
 +	size_t const length = MIN(dstCapacity, srcSize);
 +	memcpy(dst, src, length);
 +	return length;
 +}
 +
-+
 +size_t ZSTD_decompressStream(ZSTD_DStream *zds, ZSTD_outBuffer *output, ZSTD_inBuffer *input)
 +{
 +	const char *const istart = (const char *)(input->src) + input->pos;
@@ -7072,14 +7340,13 @@ index 0000000..bd76a75
 +	U32 someMoreWork = 1;
 +
 +	while (someMoreWork) {
-+		switch(zds->stage)
++		switch (zds->stage) {
-+		{
 +		case zdss_init:
 +			ZSTD_resetDStream(zds); /* transparent reset on starting decoding a new frame */
 +						/* fall-through */
 +
-+		case zdss_loadHeader :
++		case zdss_loadHeader: {
-+			{	size_t const hSize = ZSTD_getFrameParams(&zds->fParams, zds->headerBuffer, zds->lhSize);
++			size_t const hSize = ZSTD_getFrameParams(&zds->fParams, zds->headerBuffer, zds->lhSize);
 +			if (ZSTD_isError(hSize))
 +				return hSize;
 +			if (hSize != 0) {				   /* need more input */
@@ -7088,11 +7355,15 @@ index 0000000..bd76a75
 +					memcpy(zds->headerBuffer + zds->lhSize, ip, iend - ip);
 +					zds->lhSize += iend - ip;
 +					input->pos = input->size;
-+						return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
++					return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) +
++					       ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
 +				}
-+					memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
++				memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad);
++				zds->lhSize = hSize;
++				ip += toLoad;
 +				break;
-+			}   }
++			}
++		}
 +
 +			/* check for single-pass mode opportunity */
 +			if (zds->fParams.frameContentSize && zds->fParams.windowSize /* skippable frame if == 0 */
@@ -7100,47 +7371,57 @@ index 0000000..bd76a75
 +				size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend - istart);
 +				if (cSize <= (size_t)(iend - istart)) {
 +					size_t const decompressedSize = ZSTD_decompress_usingDDict(zds->dctx, op, oend - op, istart, cSize, zds->ddict);
-+					if (ZSTD_isError(decompressedSize)) return decompressedSize;
++					if (ZSTD_isError(decompressedSize))
++						return decompressedSize;
 +					ip = istart + cSize;
 +					op += decompressedSize;
 +					zds->dctx->expected = 0;
 +					zds->stage = zdss_init;
 +					someMoreWork = 0;
 +					break;
-+			}   }
++				}
++			}
 +
 +			/* Consume header */
 +			ZSTD_refDDict(zds->dctx, zds->ddict);
-+			{	size_t const h1Size = ZSTD_nextSrcSizeToDecompress(zds->dctx);  /* == ZSTD_frameHeaderSize_prefix */
++			{
++				size_t const h1Size = ZSTD_nextSrcSizeToDecompress(zds->dctx); /* == ZSTD_frameHeaderSize_prefix */
 +				CHECK_F(ZSTD_decompressContinue(zds->dctx, NULL, 0, zds->headerBuffer, h1Size));
-+				{	size_t const h2Size = ZSTD_nextSrcSizeToDecompress(zds->dctx);
++				{
++					size_t const h2Size = ZSTD_nextSrcSizeToDecompress(zds->dctx);
 +					CHECK_F(ZSTD_decompressContinue(zds->dctx, NULL, 0, zds->headerBuffer + h1Size, h2Size));
-+			}   }
++				}
++			}
 +
 +			zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
-+			if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge);
++			if (zds->fParams.windowSize > zds->maxWindowSize)
++				return ERROR(frameParameter_windowTooLarge);
 +
 +			/* Adapt buffer sizes to frame header instructions */
-+			{	size_t const blockSize = MIN(zds->fParams.windowSize, ZSTD_BLOCKSIZE_ABSOLUTEMAX);
++			{
++				size_t const blockSize = MIN(zds->fParams.windowSize, ZSTD_BLOCKSIZE_ABSOLUTEMAX);
 +				size_t const neededOutSize = zds->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2;
 +				zds->blockSize = blockSize;
 +				if (zds->inBuffSize < blockSize) {
 +					ZSTD_free(zds->inBuff, zds->customMem);
 +					zds->inBuffSize = blockSize;
 +					zds->inBuff = (char *)ZSTD_malloc(blockSize, zds->customMem);
-+					if (zds->inBuff == NULL) return ERROR(memory_allocation);
++					if (zds->inBuff == NULL)
++						return ERROR(memory_allocation);
 +				}
 +				if (zds->outBuffSize < neededOutSize) {
 +					ZSTD_free(zds->outBuff, zds->customMem);
 +					zds->outBuffSize = neededOutSize;
 +					zds->outBuff = (char *)ZSTD_malloc(neededOutSize, zds->customMem);
-+					if (zds->outBuff == NULL) return ERROR(memory_allocation);
++					if (zds->outBuff == NULL)
-+			}   }
++						return ERROR(memory_allocation);
++				}
++			}
 +			zds->stage = zdss_read;
 +		/* pass-through */
 +
-+		case zdss_read:
++		case zdss_read: {
-+			{	size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds->dctx);
++			size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds->dctx);
 +			if (neededInSize == 0) { /* end of frame */
 +				zds->stage = zdss_init;
 +				someMoreWork = 0;
@@ -7148,46 +7429,59 @@ index 0000000..bd76a75
 +			}
 +			if ((size_t)(iend - ip) >= neededInSize) { /* decode directly from src */
 +				const int isSkipFrame = ZSTD_isSkipFrame(zds->dctx);
-+					size_t const decodedSize = ZSTD_decompressContinue(zds->dctx,
++				size_t const decodedSize = ZSTD_decompressContinue(zds->dctx, zds->outBuff + zds->outStart,
-+						zds->outBuff + zds->outStart, (isSkipFrame ? 0 : zds->outBuffSize - zds->outStart),
++										   (isSkipFrame ? 0 : zds->outBuffSize - zds->outStart), ip, neededInSize);
-+						ip, neededInSize);
++				if (ZSTD_isError(decodedSize))
-+					if (ZSTD_isError(decodedSize)) return decodedSize;
++					return decodedSize;
 +				ip += neededInSize;
-+					if (!decodedSize && !isSkipFrame) break;   /* this was just a header */
++				if (!decodedSize && !isSkipFrame)
++					break; /* this was just a header */
 +				zds->outEnd = zds->outStart + decodedSize;
 +				zds->stage = zdss_flush;
 +				break;
 +			}
-+				if (ip==iend) { someMoreWork = 0; break; }   /* no more input */
++			if (ip == iend) {
++				someMoreWork = 0;
++				break;
++			} /* no more input */
 +			zds->stage = zdss_load;
 +			/* pass-through */
 +		}
 +
-+		case zdss_load:
++		case zdss_load: {
-+			{	size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds->dctx);
++			size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds->dctx);
 +			size_t const toLoad = neededInSize - zds->inPos; /* should always be <= remaining space within inBuff */
 +			size_t loadedSize;
-+				if (toLoad > zds->inBuffSize - zds->inPos) return ERROR(corruption_detected);   /* should never happen */
++			if (toLoad > zds->inBuffSize - zds->inPos)
++				return ERROR(corruption_detected); /* should never happen */
 +			loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend - ip);
 +			ip += loadedSize;
 +			zds->inPos += loadedSize;
-+				if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */
++			if (loadedSize < toLoad) {
++				someMoreWork = 0;
++				break;
++			} /* not enough input, wait for more */
 +
 +			/* decode loaded input */
-+				{  const int isSkipFrame = ZSTD_isSkipFrame(zds->dctx);
++			{
-+				   size_t const decodedSize = ZSTD_decompressContinue(zds->dctx,
++				const int isSkipFrame = ZSTD_isSkipFrame(zds->dctx);
-+						zds->outBuff + zds->outStart, zds->outBuffSize - zds->outStart,
++				size_t const decodedSize = ZSTD_decompressContinue(zds->dctx, zds->outBuff + zds->outStart, zds->outBuffSize - zds->outStart,
 +										   zds->inBuff, neededInSize);
-+					if (ZSTD_isError(decodedSize)) return decodedSize;
++				if (ZSTD_isError(decodedSize))
++					return decodedSize;
 +				zds->inPos = 0; /* input is consumed */
-+					if (!decodedSize && !isSkipFrame) { zds->stage = zdss_read; break; }   /* this was just a header */
++				if (!decodedSize && !isSkipFrame) {
++					zds->stage = zdss_read;
++					break;
++				} /* this was just a header */
 +				zds->outEnd = zds->outStart + decodedSize;
 +				zds->stage = zdss_flush;
 +				/* pass-through */
-+			}   }
++			}
++		}
 +
-+		case zdss_flush:
++		case zdss_flush: {
-+			{	size_t const toFlushSize = zds->outEnd - zds->outStart;
++			size_t const toFlushSize = zds->outEnd - zds->outStart;
 +			size_t const flushedSize = ZSTD_limitCopy(op, oend - op, zds->outBuff + zds->outStart, toFlushSize);
 +			op += flushedSize;
 +			zds->outStart += flushedSize;
@@ -7201,17 +7495,23 @@ index 0000000..bd76a75
 +			someMoreWork = 0;
 +			break;
 +		}
-+		default: return ERROR(GENERIC);   /* impossible */
++		default:
-+	}   }
++			return ERROR(GENERIC); /* impossible */
++		}
++	}
 +
 +	/* result */
 +	input->pos += (size_t)(ip - istart);
 +	output->pos += (size_t)(op - ostart);
-+	{	size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds->dctx);
++	{
++		size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds->dctx);
 +		if (!nextSrcSizeHint) {			    /* frame fully decoded */
 +			if (zds->outEnd == zds->outStart) { /* output fully flushed */
 +				if (zds->hostageByte) {
-+					if (input->pos >= input->size) { zds->stage = zdss_read; return 1; }  /* can't release hostage (not present) */
++					if (input->pos >= input->size) {
++						zds->stage = zdss_read;
++						return 1;
++					}	     /* can't release hostage (not present) */
 +					input->pos++; /* release hostage */
 +				}
 +				return 0;
@@ -7223,7 +7523,8 @@ index 0000000..bd76a75
 +			return 1;
 +		}
 +		nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds->dctx) == ZSTDnit_block); /* preload header of next block */
-+		if (zds->inPos > nextSrcSizeHint) return ERROR(GENERIC);   /* should never happen */
++		if (zds->inPos > nextSrcSizeHint)
++			return ERROR(GENERIC); /* should never happen */
 +		nextSrcSizeHint -= zds->inPos; /* already loaded*/
 +		return nextSrcSizeHint;
 +	}
@@ -7270,10 +7571,10 @@ index 0000000..bd76a75
 +MODULE_DESCRIPTION("Zstd Decompressor");
 diff --git a/lib/zstd/entropy_common.c b/lib/zstd/entropy_common.c
 new file mode 100644
-index 0000000..b13fb99
+index 0000000..b354fc2
 --- /dev/null
 +++ b/lib/zstd/entropy_common.c
-@@ -0,0 +1,222 @@
+@@ -0,0 +1,244 @@
 +/*
 + * Common functions of New Generation Entropy library
 + * Copyright (C) 2016, Yann Collet.
@@ -7316,27 +7617,23 @@ index 0000000..b13fb99
 +/* *************************************
 +*  Dependencies
 +***************************************/
-+#include "mem.h"
 +#include "error_private.h" /* ERR_*, ERROR */
 +#include "fse.h"
 +#include "huf.h"
-+
++#include "mem.h"
 +
 +/*===   Version   ===*/
 +unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }
 +
-+
 +/*===   Error Management   ===*/
 +unsigned FSE_isError(size_t code) { return ERR_isError(code); }
 +
 +unsigned HUF_isError(size_t code) { return ERR_isError(code); }
 +
-+
 +/*-**************************************************************
 +*  FSE NCount encoding-decoding
 +****************************************************************/
-+size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
++size_t FSE_readNCount(short *normalizedCounter, unsigned *maxSVPtr, unsigned *tableLogPtr, const void *headerBuffer, size_t hbSize)
-+				 const void* headerBuffer, size_t hbSize)
 +{
 +	const BYTE *const istart = (const BYTE *)headerBuffer;
 +	const BYTE *const iend = istart + hbSize;
@@ -7349,10 +7646,12 @@ index 0000000..b13fb99
 +	unsigned charnum = 0;
 +	int previous0 = 0;
 +
-+	if (hbSize < 4) return ERROR(srcSize_wrong);
++	if (hbSize < 4)
-+	bitStream = MEM_readLE32(ip);
++		return ERROR(srcSize_wrong);
++	bitStream = ZSTD_readLE32(ip);
 +	nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG; /* extract tableLog */
-+	if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
++	if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX)
++		return ERROR(tableLog_tooLarge);
 +	bitStream >>= 4;
 +	bitCount = 4;
 +	*tableLogPtr = nbBits;
@@ -7367,11 +7666,12 @@ index 0000000..b13fb99
 +				n0 += 24;
 +				if (ip < iend - 5) {
 +					ip += 2;
-+					bitStream = MEM_readLE32(ip) >> bitCount;
++					bitStream = ZSTD_readLE32(ip) >> bitCount;
 +				} else {
 +					bitStream >>= 16;
 +					bitCount += 16;
-+			}   }
++				}
++			}
 +			while ((bitStream & 3) == 3) {
 +				n0 += 3;
 +				bitStream >>= 2;
@@ -7379,16 +7679,20 @@ index 0000000..b13fb99
 +			}
 +			n0 += bitStream & 3;
 +			bitCount += 2;
-+			if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
++			if (n0 > *maxSVPtr)
-+			while (charnum < n0) normalizedCounter[charnum++] = 0;
++				return ERROR(maxSymbolValue_tooSmall);
++			while (charnum < n0)
++				normalizedCounter[charnum++] = 0;
 +			if ((ip <= iend - 7) || (ip + (bitCount >> 3) <= iend - 4)) {
 +				ip += bitCount >> 3;
 +				bitCount &= 7;
-+				bitStream = MEM_readLE32(ip) >> bitCount;
++				bitStream = ZSTD_readLE32(ip) >> bitCount;
 +			} else {
 +				bitStream >>= 2;
-+		}   }
++			}
-+		{	int const max = (2*threshold-1) - remaining;
++		}
++		{
++			int const max = (2 * threshold - 1) - remaining;
 +			int count;
 +
 +			if ((bitStream & (threshold - 1)) < (U32)max) {
@@ -7396,7 +7700,8 @@ index 0000000..b13fb99
 +				bitCount += nbBits - 1;
 +			} else {
 +				count = bitStream & (2 * threshold - 1);
-+				if (count >= threshold) count -= max;
++				if (count >= threshold)
++					count -= max;
 +				bitCount += nbBits;
 +			}
 +
@@ -7416,17 +7721,19 @@ index 0000000..b13fb99
 +				bitCount -= (int)(8 * (iend - 4 - ip));
 +				ip = iend - 4;
 +			}
-+			bitStream = MEM_readLE32(ip) >> (bitCount & 31);
++			bitStream = ZSTD_readLE32(ip) >> (bitCount & 31);
-+	}   }   /* while ((remaining>1) & (charnum<=*maxSVPtr)) */
++		}
-+	if (remaining != 1) return ERROR(corruption_detected);
++	} /* while ((remaining>1) & (charnum<=*maxSVPtr)) */
-+	if (bitCount > 32) return ERROR(corruption_detected);
++	if (remaining != 1)
++		return ERROR(corruption_detected);
++	if (bitCount > 32)
++		return ERROR(corruption_detected);
 +	*maxSVPtr = charnum - 1;
 +
 +	ip += (bitCount + 7) >> 3;
 +	return ip - istart;
 +}
 +
-+
 +/*! HUF_readStats() :
 +	Read compact Huffman tree, saved by HUF_writeCTable().
 +	`huffWeight` is destination buffer.
@@ -7434,63 +7741,79 @@ index 0000000..b13fb99
 +	@return : size read from `src` , or an error Code .
 +	Note : Needed by HUF_readCTable() and HUF_readDTableX?() .
 +*/
-+size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
++size_t HUF_readStats(BYTE *huffWeight, size_t hwSize, U32 *rankStats, U32 *nbSymbolsPtr, U32 *tableLogPtr, const void *src, size_t srcSize)
-+					 U32* nbSymbolsPtr, U32* tableLogPtr,
-+					 const void* src, size_t srcSize)
 +{
 +	U32 weightTotal;
 +	const BYTE *ip = (const BYTE *)src;
 +	size_t iSize;
 +	size_t oSize;
 +
-+	if (!srcSize) return ERROR(srcSize_wrong);
++	if (!srcSize)
++		return ERROR(srcSize_wrong);
 +	iSize = ip[0];
 +	/* memset(huffWeight, 0, hwSize);   */ /* is not necessary, even though some analyzer complain ... */
 +
 +	if (iSize >= 128) { /* special header */
 +		oSize = iSize - 127;
 +		iSize = ((oSize + 1) / 2);
-+		if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
++		if (iSize + 1 > srcSize)
-+		if (oSize >= hwSize) return ERROR(corruption_detected);
++			return ERROR(srcSize_wrong);
++		if (oSize >= hwSize)
++			return ERROR(corruption_detected);
 +		ip += 1;
-+		{	U32 n;
++		{
++			U32 n;
 +			for (n = 0; n < oSize; n += 2) {
 +				huffWeight[n] = ip[n / 2] >> 4;
 +				huffWeight[n + 1] = ip[n / 2] & 15;
-+	}   }   }
++			}
-+	else  {   /* header compressed with FSE (normal case) */
++		}
++	} else {						 /* header compressed with FSE (normal case) */
 +		FSE_DTable fseWorkspace[FSE_DTABLE_SIZE_U32(6)]; /* 6 is max possible tableLog for HUF header (maybe even 5, to be tested) */
-+		if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
++		if (iSize + 1 > srcSize)
++			return ERROR(srcSize_wrong);
 +		oSize = FSE_decompress_wksp(huffWeight, hwSize - 1, ip + 1, iSize, fseWorkspace, 6); /* max (hwSize-1) values decoded, as last one is implied */
-+		if (FSE_isError(oSize)) return oSize;
++		if (FSE_isError(oSize))
++			return oSize;
 +	}
 +
 +	/* collect weight stats */
 +	memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
 +	weightTotal = 0;
-+	{	U32 n; for (n=0; n<oSize; n++) {
++	{
-+			if (huffWeight[n] >= HUF_TABLELOG_MAX) return ERROR(corruption_detected);
++		U32 n;
++		for (n = 0; n < oSize; n++) {
++			if (huffWeight[n] >= HUF_TABLELOG_MAX)
++				return ERROR(corruption_detected);
 +			rankStats[huffWeight[n]]++;
 +			weightTotal += (1 << huffWeight[n]) >> 1;
-+	}   }
++		}
-+	if (weightTotal == 0) return ERROR(corruption_detected);
++	}
++	if (weightTotal == 0)
++		return ERROR(corruption_detected);
 +
 +	/* get last non-null symbol weight (implied, total must be 2^n) */
-+	{	U32 const tableLog = BIT_highbit32(weightTotal) + 1;
++	{
-+		if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
++		U32 const tableLog = BIT_highbit32(weightTotal) + 1;
++		if (tableLog > HUF_TABLELOG_MAX)
++			return ERROR(corruption_detected);
 +		*tableLogPtr = tableLog;
 +		/* determine last weight */
-+		{	U32 const total = 1 << tableLog;
++		{
++			U32 const total = 1 << tableLog;
 +			U32 const rest = total - weightTotal;
 +			U32 const verif = 1 << BIT_highbit32(rest);
 +			U32 const lastWeight = BIT_highbit32(rest) + 1;
-+			if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
++			if (verif != rest)
++				return ERROR(corruption_detected); /* last value must be a clean power of 2 */
 +			huffWeight[oSize] = (BYTE)lastWeight;
 +			rankStats[lastWeight]++;
-+	}   }
++		}
++	}
 +
 +	/* check tree construction validity */
-+	if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
++	if ((rankStats[1] < 2) || (rankStats[1] & 1))
++		return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */
 +
 +	/* results */
 +	*nbSymbolsPtr = (U32)(oSize + 1);
@@ -7498,10 +7821,10 @@ index 0000000..b13fb99
 +}
 diff --git a/lib/zstd/error_private.h b/lib/zstd/error_private.h
 new file mode 100644
-index 0000000..fd1f4ff
+index 0000000..1a60b31
 --- /dev/null
 +++ b/lib/zstd/error_private.h
-@@ -0,0 +1,51 @@
+@@ -0,0 +1,53 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -7529,20 +7852,17 @@ index 0000000..fd1f4ff
 +#include <linux/types.h> /* size_t */
 +#include <linux/zstd.h>  /* enum list */
 +
-+
 +/* ****************************************
 +*  Compiler-specific
 +******************************************/
 +#define ERR_STATIC static __attribute__((unused))
 +
-+
 +/*-****************************************
 +*  Customization (error_public.h)
 +******************************************/
 +typedef ZSTD_ErrorCode ERR_enum;
 +#define PREFIX(name) ZSTD_error_##name
 +
-+
 +/*-****************************************
 +*  Error codes handling
 +******************************************/
@@ -7550,15 +7870,20 @@ index 0000000..fd1f4ff
 +
 +ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
 +
-+ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }
++ERR_STATIC ERR_enum ERR_getErrorCode(size_t code)
++{
++	if (!ERR_isError(code))
++		return (ERR_enum)0;
++	return (ERR_enum)(0 - code);
++}
 +
 +#endif /* ERROR_H_MODULE */
 diff --git a/lib/zstd/fse.h b/lib/zstd/fse.h
 new file mode 100644
-index 0000000..a042154
+index 0000000..9749755
 --- /dev/null
 +++ b/lib/zstd/fse.h
-@@ -0,0 +1,612 @@
+@@ -0,0 +1,588 @@
 +/*
 + * FSE : Finite State Entropy codec
 + * Public Prototypes declaration
@@ -7601,13 +7926,11 @@ index 0000000..a042154
 +#ifndef FSE_H
 +#define FSE_H
 +
-+
 +/*-*****************************************
 +*  Dependencies
 +******************************************/
 +#include <linux/types.h> /* size_t, ptrdiff_t */
 +
-+
 +/*-*****************************************
 +*  FSE_PUBLIC_API : control library symbols visibility
 +******************************************/
@@ -7634,7 +7957,6 @@ index 0000000..a042154
 +/* Error Management */
 +FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
 +
-+
 +/*-*****************************************
 +*  FSE detailed API
 +******************************************/
@@ -7681,7 +8003,6 @@ index 0000000..a042154
 +			  or an errorCode, which can be tested using FSE_isError(). */
 +FSE_PUBLIC_API size_t FSE_writeNCount(void *buffer, size_t bufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
 +
-+
 +/*! Constructor and Destructor of FSE_CTable.
 +	Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
 +typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
@@ -7736,7 +8057,6 @@ index 0000000..a042154
 +If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
 +*/
 +
-+
 +/* *** DECOMPRESSION *** */
 +
 +/*! FSE_readNCount():
@@ -7790,11 +8110,9 @@ index 0000000..a042154
 +If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
 +*/
 +
-+
 +/* *** Dependency *** */
 +#include "bitstream.h"
 +
-+
 +/* *****************************************
 +*  Static allocation
 +*******************************************/
@@ -7807,7 +8125,6 @@ index 0000000..a042154
 +#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1 << (maxTableLog - 1)) + ((maxSymbolValue + 1) * 2))
 +#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1 << maxTableLog))
 +
-+
 +/* *****************************************
 +*  FSE advanced API
 +*******************************************/
@@ -7815,8 +8132,7 @@ index 0000000..a042154
 + * Same as FSE_count(), but using an externally provided scratch buffer.
 + * `workSpace` size must be table of >= `1024` unsigned
 + */
-+size_t FSE_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
++size_t FSE_count_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned *workSpace);
-+				 const void* source, size_t sourceSize, unsigned* workSpace);
 +
 +/* FSE_countFast_wksp() :
 + * Same as FSE_countFast(), but using an externally provided scratch buffer.
@@ -7830,8 +8146,6 @@ index 0000000..a042154
 +*/
 +size_t FSE_count_simple(unsigned *count, unsigned *maxSymbolValuePtr, const void *src, size_t srcSize);
 +
-+
-+
 +unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
 +/**< same as FSE_optimalTableLog(), which used `minus==2` */
 +
@@ -7839,8 +8153,10 @@ index 0000000..a042154
 + * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
 + * FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
 + */
-+#define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue)   ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
++#define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) \
-+size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
++	(FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024))
++size_t FSE_compress_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
++			 size_t wkspSize);
 +
 +size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits);
 +/**< build a fake FSE_CTable, designed for a flat distribution, where each symbol uses nbBits */
@@ -7863,7 +8179,6 @@ index 0000000..a042154
 +size_t FSE_decompress_wksp(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, FSE_DTable *workSpace, unsigned maxLog);
 +/**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DTABLE_SIZE_U32(maxLog)` */
 +
-+
 +/* *****************************************
 +*  FSE symbol compression API
 +*******************************************/
@@ -7927,7 +8242,6 @@ index 0000000..a042154
 +	size_t size = BIT_closeCStream(&bitStream);
 +*/
 +
-+
 +/* *****************************************
 +*  FSE symbol decompression API
 +*******************************************/
@@ -7936,7 +8250,6 @@ index 0000000..a042154
 +	const void *table; /* precise table may vary, depending on U16 */
 +} FSE_DState_t;
 +
-+
 +static void FSE_initDState(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD, const FSE_DTable *dt);
 +
 +static unsigned char FSE_decodeSymbol(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD);
@@ -7992,14 +8305,12 @@ index 0000000..a042154
 +	FSE_endOfDState(&DState);
 +*/
 +
-+
 +/* *****************************************
 +*  FSE unsafe API
 +*******************************************/
 +static unsigned char FSE_decodeSymbolFast(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD);
 +/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
 +
-+
 +/* *****************************************
 +*  Implementation of inlined functions
 +*******************************************/
@@ -8008,25 +8319,25 @@ index 0000000..a042154
 +	U32 deltaNbBits;
 +} FSE_symbolCompressionTransform; /* total 8 bytes */
 +
-+MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
++ZSTD_STATIC void FSE_initCState(FSE_CState_t *statePtr, const FSE_CTable *ct)
 +{
 +	const void *ptr = ct;
 +	const U16 *u16ptr = (const U16 *)ptr;
-+	const U32 tableLog = MEM_read16(ptr);
++	const U32 tableLog = ZSTD_read16(ptr);
 +	statePtr->value = (ptrdiff_t)1 << tableLog;
 +	statePtr->stateTable = u16ptr + 2;
 +	statePtr->symbolTT = ((const U32 *)ct + 1 + (tableLog ? (1 << (tableLog - 1)) : 1));
 +	statePtr->stateLog = tableLog;
 +}
 +
-+
 +/*! FSE_initCState2() :
 +*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
 +*   uses the smallest state value possible, saving the cost of this symbol */
-+MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
++ZSTD_STATIC void FSE_initCState2(FSE_CState_t *statePtr, const FSE_CTable *ct, U32 symbol)
 +{
 +	FSE_initCState(statePtr, ct);
-+	{	const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
++	{
++		const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform *)(statePtr->symbolTT))[symbol];
 +		const U16 *stateTable = (const U16 *)(statePtr->stateTable);
 +		U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1 << 15)) >> 16);
 +		statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
@@ -8034,7 +8345,7 @@ index 0000000..a042154
 +	}
 +}
 +
-+MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol)
++ZSTD_STATIC void FSE_encodeSymbol(BIT_CStream_t *bitC, FSE_CState_t *statePtr, U32 symbol)
 +{
 +	const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform *)(statePtr->symbolTT))[symbol];
 +	const U16 *const stateTable = (const U16 *)(statePtr->stateTable);
@@ -8043,13 +8354,12 @@ index 0000000..a042154
 +	statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
 +}
 +
-+MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
++ZSTD_STATIC void FSE_flushCState(BIT_CStream_t *bitC, const FSE_CState_t *statePtr)
 +{
 +	BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
 +	BIT_flushBits(bitC);
 +}
 +
-+
 +/* ======    Decompression    ====== */
 +
 +typedef struct {
@@ -8057,14 +8367,13 @@ index 0000000..a042154
 +	U16 fastMode;
 +} FSE_DTableHeader; /* sizeof U32 */
 +
-+typedef struct
++typedef struct {
-+{
 +	unsigned short newState;
 +	unsigned char symbol;
 +	unsigned char nbBits;
 +} FSE_decode_t; /* size == U32 */
 +
-+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
++ZSTD_STATIC void FSE_initDState(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD, const FSE_DTable *dt)
 +{
 +	const void *ptr = dt;
 +	const FSE_DTableHeader *const DTableH = (const FSE_DTableHeader *)ptr;
@@ -8073,13 +8382,13 @@ index 0000000..a042154
 +	DStatePtr->table = dt + 1;
 +}
 +
-+MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
++ZSTD_STATIC BYTE FSE_peekSymbol(const FSE_DState_t *DStatePtr)
 +{
 +	FSE_decode_t const DInfo = ((const FSE_decode_t *)(DStatePtr->table))[DStatePtr->state];
 +	return DInfo.symbol;
 +}
 +
-+MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
++ZSTD_STATIC void FSE_updateState(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD)
 +{
 +	FSE_decode_t const DInfo = ((const FSE_decode_t *)(DStatePtr->table))[DStatePtr->state];
 +	U32 const nbBits = DInfo.nbBits;
@@ -8087,7 +8396,7 @@ index 0000000..a042154
 +	DStatePtr->state = DInfo.newState + lowBits;
 +}
 +
-+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
++ZSTD_STATIC BYTE FSE_decodeSymbol(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD)
 +{
 +	FSE_decode_t const DInfo = ((const FSE_decode_t *)(DStatePtr->table))[DStatePtr->state];
 +	U32 const nbBits = DInfo.nbBits;
@@ -8100,7 +8409,7 @@ index 0000000..a042154
 +
 +/*! FSE_decodeSymbolFast() :
 +	unsafe, only works if no symbol has a probability > 50% */
-+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
++ZSTD_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t *DStatePtr, BIT_DStream_t *bitD)
 +{
 +	FSE_decode_t const DInfo = ((const FSE_decode_t *)(DStatePtr->table))[DStatePtr->state];
 +	U32 const nbBits = DInfo.nbBits;
@@ -8111,12 +8420,7 @@ index 0000000..a042154
 +	return symbol;
 +}
 +
-+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
++ZSTD_STATIC unsigned FSE_endOfDState(const FSE_DState_t *DStatePtr) { return DStatePtr->state == 0; }
-+{
-+	return DStatePtr->state == 0;
-+}
-+
-+
 +
 +#ifndef FSE_COMMONDEFS_ONLY
 +
@@ -8149,10 +8453,8 @@ index 0000000..a042154
 +#define FSE_FUNCTION_EXTENSION
 +#define FSE_DECODE_TYPE FSE_decode_t
 +
-+
 +#endif /* !FSE_COMMONDEFS_ONLY */
 +
-+
 +/* ***************************************************************
 +*  Constants
 +*****************************************************************/
@@ -8169,14 +8471,13 @@ index 0000000..a042154
 +
 +#define FSE_TABLESTEP(tableSize) ((tableSize >> 1) + (tableSize >> 3) + 3)
 +
-+
 +#endif /* FSE_H */
 diff --git a/lib/zstd/fse_compress.c b/lib/zstd/fse_compress.c
 new file mode 100644
-index 0000000..d13f00d
+index 0000000..6bb810f
 --- /dev/null
 +++ b/lib/zstd/fse_compress.c
-@@ -0,0 +1,779 @@
+@@ -0,0 +1,861 @@
 +/*
 + * FSE : Finite State Entropy encoder
 + * Copyright (C) 2013-2015, Yann Collet.
@@ -8221,21 +8522,21 @@ index 0000000..d13f00d
 +****************************************************************/
 +#define FORCE_INLINE static __always_inline
 +
-+
 +/* **************************************************************
 +*  Includes
 +****************************************************************/
-+#include <linux/compiler.h>
-+#include <linux/string.h>     /* memcpy, memset */
 +#include "bitstream.h"
 +#include "fse.h"
-+
++#include <linux/compiler.h>
++#include <linux/string.h> /* memcpy, memset */
 +
 +/* **************************************************************
 +*  Error Management
 +****************************************************************/
-+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
++#define FSE_STATIC_ASSERT(c)                                   \
-+
++	{                                                      \
++		enum { FSE_static_assert = 1 / (int)(!!(c)) }; \
++	} /* use only *after* variable declarations */
 +
 +/* **************************************************************
 +*  Templates
@@ -8259,7 +8560,6 @@ index 0000000..d13f00d
 +#define FSE_FUNCTION_NAME(X, Y) FSE_CAT(X, Y)
 +#define FSE_TYPE_NAME(X, Y) FSE_CAT(X, Y)
 +
-+
 +/* Function templates */
 +
 +/* FSE_buildCTable_wksp() :
@@ -8282,7 +8582,8 @@ index 0000000..d13f00d
 +	U32 highThreshold = tableSize - 1;
 +
 +	/* CTable header */
-+	if (((size_t)1 << tableLog) * sizeof(FSE_FUNCTION_TYPE) > wkspSize) return ERROR(tableLog_tooLarge);
++	if (((size_t)1 << tableLog) * sizeof(FSE_FUNCTION_TYPE) > wkspSize)
++		return ERROR(tableLog_tooLarge);
 +	tableU16[-2] = (U16)tableLog;
 +	tableU16[-1] = (U16)maxSymbolValue;
 +
@@ -8290,7 +8591,8 @@ index 0000000..d13f00d
 +	*  http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
 +
 +	/* symbol start positions */
-+	{	U32 u;
++	{
++		U32 u;
 +		cumul[0] = 0;
 +		for (u = 1; u <= maxSymbolValue + 1; u++) {
 +			if (normalizedCounter[u - 1] == -1) { /* Low proba symbol */
@@ -8298,36 +8600,44 @@ index 0000000..d13f00d
 +				tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u - 1);
 +			} else {
 +				cumul[u] = cumul[u - 1] + normalizedCounter[u - 1];
-+		}   }
++			}
++		}
 +		cumul[maxSymbolValue + 1] = tableSize + 1;
 +	}
 +
 +	/* Spread symbols */
-+	{	U32 position = 0;
++	{
++		U32 position = 0;
 +		U32 symbol;
 +		for (symbol = 0; symbol <= maxSymbolValue; symbol++) {
 +			int nbOccurences;
 +			for (nbOccurences = 0; nbOccurences < normalizedCounter[symbol]; nbOccurences++) {
 +				tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
 +				position = (position + step) & tableMask;
-+				while (position > highThreshold) position = (position + step) & tableMask;   /* Low proba area */
++				while (position > highThreshold)
-+		}   }
++					position = (position + step) & tableMask; /* Low proba area */
++			}
++		}
 +
-+		if (position!=0) return ERROR(GENERIC);   /* Must have gone through all positions */
++		if (position != 0)
++			return ERROR(GENERIC); /* Must have gone through all positions */
 +	}
 +
 +	/* Build table */
-+	{	U32 u; for (u=0; u<tableSize; u++) {
++	{
++		U32 u;
++		for (u = 0; u < tableSize; u++) {
 +			FSE_FUNCTION_TYPE s = tableSymbol[u];	/* note : static analyzer may not understand tableSymbol is properly initialized */
 +			tableU16[cumul[s]++] = (U16)(tableSize + u); /* TableU16 : sorted by symbol order; gives next state value */
-+	}   }
++		}
++	}
 +
 +	/* Build Symbol Transformation Table */
-+	{	unsigned total = 0;
++	{
++		unsigned total = 0;
 +		unsigned s;
 +		for (s = 0; s <= maxSymbolValue; s++) {
-+			switch (normalizedCounter[s])
++			switch (normalizedCounter[s]) {
-+			{
 +			case 0: break;
 +
 +			case -1:
@@ -8336,19 +8646,20 @@ index 0000000..d13f00d
 +				symbolTT[s].deltaFindState = total - 1;
 +				total++;
 +				break;
-+			default :
++			default: {
-+				{
 +				U32 const maxBitsOut = tableLog - BIT_highbit32(normalizedCounter[s] - 1);
 +				U32 const minStatePlus = normalizedCounter[s] << maxBitsOut;
 +				symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
 +				symbolTT[s].deltaFindState = total - normalizedCounter[s];
 +				total += normalizedCounter[s];
-+	}   }   }   }
++			}
++			}
++		}
++	}
 +
 +	return 0;
 +}
 +
-+
 +#ifndef FSE_COMMONDEFS_ONLY
 +
 +/*-**************************************************************
@@ -8360,8 +8671,7 @@ index 0000000..d13f00d
 +	return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND; /* maxSymbolValue==0 ? use default */
 +}
 +
-+static size_t FSE_writeNCount_generic (void* header, size_t headerBufferSize,
++static size_t FSE_writeNCount_generic(void *header, size_t headerBufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
-+									   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
 +				      unsigned writeIsSafe)
 +{
 +	BYTE *const ostart = (BYTE *)header;
@@ -8390,11 +8700,13 @@ index 0000000..d13f00d
 +	while (remaining > 1) { /* stops at 1 */
 +		if (previous0) {
 +			unsigned start = charnum;
-+			while (!normalizedCounter[charnum]) charnum++;
++			while (!normalizedCounter[charnum])
++				charnum++;
 +			while (charnum >= start + 24) {
 +				start += 24;
 +				bitStream += 0xFFFFU << bitCount;
-+				if ((!writeIsSafe) && (out > oend-2)) return ERROR(dstSize_tooSmall);   /* Buffer overflow */
++				if ((!writeIsSafe) && (out > oend - 2))
++					return ERROR(dstSize_tooSmall); /* Buffer overflow */
 +				out[0] = (BYTE)bitStream;
 +				out[1] = (BYTE)(bitStream >> 8);
 +				out += 2;
@@ -8408,50 +8720,61 @@ index 0000000..d13f00d
 +			bitStream += (charnum - start) << bitCount;
 +			bitCount += 2;
 +			if (bitCount > 16) {
-+				if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall);   /* Buffer overflow */
++				if ((!writeIsSafe) && (out > oend - 2))
++					return ERROR(dstSize_tooSmall); /* Buffer overflow */
 +				out[0] = (BYTE)bitStream;
 +				out[1] = (BYTE)(bitStream >> 8);
 +				out += 2;
 +				bitStream >>= 16;
 +				bitCount -= 16;
-+		}   }
++			}
-+		{	int count = normalizedCounter[charnum++];
++		}
++		{
++			int count = normalizedCounter[charnum++];
 +			int const max = (2 * threshold - 1) - remaining;
 +			remaining -= count < 0 ? -count : count;
 +			count++; /* +1 for extra accuracy */
-+			if (count>=threshold) count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
++			if (count >= threshold)
++				count += max; /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
 +			bitStream += count << bitCount;
 +			bitCount += nbBits;
 +			bitCount -= (count < max);
 +			previous0 = (count == 1);
-+			if (remaining<1) return ERROR(GENERIC);
++			if (remaining < 1)
-+			while (remaining<threshold) nbBits--, threshold>>=1;
++				return ERROR(GENERIC);
++			while (remaining < threshold)
++				nbBits--, threshold >>= 1;
 +		}
 +		if (bitCount > 16) {
-+			if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall);   /* Buffer overflow */
++			if ((!writeIsSafe) && (out > oend - 2))
++				return ERROR(dstSize_tooSmall); /* Buffer overflow */
 +			out[0] = (BYTE)bitStream;
 +			out[1] = (BYTE)(bitStream >> 8);
 +			out += 2;
 +			bitStream >>= 16;
 +			bitCount -= 16;
-+	}   }
++		}
++	}
 +
 +	/* flush remaining bitStream */
-+	if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall);   /* Buffer overflow */
++	if ((!writeIsSafe) && (out > oend - 2))
++		return ERROR(dstSize_tooSmall); /* Buffer overflow */
 +	out[0] = (BYTE)bitStream;
 +	out[1] = (BYTE)(bitStream >> 8);
 +	out += (bitCount + 7) / 8;
 +
-+	if (charnum > maxSymbolValue + 1) return ERROR(GENERIC);
++	if (charnum > maxSymbolValue + 1)
++		return ERROR(GENERIC);
 +
 +	return (out - ostart);
 +}
 +
-+
 +size_t FSE_writeNCount(void *buffer, size_t bufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
 +{
-+	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
++	if (tableLog > FSE_MAX_TABLELOG)
-+	if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */
++		return ERROR(tableLog_tooLarge); /* Unsupported */
++	if (tableLog < FSE_MIN_TABLELOG)
++		return ERROR(GENERIC); /* Unsupported */
 +
 +	if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
 +		return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
@@ -8459,8 +8782,6 @@ index 0000000..d13f00d
 +	return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1);
 +}
 +
-+
-+
 +/*-**************************************************************
 +*  Counting histogram
 +****************************************************************/
@@ -8471,8 +8792,7 @@ index 0000000..d13f00d
 +	For this reason, prefer using a table `count` with 256 elements.
 +	@return : count of most numerous element
 +*/
-+size_t FSE_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
++size_t FSE_count_simple(unsigned *count, unsigned *maxSymbolValuePtr, const void *src, size_t srcSize)
-+						const void* src, size_t srcSize)
 +{
 +	const BYTE *ip = (const BYTE *)src;
 +	const BYTE *const end = ip + srcSize;
@@ -8480,26 +8800,33 @@ index 0000000..d13f00d
 +	unsigned max = 0;
 +
 +	memset(count, 0, (maxSymbolValue + 1) * sizeof(*count));
-+	if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }
++	if (srcSize == 0) {
++		*maxSymbolValuePtr = 0;
++		return 0;
++	}
 +
-+	while (ip<end) count[*ip++]++;
++	while (ip < end)
++		count[*ip++]++;
 +
-+	while (!count[maxSymbolValue]) maxSymbolValue--;
++	while (!count[maxSymbolValue])
++		maxSymbolValue--;
 +	*maxSymbolValuePtr = maxSymbolValue;
 +
-+	{ U32 s; for (s=0; s<=maxSymbolValue; s++) if (count[s] > max) max = count[s]; }
++	{
++		U32 s;
++		for (s = 0; s <= maxSymbolValue; s++)
++			if (count[s] > max)
++				max = count[s];
++	}
 +
 +	return (size_t)max;
 +}
 +
-+
 +/* FSE_count_parallel_wksp() :
 + * Same as FSE_count_parallel(), but using an externally provided scratch buffer.
 + * `workSpace` size must be a minimum of `1024 * sizeof(unsigned)`` */
-+static size_t FSE_count_parallel_wksp(
++static size_t FSE_count_parallel_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned checkMax,
-+								unsigned* count, unsigned* maxSymbolValuePtr,
++				      unsigned *const workSpace)
-+								const void* source, size_t sourceSize,
-+								unsigned checkMax, unsigned* const workSpace)
 +{
 +	const BYTE *ip = (const BYTE *)source;
 +	const BYTE *const iend = ip + sourceSize;
@@ -8518,27 +8845,38 @@ index 0000000..d13f00d
 +		*maxSymbolValuePtr = 0;
 +		return 0;
 +	}
-+	if (!maxSymbolValue) maxSymbolValue = 255;            /* 0 == default */
++	if (!maxSymbolValue)
++		maxSymbolValue = 255; /* 0 == default */
 +
 +	/* by stripes of 16 bytes */
-+	{	U32 cached = MEM_read32(ip); ip += 4;
++	{
++		U32 cached = ZSTD_read32(ip);
++		ip += 4;
 +		while (ip < iend - 15) {
-+			U32 c = cached; cached = MEM_read32(ip); ip += 4;
++			U32 c = cached;
++			cached = ZSTD_read32(ip);
++			ip += 4;
 +			Counting1[(BYTE)c]++;
 +			Counting2[(BYTE)(c >> 8)]++;
 +			Counting3[(BYTE)(c >> 16)]++;
 +			Counting4[c >> 24]++;
-+			c = cached; cached = MEM_read32(ip); ip += 4;
++			c = cached;
++			cached = ZSTD_read32(ip);
++			ip += 4;
 +			Counting1[(BYTE)c]++;
 +			Counting2[(BYTE)(c >> 8)]++;
 +			Counting3[(BYTE)(c >> 16)]++;
 +			Counting4[c >> 24]++;
-+			c = cached; cached = MEM_read32(ip); ip += 4;
++			c = cached;
++			cached = ZSTD_read32(ip);
++			ip += 4;
 +			Counting1[(BYTE)c]++;
 +			Counting2[(BYTE)(c >> 8)]++;
 +			Counting3[(BYTE)(c >> 16)]++;
 +			Counting4[c >> 24]++;
-+			c = cached; cached = MEM_read32(ip); ip += 4;
++			c = cached;
++			cached = ZSTD_read32(ip);
++			ip += 4;
 +			Counting1[(BYTE)c]++;
 +			Counting2[(BYTE)(c >> 8)]++;
 +			Counting3[(BYTE)(c >> 16)]++;
@@ -8548,20 +8886,29 @@ index 0000000..d13f00d
 +	}
 +
 +	/* finish last symbols */
-+	while (ip<iend) Counting1[*ip++]++;
++	while (ip < iend)
++		Counting1[*ip++]++;
 +
 +	if (checkMax) { /* verify stats will fit into destination table */
-+		U32 s; for (s=255; s>maxSymbolValue; s--) {
++		U32 s;
++		for (s = 255; s > maxSymbolValue; s--) {
 +			Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
-+			if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
++			if (Counting1[s])
-+	}   }
++				return ERROR(maxSymbolValue_tooSmall);
++		}
++	}
 +
-+	{	U32 s; for (s=0; s<=maxSymbolValue; s++) {
++	{
++		U32 s;
++		for (s = 0; s <= maxSymbolValue; s++) {
 +			count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
-+			if (count[s] > max) max = count[s];
++			if (count[s] > max)
-+	}   }
++				max = count[s];
++		}
++	}
 +
-+	while (!count[maxSymbolValue]) maxSymbolValue--;
++	while (!count[maxSymbolValue])
++		maxSymbolValue--;
 +	*maxSymbolValuePtr = maxSymbolValue;
 +	return (size_t)max;
 +}
@@ -8569,18 +8916,17 @@ index 0000000..d13f00d
 +/* FSE_countFast_wksp() :
 + * Same as FSE_countFast(), but using an externally provided scratch buffer.
 + * `workSpace` size must be table of >= `1024` unsigned */
-+size_t FSE_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
++size_t FSE_countFast_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned *workSpace)
-+					 const void* source, size_t sourceSize, unsigned* workSpace)
 +{
-+	if (sourceSize < 1500) return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize);
++	if (sourceSize < 1500)
++		return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize);
 +	return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 0, workSpace);
 +}
 +
 +/* FSE_count_wksp() :
 + * Same as FSE_count(), but using an externally provided scratch buffer.
 + * `workSpace` size must be table of >= `1024` unsigned */
-+size_t FSE_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
++size_t FSE_count_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned *workSpace)
-+				 const void* source, size_t sourceSize, unsigned* workSpace)
 +{
 +	if (*maxSymbolValuePtr < 255)
 +		return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 1, workSpace);
@@ -8588,7 +8934,6 @@ index 0000000..d13f00d
 +	return FSE_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace);
 +}
 +
-+
 +/*-**************************************************************
 +*  FSE Compression Code
 +****************************************************************/
@@ -8602,7 +8947,8 @@ index 0000000..d13f00d
 +*/
 +size_t FSE_sizeof_CTable(unsigned maxSymbolValue, unsigned tableLog)
 +{
-+	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
++	if (tableLog > FSE_MAX_TABLELOG)
++		return ERROR(tableLog_tooLarge);
 +	return FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue) * sizeof(U32);
 +}
 +
@@ -8620,11 +8966,16 @@ index 0000000..d13f00d
 +	U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
 +	U32 tableLog = maxTableLog;
 +	U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
-+	if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
++	if (tableLog == 0)
-+	if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */
++		tableLog = FSE_DEFAULT_TABLELOG;
-+	if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */
++	if (maxBitsSrc < tableLog)
-+	if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
++		tableLog = maxBitsSrc; /* Accuracy can be reduced */
-+	if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
++	if (minBits > tableLog)
++		tableLog = minBits; /* Need a minimum to safely represent all symbol values */
++	if (tableLog < FSE_MIN_TABLELOG)
++		tableLog = FSE_MIN_TABLELOG;
++	if (tableLog > FSE_MAX_TABLELOG)
++		tableLog = FSE_MAX_TABLELOG;
 +	return tableLog;
 +}
 +
@@ -8633,7 +8984,6 @@ index 0000000..d13f00d
 +	return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
 +}
 +
-+
 +/* Secondary normalization method.
 +   To be used when primary method fails. */
 +
@@ -8679,7 +9029,8 @@ index 0000000..d13f00d
 +				distributed++;
 +				total -= count[s];
 +				continue;
-+		}   }
++			}
++		}
 +		ToDistribute = (1 << tableLog) - distributed;
 +	}
 +
@@ -8689,7 +9040,8 @@ index 0000000..d13f00d
 +		   find max, then give all remaining points to max */
 +		U32 maxV = 0, maxC = 0;
 +		for (s = 0; s <= maxSymbolValue; s++)
-+			if (count[s] > maxC) maxV=s, maxC=count[s];
++			if (count[s] > maxC)
++				maxV = s, maxC = count[s];
 +		norm[maxV] += (short)ToDistribute;
 +		return 0;
 +	}
@@ -8697,11 +9049,13 @@ index 0000000..d13f00d
 +	if (total == 0) {
 +		/* all of the symbols were low enough for the lowOne or lowThreshold */
 +		for (s = 0; ToDistribute > 0; s = (s + 1) % (maxSymbolValue + 1))
-+			if (norm[s] > 0) ToDistribute--, norm[s]++;
++			if (norm[s] > 0)
++				ToDistribute--, norm[s]++;
 +		return 0;
 +	}
 +
-+	{	U64 const vStepLog = 62 - tableLog;
++	{
++		U64 const vStepLog = 62 - tableLog;
 +		U64 const mid = (1ULL << (vStepLog - 1)) - 1;
 +		U64 const rStep = ((((U64)1 << vStepLog) * ToDistribute) + mid) / total; /* scale on remaining */
 +		U64 tmpTotal = mid;
@@ -8715,23 +9069,27 @@ index 0000000..d13f00d
 +					return ERROR(GENERIC);
 +				norm[s] = (short)weight;
 +				tmpTotal = end;
-+	}   }   }
++			}
++		}
++	}
 +
 +	return 0;
 +}
 +
-+
++size_t FSE_normalizeCount(short *normalizedCounter, unsigned tableLog, const unsigned *count, size_t total, unsigned maxSymbolValue)
-+size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
-+						   const unsigned* count, size_t total,
-+						   unsigned maxSymbolValue)
 +{
 +	/* Sanity checks */
-+	if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
++	if (tableLog == 0)
-+	if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */
++		tableLog = FSE_DEFAULT_TABLELOG;
-+	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */
++	if (tableLog < FSE_MIN_TABLELOG)
-+	if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */
++		return ERROR(GENERIC); /* Unsupported size */
++	if (tableLog > FSE_MAX_TABLELOG)
++		return ERROR(tableLog_tooLarge); /* Unsupported size */
++	if (tableLog < FSE_minTableLog(total, maxSymbolValue))
++		return ERROR(GENERIC); /* Too small tableLog, compression potentially impossible */
 +
-+	{	U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
++	{
++		U32 const rtbTable[] = {0, 473195, 504333, 520860, 550000, 700000, 750000, 830000};
 +		U64 const scale = 62 - tableLog;
 +		U64 const step = ((U64)1 << 62) / total; /* <== here, one division ! */
 +		U64 const vStep = 1ULL << (scale - 20);
@@ -8742,8 +9100,12 @@ index 0000000..d13f00d
 +		U32 lowThreshold = (U32)(total >> tableLog);
 +
 +		for (s = 0; s <= maxSymbolValue; s++) {
-+			if (count[s] == total) return 0;   /* rle special case */
++			if (count[s] == total)
-+			if (count[s] == 0) { normalizedCounter[s]=0; continue; }
++				return 0; /* rle special case */
++			if (count[s] == 0) {
++				normalizedCounter[s] = 0;
++				continue;
++			}
 +			if (count[s] <= lowThreshold) {
 +				normalizedCounter[s] = -1;
 +				stillToDistribute--;
@@ -8753,22 +9115,24 @@ index 0000000..d13f00d
 +					U64 restToBeat = vStep * rtbTable[proba];
 +					proba += (count[s] * step) - ((U64)proba << scale) > restToBeat;
 +				}
-+				if (proba > largestP) largestP=proba, largest=s;
++				if (proba > largestP)
++					largestP = proba, largest = s;
 +				normalizedCounter[s] = proba;
 +				stillToDistribute -= proba;
-+		}   }
++			}
++		}
 +		if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
 +			/* corner case, need another normalization method */
 +			size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue);
-+			if (FSE_isError(errorCode)) return errorCode;
++			if (FSE_isError(errorCode))
-+		}
++				return errorCode;
-+		else normalizedCounter[largest] += (short)stillToDistribute;
++		} else
++			normalizedCounter[largest] += (short)stillToDistribute;
 +	}
 +
 +	return tableLog;
 +}
 +
-+
 +/* fake FSE_CTable, for raw (uncompressed) input */
 +size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits)
 +{
@@ -8782,7 +9146,8 @@ index 0000000..d13f00d
 +	unsigned s;
 +
 +	/* Sanity checks */
-+	if (nbBits < 1) return ERROR(GENERIC);             /* min size */
++	if (nbBits < 1)
++		return ERROR(GENERIC); /* min size */
 +
 +	/* header */
 +	tableU16[-2] = (U16)nbBits;
@@ -8793,11 +9158,13 @@ index 0000000..d13f00d
 +		tableU16[s] = (U16)(tableSize + s);
 +
 +	/* Build Symbol Transformation Table */
-+	{	const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
++	{
++		const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
 +		for (s = 0; s <= maxSymbolValue; s++) {
 +			symbolTT[s].deltaNbBits = deltaNbBits;
 +			symbolTT[s].deltaFindState = s - 1;
-+	}   }
++		}
++	}
 +
 +	return 0;
 +}
@@ -8825,10 +9192,7 @@ index 0000000..d13f00d
 +	return 0;
 +}
 +
-+
++static size_t FSE_compress_usingCTable_generic(void *dst, size_t dstSize, const void *src, size_t srcSize, const FSE_CTable *ct, const unsigned fast)
-+static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,
-+						   const void* src, size_t srcSize,
-+						   const FSE_CTable* ct, const unsigned fast)
 +{
 +	const BYTE *const istart = (const BYTE *)src;
 +	const BYTE *const iend = istart + srcSize;
@@ -8838,9 +9202,13 @@ index 0000000..d13f00d
 +	FSE_CState_t CState1, CState2;
 +
 +	/* init */
-+	if (srcSize <= 2) return 0;
++	if (srcSize <= 2)
-+	{ size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
++		return 0;
-+	  if (FSE_isError(initError)) return 0; /* not enough space available to write a bitstream */ }
++	{
++		size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
++		if (FSE_isError(initError))
++			return 0; /* not enough space available to write a bitstream */
++	}
 +
 +#define FSE_FLUSHBITS(s) (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
 +
@@ -8885,9 +9253,7 @@ index 0000000..d13f00d
 +	return BIT_closeCStream(&bitC);
 +}
 +
-+size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
++size_t FSE_compress_usingCTable(void *dst, size_t dstSize, const void *src, size_t srcSize, const FSE_CTable *ct)
-+						   const void* src, size_t srcSize,
-+						   const FSE_CTable* ct)
 +{
 +	unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));
 +
@@ -8897,17 +9263,23 @@ index 0000000..d13f00d
 +		return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
 +}
 +
-+
 +size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
 +
-+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return f
++#define CHECK_V_F(e, f)     \
-+#define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
++	size_t const e = f; \
++	if (ERR_isError(e)) \
++	return f
++#define CHECK_F(f)                        \
++	{                                 \
++		CHECK_V_F(_var_err__, f); \
++	}
 +
 +/* FSE_compress_wksp() :
 + * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
 + * `wkspSize` size must be `(1<<tableLog)`.
 + */
-+size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
++size_t FSE_compress_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
++			 size_t wkspSize)
 +{
 +	BYTE *const ostart = (BYTE *)dst;
 +	BYTE *op = ostart;
@@ -8921,47 +9293,58 @@ index 0000000..d13f00d
 +	size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable));
 +
 +	/* init conditions */
-+	if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge);
++	if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue))
-+	if (srcSize <= 1) return 0;  /* Not compressible */
++		return ERROR(tableLog_tooLarge);
-+	if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
++	if (srcSize <= 1)
-+	if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
++		return 0; /* Not compressible */
++	if (!maxSymbolValue)
++		maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
++	if (!tableLog)
++		tableLog = FSE_DEFAULT_TABLELOG;
 +
 +	/* Scan input and build symbol stats */
-+	{	CHECK_V_F(maxCount, FSE_count_wksp(count, &maxSymbolValue, src, srcSize, (unsigned*)scratchBuffer) );
++	{
-+		if (maxCount == srcSize) return 1;   /* only a single symbol in src : rle */
++		CHECK_V_F(maxCount, FSE_count_wksp(count, &maxSymbolValue, src, srcSize, (unsigned *)scratchBuffer));
-+		if (maxCount == 1) return 0;         /* each symbol present maximum once => not compressible */
++		if (maxCount == srcSize)
-+		if (maxCount < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */
++			return 1; /* only a single symbol in src : rle */
++		if (maxCount == 1)
++			return 0; /* each symbol present maximum once => not compressible */
++		if (maxCount < (srcSize >> 7))
++			return 0; /* Heuristic : not compressible enough */
 +	}
 +
 +	tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
 +	CHECK_F(FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue));
 +
 +	/* Write table description header */
-+	{	CHECK_V_F(nc_err, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
++	{
++		CHECK_V_F(nc_err, FSE_writeNCount(op, oend - op, norm, maxSymbolValue, tableLog));
 +		op += nc_err;
 +	}
 +
 +	/* Compress */
 +	CHECK_F(FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, scratchBufferSize));
-+	{	CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable) );
++	{
-+		if (cSize == 0) return 0;   /* not enough space for compressed data */
++		CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable));
++		if (cSize == 0)
++			return 0; /* not enough space for compressed data */
 +		op += cSize;
 +	}
 +
 +	/* check compressibility */
-+	if ( (size_t)(op-ostart) >= srcSize-1 ) return 0;
++	if ((size_t)(op - ostart) >= srcSize - 1)
++		return 0;
 +
 +	return op - ostart;
 +}
 +
-+
 +#endif /* FSE_COMMONDEFS_ONLY */
 diff --git a/lib/zstd/fse_decompress.c b/lib/zstd/fse_decompress.c
 new file mode 100644
-index 0000000..6d2c367
+index 0000000..245570a
 --- /dev/null
 +++ b/lib/zstd/fse_decompress.c
-@@ -0,0 +1,297 @@
+@@ -0,0 +1,317 @@
 +/*
 + * FSE : Finite State Entropy decoder
 + * Copyright (C) 2013-2015, Yann Collet.
@@ -9001,31 +9384,35 @@ index 0000000..6d2c367
 + * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
 + */
 +
-+
 +/* **************************************************************
 +*  Compiler specifics
 +****************************************************************/
 +#define FORCE_INLINE static __always_inline
 +
-+
 +/* **************************************************************
 +*  Includes
 +****************************************************************/
-+#include <linux/compiler.h>
-+#include <linux/string.h>     /* memcpy, memset */
 +#include "bitstream.h"
 +#include "fse.h"
-+
++#include <linux/compiler.h>
++#include <linux/string.h> /* memcpy, memset */
 +
 +/* **************************************************************
 +*  Error Management
 +****************************************************************/
 +#define FSE_isError ERR_isError
-+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
++#define FSE_STATIC_ASSERT(c)                                   \
++	{                                                      \
++		enum { FSE_static_assert = 1 / (int)(!!(c)) }; \
++	} /* use only *after* variable declarations */
 +
 +/* check and forward error code */
-+#define CHECK_F(f) { size_t const e = f; if (FSE_isError(e)) return e; }
++#define CHECK_F(f)                  \
-+
++	{                           \
++		size_t const e = f; \
++		if (FSE_isError(e)) \
++			return e;   \
++	}
 +
 +/* **************************************************************
 +*  Templates
@@ -9049,7 +9436,6 @@ index 0000000..6d2c367
 +#define FSE_FUNCTION_NAME(X, Y) FSE_CAT(X, Y)
 +#define FSE_TYPE_NAME(X, Y) FSE_CAT(X, Y)
 +
-+
 +/* Function templates */
 +
 +size_t FSE_buildDTable(FSE_DTable *dt, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
@@ -9063,28 +9449,36 @@ index 0000000..6d2c367
 +	U32 highThreshold = tableSize - 1;
 +
 +	/* Sanity Checks */
-+	if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
++	if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE)
-+	if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
++		return ERROR(maxSymbolValue_tooLarge);
++	if (tableLog > FSE_MAX_TABLELOG)
++		return ERROR(tableLog_tooLarge);
 +
 +	/* Init, lay down lowprob symbols */
-+	{	FSE_DTableHeader DTableH;
++	{
++		FSE_DTableHeader DTableH;
 +		DTableH.tableLog = (U16)tableLog;
 +		DTableH.fastMode = 1;
-+		{	S16 const largeLimit= (S16)(1 << (tableLog-1));
++		{
++			S16 const largeLimit = (S16)(1 << (tableLog - 1));
 +			U32 s;
 +			for (s = 0; s < maxSV1; s++) {
 +				if (normalizedCounter[s] == -1) {
 +					tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
 +					symbolNext[s] = 1;
 +				} else {
-+					if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
++					if (normalizedCounter[s] >= largeLimit)
++						DTableH.fastMode = 0;
 +					symbolNext[s] = normalizedCounter[s];
-+		}   }   }
++				}
++			}
++		}
 +		memcpy(dt, &DTableH, sizeof(DTableH));
 +	}
 +
 +	/* Spread symbols */
-+	{	U32 const tableMask = tableSize-1;
++	{
++		U32 const tableMask = tableSize - 1;
 +		U32 const step = FSE_TABLESTEP(tableSize);
 +		U32 s, position = 0;
 +		for (s = 0; s < maxSV1; s++) {
@@ -9092,24 +9486,28 @@ index 0000000..6d2c367
 +			for (i = 0; i < normalizedCounter[s]; i++) {
 +				tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
 +				position = (position + step) & tableMask;
-+				while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
++				while (position > highThreshold)
-+		}   }
++					position = (position + step) & tableMask; /* lowprob area */
-+		if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
++			}
++		}
++		if (position != 0)
++			return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
 +	}
 +
 +	/* Build Decoding table */
-+	{	U32 u;
++	{
++		U32 u;
 +		for (u = 0; u < tableSize; u++) {
 +			FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
 +			U16 nextState = symbolNext[symbol]++;
 +			tableDecode[u].nbBits = (BYTE)(tableLog - BIT_highbit32((U32)nextState));
 +			tableDecode[u].newState = (U16)((nextState << tableDecode[u].nbBits) - tableSize);
-+	}   }
++		}
++	}
 +
 +	return 0;
 +}
 +
-+
 +#ifndef FSE_COMMONDEFS_ONLY
 +
 +/*-*******************************************************
@@ -9132,7 +9530,6 @@ index 0000000..6d2c367
 +	return 0;
 +}
 +
-+
 +size_t FSE_buildDTable_raw(FSE_DTable *dt, unsigned nbBits)
 +{
 +	void *ptr = dt;
@@ -9145,7 +9542,8 @@ index 0000000..6d2c367
 +	unsigned s;
 +
 +	/* Sanity checks */
-+	if (nbBits < 1) return ERROR(GENERIC);         /* min size */
++	if (nbBits < 1)
++		return ERROR(GENERIC); /* min size */
 +
 +	/* Build Decoding Table */
 +	DTableH->tableLog = (U16)nbBits;
@@ -9159,10 +9557,8 @@ index 0000000..6d2c367
 +	return 0;
 +}
 +
-+FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
++FORCE_INLINE size_t FSE_decompress_usingDTable_generic(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const FSE_DTable *dt,
-+		  void* dst, size_t maxDstSize,
++						       const unsigned fast)
-+	const void* cSrc, size_t cSrcSize,
-+	const FSE_DTable* dt, const unsigned fast)
 +{
 +	BYTE *const ostart = (BYTE *)dst;
 +	BYTE *op = ostart;
@@ -9191,7 +9587,12 @@ index 0000000..6d2c367
 +		op[1] = FSE_GETSYMBOL(&state2);
 +
 +		if (FSE_MAX_TABLELOG * 4 + 7 > sizeof(bitD.bitContainer) * 8) /* This test must be static */
-+			{ if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
++		{
++			if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) {
++				op += 2;
++				break;
++			}
++		}
 +
 +		op[2] = FSE_GETSYMBOL(&state1);
 +
@@ -9204,38 +9605,38 @@ index 0000000..6d2c367
 +	/* tail */
 +	/* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
 +	while (1) {
-+		if (op>(omax-2)) return ERROR(dstSize_tooSmall);
++		if (op > (omax - 2))
++			return ERROR(dstSize_tooSmall);
 +		*op++ = FSE_GETSYMBOL(&state1);
 +		if (BIT_reloadDStream(&bitD) == BIT_DStream_overflow) {
 +			*op++ = FSE_GETSYMBOL(&state2);
 +			break;
 +		}
 +
-+		if (op>(omax-2)) return ERROR(dstSize_tooSmall);
++		if (op > (omax - 2))
++			return ERROR(dstSize_tooSmall);
 +		*op++ = FSE_GETSYMBOL(&state2);
 +		if (BIT_reloadDStream(&bitD) == BIT_DStream_overflow) {
 +			*op++ = FSE_GETSYMBOL(&state1);
 +			break;
-+	}   }
++		}
++	}
 +
 +	return op - ostart;
 +}
 +
-+
++size_t FSE_decompress_usingDTable(void *dst, size_t originalSize, const void *cSrc, size_t cSrcSize, const FSE_DTable *dt)
-+size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-+							const void* cSrc, size_t cSrcSize,
-+							const FSE_DTable* dt)
 +{
 +	const void *ptr = dt;
 +	const FSE_DTableHeader *DTableH = (const FSE_DTableHeader *)ptr;
 +	const U32 fastMode = DTableH->fastMode;
 +
 +	/* select fast mode (static) */
-+	if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
++	if (fastMode)
++		return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
 +	return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
 +}
 +
-+
 +size_t FSE_decompress_wksp(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, FSE_DTable *workSpace, unsigned maxLog)
 +{
 +	const BYTE *const istart = (const BYTE *)cSrc;
@@ -9246,9 +9647,12 @@ index 0000000..6d2c367
 +
 +	/* normal FSE decoding mode */
 +	size_t const NCountLength = FSE_readNCount(counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-+	if (FSE_isError(NCountLength)) return NCountLength;
++	if (FSE_isError(NCountLength))
-+	//if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size; supposed to be already checked in NCountLength, only remaining case : NCountLength==cSrcSize */
++		return NCountLength;
-+	if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
++	// if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size; supposed to be already checked in NCountLength, only remaining
++	// case : NCountLength==cSrcSize */
++	if (tableLog > maxLog)
++		return ERROR(tableLog_tooLarge);
 +	ip += NCountLength;
 +	cSrcSize -= NCountLength;
 +
@@ -9257,14 +9661,13 @@ index 0000000..6d2c367
 +	return FSE_decompress_usingDTable(dst, dstCapacity, ip, cSrcSize, workSpace); /* always return, even if it is an error code */
 +}
 +
-+
 +#endif /* FSE_COMMONDEFS_ONLY */
 diff --git a/lib/zstd/huf.h b/lib/zstd/huf.h
 new file mode 100644
-index 0000000..b157675
+index 0000000..56abe2f
 --- /dev/null
 +++ b/lib/zstd/huf.h
-@@ -0,0 +1,209 @@
+@@ -0,0 +1,203 @@
 +/*
 + * Huffman coder, part of New Generation Entropy library
 + * header file
@@ -9307,11 +9710,9 @@ index 0000000..b157675
 +#ifndef HUF_H_298734234
 +#define HUF_H_298734234
 +
-+
 +/* *** Dependencies *** */
 +#include <linux/types.h> /* size_t */
 +
-+
 +/* ***   Tool functions *** */
 +#define HUF_BLOCKSIZE_MAX (128 * 1024) /**< maximum input size for a single block compressed with HUF_compress */
 +size_t HUF_compressBound(size_t size); /**< maximum compressed size (worst case) */
@@ -9319,19 +9720,16 @@ index 0000000..b157675
 +/* Error Management */
 +unsigned HUF_isError(size_t code); /**< tells if a return value is an error code */
 +
-+
 +/* ***   Advanced function   *** */
 +
 +/** HUF_compress4X_wksp() :
 +*   Same as HUF_compress2(), but uses externally allocated `workSpace`, which must be a table of >= 1024 unsigned */
-+size_t HUF_compress4X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
++size_t HUF_compress4X_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
-+
++			   size_t wkspSize); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
-+
 +
 +/* *** Dependencies *** */
 +#include "mem.h" /* U32 */
 +
-+
 +/* *** Constants *** */
 +#define HUF_TABLELOG_MAX 12     /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
 +#define HUF_TABLELOG_DEFAULT 11 /* tableLog by default, when not specified */
@@ -9342,7 +9740,6 @@ index 0000000..b157675
 +#error "HUF_TABLELOG_MAX is too large !"
 +#endif
 +
-+
 +/* ****************************************
 +*  Static allocation
 +******************************************/
@@ -9360,25 +9757,22 @@ index 0000000..b157675
 +/* static allocation of HUF's DTable */
 +typedef U32 HUF_DTable;
 +#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1 << (maxTableLog)))
-+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
++#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = {((U32)((maxTableLog)-1) * 0x01000001)}
-+		HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
++#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = {((U32)(maxTableLog)*0x01000001)}
-+#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
-+		HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
 +
 +/* The workspace must have alignment at least 4 and be at least this large */
 +#define HUF_WORKSPACE_SIZE (6 << 10)
 +#define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32))
 +
-+
 +/* ****************************************
 +*  Advanced decompression functions
 +******************************************/
 +size_t HUF_decompress4X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */
-+size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
++size_t HUF_decompress4X_hufOnly(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc,
++				size_t cSrcSize);							       /**< considers RLE and uncompressed as errors */
 +size_t HUF_decompress4X2_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize); /**< single-symbol decoder */
 +size_t HUF_decompress4X4_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize); /**< double-symbols decoder */
 +
-+
 +/* ****************************************
 +*  HUF detailed API
 +******************************************/
@@ -9402,7 +9796,8 @@ index 0000000..b157675
 +
 +typedef enum {
 +	HUF_repeat_none,  /**< Cannot use the previous table */
-+   HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
++	HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1,
++			     4}X_repeat */
 +	HUF_repeat_valid  /**< Can use the previous table and it is asumed to be valid */
 +} HUF_repeat;
 +/** HUF_compress4X_repeat() :
@@ -9410,7 +9805,9 @@ index 0000000..b157675
 +*   If it uses hufTable it does not modify hufTable or repeat.
 +*   If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
 +*   If preferRepeat then the old table will always be used if valid. */
-+size_t HUF_compress4X_repeat(void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize, HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
++size_t HUF_compress4X_repeat(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
++			     size_t wkspSize, HUF_CElt *hufTable, HUF_repeat *repeat,
++			     int preferRepeat); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
 +
 +/** HUF_buildCTable_wksp() :
 + *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
@@ -9423,15 +9820,12 @@ index 0000000..b157675
 +	`huffWeight` is destination buffer.
 +	@return : size read from `src` , or an error Code .
 +	Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
-+size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
++size_t HUF_readStats(BYTE *huffWeight, size_t hwSize, U32 *rankStats, U32 *nbSymbolsPtr, U32 *tableLogPtr, const void *src, size_t srcSize);
-+					 U32* nbSymbolsPtr, U32* tableLogPtr,
-+					 const void* src, size_t srcSize);
 +
 +/** HUF_readCTable() :
 +*   Loading a CTable saved with HUF_writeCTable() */
 +size_t HUF_readCTable(HUF_CElt *CTable, unsigned maxSymbolValue, const void *src, size_t srcSize);
 +
-+
 +/*
 +HUF_decompress() does the following:
 +1. select the decompression algorithm (X2, X4) based on pre-computed heuristics
@@ -9453,33 +9847,36 @@ index 0000000..b157675
 +size_t HUF_decompress4X2_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable);
 +size_t HUF_decompress4X4_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable);
 +
-+
 +/* single stream variants */
 +
-+size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
++size_t HUF_compress1X_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
++			   size_t wkspSize); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
 +size_t HUF_compress1X_usingCTable(void *dst, size_t dstSize, const void *src, size_t srcSize, const HUF_CElt *CTable);
 +/** HUF_compress1X_repeat() :
 +*   Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
 +*   If it uses hufTable it does not modify hufTable or repeat.
 +*   If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
 +*   If preferRepeat then the old table will always be used if valid. */
-+size_t HUF_compress1X_repeat(void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize, HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
++size_t HUF_compress1X_repeat(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace,
++			     size_t wkspSize, HUF_CElt *hufTable, HUF_repeat *repeat,
++			     int preferRepeat); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
 +
 +size_t HUF_decompress1X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize);
 +size_t HUF_decompress1X2_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize); /**< single-symbol decoder */
 +size_t HUF_decompress1X4_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize); /**< double-symbols decoder */
 +
-+size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);   /**< automatic selection of sing or double symbol decoder, based on DTable */
++size_t HUF_decompress1X_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize,
++				    const HUF_DTable *DTable); /**< automatic selection of sing or double symbol decoder, based on DTable */
 +size_t HUF_decompress1X2_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable);
 +size_t HUF_decompress1X4_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable);
 +
 +#endif /* HUF_H_298734234 */
 diff --git a/lib/zstd/huf_compress.c b/lib/zstd/huf_compress.c
 new file mode 100644
-index 0000000..ee03de9
+index 0000000..1587401
 --- /dev/null
 +++ b/lib/zstd/huf_compress.c
-@@ -0,0 +1,649 @@
+@@ -0,0 +1,732 @@
 +/*
 + * Huffman encoder, part of New Generation Entropy library
 + * Copyright (C) 2013-2016, Yann Collet.
@@ -9519,23 +9916,29 @@ index 0000000..ee03de9
 + * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
 + */
 +
-+
 +/* **************************************************************
 +*  Includes
 +****************************************************************/
-+#include <linux/string.h>     /* memcpy, memset */
 +#include "bitstream.h"
 +#include "fse.h" /* header compression */
 +#include "huf.h"
-+
++#include <linux/string.h> /* memcpy, memset */
 +
 +/* **************************************************************
 +*  Error Management
 +****************************************************************/
-+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
++#define HUF_STATIC_ASSERT(c)                                   \
-+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return f
++	{                                                      \
-+#define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
++		enum { HUF_static_assert = 1 / (int)(!!(c)) }; \
-+
++	} /* use only *after* variable declarations */
++#define CHECK_V_F(e, f)     \
++	size_t const e = f; \
++	if (ERR_isError(e)) \
++	return f
++#define CHECK_F(f)                        \
++	{                                 \
++		CHECK_V_F(_var_err__, f); \
++	}
 +
 +/* **************************************************************
 +*  Utils
@@ -9545,7 +9948,6 @@ index 0000000..ee03de9
 +	return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);
 +}
 +
-+
 +/* *******************************************************
 +*  HUF : Huffman block compression
 +*********************************************************/
@@ -9571,33 +9973,39 @@ index 0000000..ee03de9
 +	S16 norm[HUF_TABLELOG_MAX + 1];
 +
 +	/* init conditions */
-+	if (wtSize <= 1) return 0;  /* Not compressible */
++	if (wtSize <= 1)
++		return 0; /* Not compressible */
 +
 +	/* Scan input and build symbol stats */
-+	{	CHECK_V_F(maxCount, FSE_count_simple(count, &maxSymbolValue, weightTable, wtSize) );
++	{
-+		if (maxCount == wtSize) return 1;   /* only a single symbol in src : rle */
++		CHECK_V_F(maxCount, FSE_count_simple(count, &maxSymbolValue, weightTable, wtSize));
-+		if (maxCount == 1) return 0;         /* each symbol present maximum once => not compressible */
++		if (maxCount == wtSize)
++			return 1; /* only a single symbol in src : rle */
++		if (maxCount == 1)
++			return 0; /* each symbol present maximum once => not compressible */
 +	}
 +
 +	tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);
 +	CHECK_F(FSE_normalizeCount(norm, tableLog, count, wtSize, maxSymbolValue));
 +
 +	/* Write table description header */
-+	{	CHECK_V_F(hSize, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
++	{
++		CHECK_V_F(hSize, FSE_writeNCount(op, oend - op, norm, maxSymbolValue, tableLog));
 +		op += hSize;
 +	}
 +
 +	/* Compress */
 +	CHECK_F(FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, sizeof(scratchBuffer)));
-+	{	CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, weightTable, wtSize, CTable) );
++	{
-+		if (cSize == 0) return 0;   /* not enough space for compressed data */
++		CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, weightTable, wtSize, CTable));
++		if (cSize == 0)
++			return 0; /* not enough space for compressed data */
 +		op += cSize;
 +	}
 +
 +	return op - ostart;
 +}
 +
-+
 +struct HUF_CElt_s {
 +	U16 val;
 +	BYTE nbBits;
@@ -9606,8 +10014,7 @@ index 0000000..ee03de9
 +/*! HUF_writeCTable() :
 +	`CTable` : Huffman tree to save, using huf representation.
 +	@return : size of saved CTable */
-+size_t HUF_writeCTable (void* dst, size_t maxDstSize,
++size_t HUF_writeCTable(void *dst, size_t maxDstSize, const HUF_CElt *CTable, U32 maxSymbolValue, U32 huffLog)
-+						const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog)
 +{
 +	BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */
 +	BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
@@ -9615,7 +10022,8 @@ index 0000000..ee03de9
 +	U32 n;
 +
 +	/* check conditions */
-+	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
++	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)
++		return ERROR(maxSymbolValue_tooLarge);
 +
 +	/* convert to weight */
 +	bitsToWeight[0] = 0;
@@ -9625,15 +10033,19 @@ index 0000000..ee03de9
 +		huffWeight[n] = bitsToWeight[CTable[n].nbBits];
 +
 +	/* attempt weights compression by FSE */
-+	{	CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, huffWeight, maxSymbolValue) );
++	{
++		CHECK_V_F(hSize, HUF_compressWeights(op + 1, maxDstSize - 1, huffWeight, maxSymbolValue));
 +		if ((hSize > 1) & (hSize < maxSymbolValue / 2)) { /* FSE compressed */
 +			op[0] = (BYTE)hSize;
 +			return hSize + 1;
-+	}   }
++		}
++	}
 +
 +	/* write raw values as 4-bits (max : 15) */
-+	if (maxSymbolValue > (256-128)) return ERROR(GENERIC);   /* should not happen : likely means source cannot be compressed */
++	if (maxSymbolValue > (256 - 128))
-+	if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */
++		return ERROR(GENERIC); /* should not happen : likely means source cannot be compressed */
++	if (((maxSymbolValue + 1) / 2) + 1 > maxDstSize)
++		return ERROR(dstSize_tooSmall); /* not enough space within dst buffer */
 +	op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue - 1));
 +	huffWeight[maxSymbolValue] = 0; /* to be sure it doesn't cause msan issue in final combination */
 +	for (n = 0; n < maxSymbolValue; n += 2)
@@ -9641,7 +10053,6 @@ index 0000000..ee03de9
 +	return ((maxSymbolValue + 1) / 2) + 1;
 +}
 +
-+
 +size_t HUF_readCTable(HUF_CElt *CTable, U32 maxSymbolValue, const void *src, size_t srcSize)
 +{
 +	BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];  /* init not required, even though some static analyzer may complain */
@@ -9653,43 +10064,61 @@ index 0000000..ee03de9
 +	CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize));
 +
 +	/* check result */
-+	if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
++	if (tableLog > HUF_TABLELOG_MAX)
-+	if (nbSymbols > maxSymbolValue+1) return ERROR(maxSymbolValue_tooSmall);
++		return ERROR(tableLog_tooLarge);
++	if (nbSymbols > maxSymbolValue + 1)
++		return ERROR(maxSymbolValue_tooSmall);
 +
 +	/* Prepare base value per rank */
-+	{	U32 n, nextRankStart = 0;
++	{
++		U32 n, nextRankStart = 0;
 +		for (n = 1; n <= tableLog; n++) {
 +			U32 curr = nextRankStart;
 +			nextRankStart += (rankVal[n] << (n - 1));
 +			rankVal[n] = curr;
-+	}   }
++		}
++	}
 +
 +	/* fill nbBits */
-+	{	U32 n; for (n=0; n<nbSymbols; n++) {
++	{
++		U32 n;
++		for (n = 0; n < nbSymbols; n++) {
 +			const U32 w = huffWeight[n];
 +			CTable[n].nbBits = (BYTE)(tableLog + 1 - w);
-+	}   }
++		}
++	}
 +
 +	/* fill val */
-+	{	U16 nbPerRank[HUF_TABLELOG_MAX+2]  = {0};  /* support w=0=>n=tableLog+1 */
++	{
++		U16 nbPerRank[HUF_TABLELOG_MAX + 2] = {0}; /* support w=0=>n=tableLog+1 */
 +		U16 valPerRank[HUF_TABLELOG_MAX + 2] = {0};
-+		{ U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[CTable[n].nbBits]++; }
++		{
++			U32 n;
++			for (n = 0; n < nbSymbols; n++)
++				nbPerRank[CTable[n].nbBits]++;
++		}
 +		/* determine stating value per rank */
 +		valPerRank[tableLog + 1] = 0; /* for w==0 */
-+		{	U16 min = 0;
++		{
-+			U32 n; for (n=tableLog; n>0; n--) {  /* start at n=tablelog <-> w=1 */
++			U16 min = 0;
++			U32 n;
++			for (n = tableLog; n > 0; n--) { /* start at n=tablelog <-> w=1 */
 +				valPerRank[n] = min;     /* get starting value within each rank */
 +				min += nbPerRank[n];
 +				min >>= 1;
-+		}   }
++			}
++		}
 +		/* assign value within rank, symbol order */
-+		{ U32 n; for (n=0; n<=maxSymbolValue; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
++		{
++			U32 n;
++			for (n = 0; n <= maxSymbolValue; n++)
++				CTable[n].val = valPerRank[CTable[n].nbBits]++;
++		}
 +	}
 +
 +	return readSize;
 +}
 +
-+
 +typedef struct nodeElt_s {
 +	U32 count;
 +	U16 parent;
@@ -9700,10 +10129,12 @@ index 0000000..ee03de9
 +static U32 HUF_setMaxHeight(nodeElt *huffNode, U32 lastNonNull, U32 maxNbBits)
 +{
 +	const U32 largestBits = huffNode[lastNonNull].nbBits;
-+	if (largestBits <= maxNbBits) return largestBits;   /* early exit : no elt > maxNbBits */
++	if (largestBits <= maxNbBits)
++		return largestBits; /* early exit : no elt > maxNbBits */
 +
 +	/* there are several too large elements (at least >= 2) */
-+	{	int totalCost = 0;
++	{
++		int totalCost = 0;
 +		const U32 baseCost = 1 << (largestBits - maxNbBits);
 +		U32 n = lastNonNull;
 +
@@ -9712,38 +10143,50 @@ index 0000000..ee03de9
 +			huffNode[n].nbBits = (BYTE)maxNbBits;
 +			n--;
 +		} /* n stops at huffNode[n].nbBits <= maxNbBits */
-+		while (huffNode[n].nbBits == maxNbBits) n--;   /* n end at index of smallest symbol using < maxNbBits */
++		while (huffNode[n].nbBits == maxNbBits)
++			n--; /* n end at index of smallest symbol using < maxNbBits */
 +
 +		/* renorm totalCost */
 +		totalCost >>= (largestBits - maxNbBits); /* note : totalCost is necessarily a multiple of baseCost */
 +
 +		/* repay normalized cost */
-+		{	U32 const noSymbol = 0xF0F0F0F0;
++		{
++			U32 const noSymbol = 0xF0F0F0F0;
 +			U32 rankLast[HUF_TABLELOG_MAX + 2];
 +			int pos;
 +
 +			/* Get pos of last (smallest) symbol per rank */
 +			memset(rankLast, 0xF0, sizeof(rankLast));
-+			{	U32 currNbBits = maxNbBits;
++			{
++				U32 currNbBits = maxNbBits;
 +				for (pos = n; pos >= 0; pos--) {
-+					if (huffNode[pos].nbBits >= currNbBits) continue;
++					if (huffNode[pos].nbBits >= currNbBits)
++						continue;
 +					currNbBits = huffNode[pos].nbBits; /* < maxNbBits */
 +					rankLast[maxNbBits - currNbBits] = pos;
-+			}   }
++				}
++			}
 +
 +			while (totalCost > 0) {
 +				U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1;
 +				for (; nBitsToDecrease > 1; nBitsToDecrease--) {
 +					U32 highPos = rankLast[nBitsToDecrease];
 +					U32 lowPos = rankLast[nBitsToDecrease - 1];
-+					if (highPos == noSymbol) continue;
++					if (highPos == noSymbol)
-+					if (lowPos == noSymbol) break;
++						continue;
-+					{	U32 const highTotal = huffNode[highPos].count;
++					if (lowPos == noSymbol)
++						break;
++					{
++						U32 const highTotal = huffNode[highPos].count;
 +						U32 const lowTotal = 2 * huffNode[lowPos].count;
-+						if (highTotal <= lowTotal) break;
++						if (highTotal <= lowTotal)
-+				}   }
++							break;
++					}
++				}
 +				/* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
-+				while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))  /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
++				while (
++				    (nBitsToDecrease <= HUF_TABLELOG_MAX) &&
++				    (rankLast[nBitsToDecrease] == noSymbol)) /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
 +					nBitsToDecrease++;
 +				totalCost -= 1 << (nBitsToDecrease - 1);
 +				if (rankLast[nBitsToDecrease - 1] == noSymbol)
@@ -9755,11 +10198,14 @@ index 0000000..ee03de9
 +					rankLast[nBitsToDecrease]--;
 +					if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits - nBitsToDecrease)
 +						rankLast[nBitsToDecrease] = noSymbol; /* this rank is now empty */
-+			}   }   /* while (totalCost > 0) */
++				}
++			} /* while (totalCost > 0) */
 +
 +			while (totalCost < 0) {		       /* Sometimes, cost correction overshoot */
-+				if (rankLast[1] == noSymbol) {  /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
++				if (rankLast[1] == noSymbol) { /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0
-+					while (huffNode[n].nbBits == maxNbBits) n--;
++								  (using maxNbBits) */
++					while (huffNode[n].nbBits == maxNbBits)
++						n--;
 +					huffNode[n + 1].nbBits--;
 +					rankLast[1] = n + 1;
 +					totalCost++;
@@ -9768,12 +10214,13 @@ index 0000000..ee03de9
 +				huffNode[rankLast[1] + 1].nbBits--;
 +				rankLast[1]++;
 +				totalCost++;
-+	}   }   }   /* there are several too large elements (at least >= 2) */
++			}
++		}
++	} /* there are several too large elements (at least >= 2) */
 +
 +	return maxNbBits;
 +}
 +
-+
 +typedef struct {
 +	U32 base;
 +	U32 curr;
@@ -9789,19 +10236,21 @@ index 0000000..ee03de9
 +		U32 r = BIT_highbit32(count[n] + 1);
 +		rank[r].base++;
 +	}
-+	for (n=30; n>0; n--) rank[n-1].base += rank[n].base;
++	for (n = 30; n > 0; n--)
-+	for (n=0; n<32; n++) rank[n].curr = rank[n].base;
++		rank[n - 1].base += rank[n].base;
++	for (n = 0; n < 32; n++)
++		rank[n].curr = rank[n].base;
 +	for (n = 0; n <= maxSymbolValue; n++) {
 +		U32 const c = count[n];
 +		U32 const r = BIT_highbit32(c + 1) + 1;
 +		U32 pos = rank[r].curr++;
-+		while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) huffNode[pos]=huffNode[pos-1], pos--;
++		while ((pos > rank[r].base) && (c > huffNode[pos - 1].count))
++			huffNode[pos] = huffNode[pos - 1], pos--;
 +		huffNode[pos].count = c;
 +		huffNode[pos].byte = (BYTE)n;
 +	}
 +}
 +
-+
 +/** HUF_buildCTable_wksp() :
 + *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
 + *  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of 1024 unsigned.
@@ -9818,9 +10267,12 @@ index 0000000..ee03de9
 +	U32 nodeRoot;
 +
 +	/* safety checks */
-+	if (wkspSize < sizeof(huffNodeTable)) return ERROR(GENERIC);   /* workSpace is not large enough */
++	if (wkspSize < sizeof(huffNodeTable))
-+	if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
++		return ERROR(GENERIC); /* workSpace is not large enough */
-+	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(GENERIC);
++	if (maxNbBits == 0)
++		maxNbBits = HUF_TABLELOG_DEFAULT;
++	if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)
++		return ERROR(GENERIC);
 +	memset(huffNode0, 0, sizeof(huffNodeTable));
 +
 +	/* sort, decreasing order */
@@ -9828,12 +10280,17 @@ index 0000000..ee03de9
 +
 +	/* init for parents */
 +	nonNullRank = maxSymbolValue;
-+	while(huffNode[nonNullRank].count == 0) nonNullRank--;
++	while (huffNode[nonNullRank].count == 0)
-+	lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
++		nonNullRank--;
++	lowS = nonNullRank;
++	nodeRoot = nodeNb + lowS - 1;
++	lowN = nodeNb;
 +	huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS - 1].count;
 +	huffNode[lowS].parent = huffNode[lowS - 1].parent = nodeNb;
-+	nodeNb++; lowS-=2;
++	nodeNb++;
-+	for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
++	lowS -= 2;
++	for (n = nodeNb; n <= nodeRoot; n++)
++		huffNode[n].count = (U32)(1U << 30);
 +	huffNode0[0].count = (U32)(1U << 31); /* fake entry, strong barrier */
 +
 +	/* create parents */
@@ -9856,18 +10313,22 @@ index 0000000..ee03de9
 +	maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits);
 +
 +	/* fill result into tree (val, nbBits) */
-+	{	U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};
++	{
++		U16 nbPerRank[HUF_TABLELOG_MAX + 1] = {0};
 +		U16 valPerRank[HUF_TABLELOG_MAX + 1] = {0};
-+		if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC);   /* check fit into table */
++		if (maxNbBits > HUF_TABLELOG_MAX)
++			return ERROR(GENERIC); /* check fit into table */
 +		for (n = 0; n <= nonNullRank; n++)
 +			nbPerRank[huffNode[n].nbBits]++;
 +		/* determine stating value per rank */
-+		{	U16 min = 0;
++		{
++			U16 min = 0;
 +			for (n = maxNbBits; n > 0; n--) {
 +				valPerRank[n] = min; /* get starting value within each rank */
 +				min += nbPerRank[n];
 +				min >>= 1;
-+		}   }
++			}
++		}
 +		for (n = 0; n <= maxSymbolValue; n++)
 +			tree[huffNode[n].byte].nbBits = huffNode[n].nbBits; /* push nbBits per symbol, symbol order */
 +		for (n = 0; n <= maxSymbolValue; n++)
@@ -9887,7 +10348,8 @@ index 0000000..ee03de9
 +	return nbBits >> 3;
 +}
 +
-+static int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
++static int HUF_validateCTable(const HUF_CElt *CTable, const unsigned *count, unsigned maxSymbolValue)
++{
 +	int bad = 0;
 +	int s;
 +	for (s = 0; s <= (int)maxSymbolValue; ++s) {
@@ -9906,10 +10368,12 @@ index 0000000..ee03de9
 +#define HUF_FLUSHBITS(s) (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
 +
 +#define HUF_FLUSHBITS_1(stream)                                            \
-+	if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*2+7) HUF_FLUSHBITS(stream)
++	if (sizeof((stream)->bitContainer) * 8 < HUF_TABLELOG_MAX * 2 + 7) \
++	HUF_FLUSHBITS(stream)
 +
 +#define HUF_FLUSHBITS_2(stream)                                            \
-+	if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*4+7) HUF_FLUSHBITS(stream)
++	if (sizeof((stream)->bitContainer) * 8 < HUF_TABLELOG_MAX * 4 + 7) \
++	HUF_FLUSHBITS(stream)
 +
 +size_t HUF_compress1X_usingCTable(void *dst, size_t dstSize, const void *src, size_t srcSize, const HUF_CElt *CTable)
 +{
@@ -9922,19 +10386,19 @@ index 0000000..ee03de9
 +	BIT_CStream_t bitC;
 +
 +	/* init */
-+	if (dstSize < 8) return 0;   /* not enough space to compress */
++	if (dstSize < 8)
-+	{ size_t const initErr = BIT_initCStream(&bitC, op, oend-op);
++		return 0; /* not enough space to compress */
-+	  if (HUF_isError(initErr)) return 0; }
++	{
++		size_t const initErr = BIT_initCStream(&bitC, op, oend - op);
++		if (HUF_isError(initErr))
++			return 0;
++	}
 +
 +	n = srcSize & ~3; /* join to mod 4 */
-+	switch (srcSize & 3)
++	switch (srcSize & 3) {
-+	{
++	case 3: HUF_encodeSymbol(&bitC, ip[n + 2], CTable); HUF_FLUSHBITS_2(&bitC);
-+		case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable);
++	case 2: HUF_encodeSymbol(&bitC, ip[n + 1], CTable); HUF_FLUSHBITS_1(&bitC);
-+				 HUF_FLUSHBITS_2(&bitC);
++	case 1: HUF_encodeSymbol(&bitC, ip[n + 0], CTable); HUF_FLUSHBITS(&bitC);
-+		case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable);
-+				 HUF_FLUSHBITS_1(&bitC);
-+		case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable);
-+				 HUF_FLUSHBITS(&bitC);
 +	case 0:
 +	default:;
 +	}
@@ -9953,7 +10417,6 @@ index 0000000..ee03de9
 +	return BIT_closeCStream(&bitC);
 +}
 +
-+
 +size_t HUF_compress4X_usingCTable(void *dst, size_t dstSize, const void *src, size_t srcSize, const HUF_CElt *CTable)
 +{
 +	size_t const segmentSize = (srcSize + 3) / 4; /* first 3 segments */
@@ -9963,65 +10426,71 @@ index 0000000..ee03de9
 +	BYTE *const oend = ostart + dstSize;
 +	BYTE *op = ostart;
 +
-+	if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */
++	if (dstSize < 6 + 1 + 1 + 1 + 8)
-+	if (srcSize < 12) return 0;   /* no saving possible : too small input */
++		return 0; /* minimum space to compress successfully */
++	if (srcSize < 12)
++		return 0; /* no saving possible : too small input */
 +	op += 6;	  /* jumpTable */
 +
-+	{	CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
++	{
-+		if (cSize==0) return 0;
++		CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend - op, ip, segmentSize, CTable));
-+		MEM_writeLE16(ostart, (U16)cSize);
++		if (cSize == 0)
++			return 0;
++		ZSTD_writeLE16(ostart, (U16)cSize);
 +		op += cSize;
 +	}
 +
 +	ip += segmentSize;
-+	{	CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
++	{
-+		if (cSize==0) return 0;
++		CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend - op, ip, segmentSize, CTable));
-+		MEM_writeLE16(ostart+2, (U16)cSize);
++		if (cSize == 0)
++			return 0;
++		ZSTD_writeLE16(ostart + 2, (U16)cSize);
 +		op += cSize;
 +	}
 +
 +	ip += segmentSize;
-+	{	CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
++	{
-+		if (cSize==0) return 0;
++		CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend - op, ip, segmentSize, CTable));
-+		MEM_writeLE16(ostart+4, (U16)cSize);
++		if (cSize == 0)
++			return 0;
++		ZSTD_writeLE16(ostart + 4, (U16)cSize);
 +		op += cSize;
 +	}
 +
 +	ip += segmentSize;
-+	{	CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, iend-ip, CTable) );
++	{
-+		if (cSize==0) return 0;
++		CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend - op, ip, iend - ip, CTable));
++		if (cSize == 0)
++			return 0;
 +		op += cSize;
 +	}
 +
 +	return op - ostart;
 +}
 +
-+
++static size_t HUF_compressCTable_internal(BYTE *const ostart, BYTE *op, BYTE *const oend, const void *src, size_t srcSize, unsigned singleStream,
-+static size_t HUF_compressCTable_internal(
++					  const HUF_CElt *CTable)
-+				BYTE* const ostart, BYTE* op, BYTE* const oend,
-+				const void* src, size_t srcSize,
-+				unsigned singleStream, const HUF_CElt* CTable)
 +{
-+	size_t const cSize = singleStream ?
++	size_t const cSize =
-+						 HUF_compress1X_usingCTable(op, oend - op, src, srcSize, CTable) :
++	    singleStream ? HUF_compress1X_usingCTable(op, oend - op, src, srcSize, CTable) : HUF_compress4X_usingCTable(op, oend - op, src, srcSize, CTable);
-+						 HUF_compress4X_usingCTable(op, oend - op, src, srcSize, CTable);
++	if (HUF_isError(cSize)) {
-+	if (HUF_isError(cSize)) { return cSize; }
++		return cSize;
-+	if (cSize==0) { return 0; }   /* uncompressible */
++	}
++	if (cSize == 0) {
++		return 0;
++	} /* uncompressible */
 +	op += cSize;
 +	/* check compressibility */
-+	if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
++	if ((size_t)(op - ostart) >= srcSize - 1) {
++		return 0;
++	}
 +	return op - ostart;
 +}
 +
-+
 +/* `workSpace` must a table of at least 1024 unsigned */
-+static size_t HUF_compress_internal (
++static size_t HUF_compress_internal(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog,
-+				void* dst, size_t dstSize,
++				    unsigned singleStream, void *workSpace, size_t wkspSize, HUF_CElt *oldHufTable, HUF_repeat *repeat, int preferRepeat)
-+				const void* src, size_t srcSize,
-+				unsigned maxSymbolValue, unsigned huffLog,
-+				unsigned singleStream,
-+				void* workSpace, size_t wkspSize,
-+				HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat)
 +{
 +	BYTE *const ostart = (BYTE *)dst;
 +	BYTE *const oend = ostart + dstSize;
@@ -10033,13 +10502,20 @@ index 0000000..ee03de9
 +	size_t const CTableSize = sizeof(HUF_CElt) * (HUF_SYMBOLVALUE_MAX + 1);
 +
 +	/* checks & inits */
-+	if (wkspSize < sizeof(huffNodeTable) + countSize + CTableSize) return ERROR(GENERIC);
++	if (wkspSize < sizeof(huffNodeTable) + countSize + CTableSize)
-+	if (!srcSize) return 0;  /* Uncompressed (note : 1 means rle, so first byte must be correct) */
++		return ERROR(GENERIC);
-+	if (!dstSize) return 0;  /* cannot fit within dst budget */
++	if (!srcSize)
-+	if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* curr block size limit */
++		return 0; /* Uncompressed (note : 1 means rle, so first byte must be correct) */
-+	if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
++	if (!dstSize)
-+	if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
++		return 0; /* cannot fit within dst budget */
-+	if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
++	if (srcSize > HUF_BLOCKSIZE_MAX)
++		return ERROR(srcSize_wrong); /* curr block size limit */
++	if (huffLog > HUF_TABLELOG_MAX)
++		return ERROR(tableLog_tooLarge);
++	if (!maxSymbolValue)
++		maxSymbolValue = HUF_SYMBOLVALUE_MAX;
++	if (!huffLog)
++		huffLog = HUF_TABLELOG_DEFAULT;
 +
 +	count = (U32 *)workSpace;
 +	workSpace = (BYTE *)workSpace + countSize;
@@ -10054,9 +10530,14 @@ index 0000000..ee03de9
 +	}
 +
 +	/* Scan input and build symbol stats */
-+	{	CHECK_V_F(largest, FSE_count_wksp (count, &maxSymbolValue, (const BYTE*)src, srcSize, (U32*)workSpace) );
++	{
-+		if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
++		CHECK_V_F(largest, FSE_count_wksp(count, &maxSymbolValue, (const BYTE *)src, srcSize, (U32 *)workSpace));
-+		if (largest <= (srcSize >> 7)+1) return 0;   /* Fast heuristic : not compressible enough */
++		if (largest == srcSize) {
++			*ostart = ((const BYTE *)src)[0];
++			return 1;
++		} /* single symbol, rle */
++		if (largest <= (srcSize >> 7) + 1)
++			return 0; /* Fast heuristic : not compressible enough */
 +	}
 +
 +	/* Check validity of previous table */
@@ -10070,14 +10551,16 @@ index 0000000..ee03de9
 +
 +	/* Build Huffman Tree */
 +	huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
-+	{	CHECK_V_F(maxBits, HUF_buildCTable_wksp (CTable, count, maxSymbolValue, huffLog, workSpace, wkspSize) );
++	{
++		CHECK_V_F(maxBits, HUF_buildCTable_wksp(CTable, count, maxSymbolValue, huffLog, workSpace, wkspSize));
 +		huffLog = (U32)maxBits;
 +		/* Zero the unused symbols so we can check it for validity */
 +		memset(CTable + maxSymbolValue + 1, 0, CTableSize - (maxSymbolValue + 1) * sizeof(HUF_CElt));
 +	}
 +
 +	/* Write table description header */
-+	{	CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, CTable, maxSymbolValue, huffLog) );
++	{
++		CHECK_V_F(hSize, HUF_writeCTable(op, dstSize, CTable, maxSymbolValue, huffLog));
 +		/* Check if using the previous table will be beneficial */
 +		if (repeat && *repeat != HUF_repeat_none) {
 +			size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, count, maxSymbolValue);
@@ -10087,54 +10570,51 @@ index 0000000..ee03de9
 +			}
 +		}
 +		/* Use the new table */
-+		if (hSize + 12ul >= srcSize) { return 0; }
++		if (hSize + 12ul >= srcSize) {
++			return 0;
++		}
 +		op += hSize;
-+		if (repeat) { *repeat = HUF_repeat_none; }
++		if (repeat) {
-+		if (oldHufTable) { memcpy(oldHufTable, CTable, CTableSize); } /* Save the new table */
++			*repeat = HUF_repeat_none;
++		}
++		if (oldHufTable) {
++			memcpy(oldHufTable, CTable, CTableSize);
++		} /* Save the new table */
 +	}
 +	return HUF_compressCTable_internal(ostart, op, oend, src, srcSize, singleStream, CTable);
 +}
 +
-+
++size_t HUF_compress1X_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void *workSpace,
-+size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
++			   size_t wkspSize)
-+					  const void* src, size_t srcSize,
-+					  unsigned maxSymbolValue, unsigned huffLog,
-+					  void* workSpace, size_t wkspSize)
 +{
 +	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /* single stream */, workSpace, wkspSize, NULL, NULL, 0);
 +}
 +
-+size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
++size_t HUF_compress1X_repeat(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void *workSpace,
-+					  const void* src, size_t srcSize,
++			     size_t wkspSize, HUF_CElt *hufTable, HUF_repeat *repeat, int preferRepeat)
-+					  unsigned maxSymbolValue, unsigned huffLog,
-+					  void* workSpace, size_t wkspSize,
-+					  HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat)
 +{
-+	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /* single stream */, workSpace, wkspSize, hufTable, repeat, preferRepeat);
++	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /* single stream */, workSpace, wkspSize, hufTable, repeat,
++				     preferRepeat);
 +}
 +
-+size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
++size_t HUF_compress4X_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void *workSpace,
-+					  const void* src, size_t srcSize,
++			   size_t wkspSize)
-+					  unsigned maxSymbolValue, unsigned huffLog,
-+					  void* workSpace, size_t wkspSize)
 +{
 +	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /* 4 streams */, workSpace, wkspSize, NULL, NULL, 0);
 +}
 +
-+size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
++size_t HUF_compress4X_repeat(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void *workSpace,
-+					  const void* src, size_t srcSize,
++			     size_t wkspSize, HUF_CElt *hufTable, HUF_repeat *repeat, int preferRepeat)
-+					  unsigned maxSymbolValue, unsigned huffLog,
-+					  void* workSpace, size_t wkspSize,
-+					  HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat)
 +{
-+	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /* 4 streams */, workSpace, wkspSize, hufTable, repeat, preferRepeat);
++	return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /* 4 streams */, workSpace, wkspSize, hufTable, repeat,
++				     preferRepeat);
 +}
 diff --git a/lib/zstd/huf_decompress.c b/lib/zstd/huf_decompress.c
 new file mode 100644
-index 0000000..1ed6826
+index 0000000..5c38aa3
 --- /dev/null
 +++ b/lib/zstd/huf_decompress.c
-@@ -0,0 +1,840 @@
+@@ -0,0 +1,921 @@
 +/*
 + * Huffman decoder, part of New Generation Entropy library
 + * Copyright (C) 2013-2016, Yann Collet.
@@ -10179,28 +10659,33 @@ index 0000000..1ed6826
 +****************************************************************/
 +#define FORCE_INLINE static __always_inline
 +
-+
 +/* **************************************************************
 +*  Dependencies
 +****************************************************************/
-+#include <linux/compiler.h>
-+#include <linux/string.h>     /* memcpy, memset */
 +#include "bitstream.h" /* BIT_* */
 +#include "fse.h"       /* header compression */
 +#include "huf.h"
-+
++#include <linux/compiler.h>
++#include <linux/string.h> /* memcpy, memset */
 +
 +/* **************************************************************
 +*  Error Management
 +****************************************************************/
-+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
++#define HUF_STATIC_ASSERT(c)                                   \
-+
++	{                                                      \
++		enum { HUF_static_assert = 1 / (int)(!!(c)) }; \
++	} /* use only *after* variable declarations */
 +
 +/*-***************************/
 +/*  generic DTableDesc       */
 +/*-***************************/
 +
-+typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
++typedef struct {
++	BYTE maxTableLog;
++	BYTE tableType;
++	BYTE tableLog;
++	BYTE reserved;
++} DTableDesc;
 +
 +static DTableDesc HUF_getDTableDesc(const HUF_DTable *table)
 +{
@@ -10209,12 +10694,14 @@ index 0000000..1ed6826
 +	return dtd;
 +}
 +
-+
 +/*-***************************/
 +/*  single-symbol decoding   */
 +/*-***************************/
 +
-+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
++typedef struct {
++	BYTE byte;
++	BYTE nbBits;
++} HUF_DEltX2; /* single-symbol decoding */
 +
 +size_t HUF_readDTableX2(HUF_DTable *DTable, const void *src, size_t srcSize)
 +{
@@ -10230,41 +10717,48 @@ index 0000000..1ed6826
 +	/* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */
 +
 +	iSize = HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-+	if (HUF_isError(iSize)) return iSize;
++	if (HUF_isError(iSize))
++		return iSize;
 +
 +	/* Table header */
-+	{	DTableDesc dtd = HUF_getDTableDesc(DTable);
++	{
-+		if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
++		DTableDesc dtd = HUF_getDTableDesc(DTable);
++		if (tableLog > (U32)(dtd.maxTableLog + 1))
++			return ERROR(tableLog_tooLarge); /* DTable too small, Huffman tree cannot fit in */
 +		dtd.tableType = 0;
 +		dtd.tableLog = (BYTE)tableLog;
 +		memcpy(DTable, &dtd, sizeof(dtd));
 +	}
 +
 +	/* Calculate starting value for each rank */
-+	{	U32 n, nextRankStart = 0;
++	{
++		U32 n, nextRankStart = 0;
 +		for (n = 1; n < tableLog + 1; n++) {
 +			U32 const curr = nextRankStart;
 +			nextRankStart += (rankVal[n] << (n - 1));
 +			rankVal[n] = curr;
-+	}   }
++		}
++	}
 +
 +	/* fill DTable */
-+	{	U32 n;
++	{
++		U32 n;
 +		for (n = 0; n < nbSymbols; n++) {
 +			U32 const w = huffWeight[n];
 +			U32 const length = (1 << w) >> 1;
 +			U32 u;
 +			HUF_DEltX2 D;
-+			D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
++			D.byte = (BYTE)n;
++			D.nbBits = (BYTE)(tableLog + 1 - w);
 +			for (u = rankVal[w]; u < rankVal[w] + length; u++)
 +				dt[u] = D;
 +			rankVal[w] += length;
-+	}   }
++		}
++	}
 +
 +	return iSize;
 +}
 +
-+
 +static BYTE HUF_decodeSymbolX2(BIT_DStream_t *Dstream, const HUF_DEltX2 *dt, const U32 dtLog)
 +{
 +	size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
@@ -10273,15 +10767,14 @@ index 0000000..1ed6826
 +	return c;
 +}
 +
-+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
++#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
-+	*ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
 +
 +#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr)         \
-+	if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
++	if (ZSTD_64bits() || (HUF_TABLELOG_MAX <= 12)) \
 +	HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
 +
 +#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-+	if (MEM_64bits()) \
++	if (ZSTD_64bits())                     \
 +	HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
 +
 +FORCE_INLINE size_t HUF_decodeStreamX2(BYTE *p, BIT_DStream_t *const bitDPtr, BYTE *const pEnd, const HUF_DEltX2 *const dt, const U32 dtLog)
@@ -10307,10 +10800,7 @@ index 0000000..1ed6826
 +	return pEnd - pStart;
 +}
 +
-+static size_t HUF_decompress1X2_usingDTable_internal(
++static size_t HUF_decompress1X2_usingDTable_internal(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	BYTE *op = (BYTE *)dst;
 +	BYTE *const oend = op + dstSize;
@@ -10320,24 +10810,26 @@ index 0000000..1ed6826
 +	DTableDesc const dtd = HUF_getDTableDesc(DTable);
 +	U32 const dtLog = dtd.tableLog;
 +
-+	{ size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);
++	{
-+	  if (HUF_isError(errorCode)) return errorCode; }
++		size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);
++		if (HUF_isError(errorCode))
++			return errorCode;
++	}
 +
 +	HUF_decodeStreamX2(op, &bitD, oend, dt, dtLog);
 +
 +	/* check */
-+	if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
++	if (!BIT_endOfDStream(&bitD))
++		return ERROR(corruption_detected);
 +
 +	return dstSize;
 +}
 +
-+size_t HUF_decompress1X2_usingDTable(
++size_t HUF_decompress1X2_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	DTableDesc dtd = HUF_getDTableDesc(DTable);
-+	if (dtd.tableType != 0) return ERROR(GENERIC);
++	if (dtd.tableType != 0)
++		return ERROR(GENERIC);
 +	return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
 +}
 +
@@ -10346,23 +10838,24 @@ index 0000000..1ed6826
 +	const BYTE *ip = (const BYTE *)cSrc;
 +
 +	size_t const hSize = HUF_readDTableX2(DCtx, cSrc, cSrcSize);
-+	if (HUF_isError(hSize)) return hSize;
++	if (HUF_isError(hSize))
-+	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
++		return hSize;
-+	ip += hSize; cSrcSize -= hSize;
++	if (hSize >= cSrcSize)
++		return ERROR(srcSize_wrong);
++	ip += hSize;
++	cSrcSize -= hSize;
 +
 +	return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx);
 +}
 +
-+
++static size_t HUF_decompress4X2_usingDTable_internal(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+static size_t HUF_decompress4X2_usingDTable_internal(
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	/* Check */
-+	if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
++	if (cSrcSize < 10)
++		return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */
 +
-+	{	const BYTE* const istart = (const BYTE*) cSrc;
++	{
++		const BYTE *const istart = (const BYTE *)cSrc;
 +		BYTE *const ostart = (BYTE *)dst;
 +		BYTE *const oend = ostart + dstSize;
 +		const void *const dtPtr = DTable + 1;
@@ -10373,9 +10866,9 @@ index 0000000..1ed6826
 +		BIT_DStream_t bitD2;
 +		BIT_DStream_t bitD3;
 +		BIT_DStream_t bitD4;
-+		size_t const length1 = MEM_readLE16(istart);
++		size_t const length1 = ZSTD_readLE16(istart);
-+		size_t const length2 = MEM_readLE16(istart+2);
++		size_t const length2 = ZSTD_readLE16(istart + 2);
-+		size_t const length3 = MEM_readLE16(istart+4);
++		size_t const length3 = ZSTD_readLE16(istart + 4);
 +		size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
 +		const BYTE *const istart1 = istart + 6; /* jumpTable */
 +		const BYTE *const istart2 = istart1 + length1;
@@ -10393,15 +10886,28 @@ index 0000000..1ed6826
 +		DTableDesc const dtd = HUF_getDTableDesc(DTable);
 +		U32 const dtLog = dtd.tableLog;
 +
-+		if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
++		if (length4 > cSrcSize)
-+		{ size_t const errorCode = BIT_initDStream(&bitD1, istart1, length1);
++			return ERROR(corruption_detected); /* overflow */
-+		  if (HUF_isError(errorCode)) return errorCode; }
++		{
-+		{ size_t const errorCode = BIT_initDStream(&bitD2, istart2, length2);
++			size_t const errorCode = BIT_initDStream(&bitD1, istart1, length1);
-+		  if (HUF_isError(errorCode)) return errorCode; }
++			if (HUF_isError(errorCode))
-+		{ size_t const errorCode = BIT_initDStream(&bitD3, istart3, length3);
++				return errorCode;
-+		  if (HUF_isError(errorCode)) return errorCode; }
++		}
-+		{ size_t const errorCode = BIT_initDStream(&bitD4, istart4, length4);
++		{
-+		  if (HUF_isError(errorCode)) return errorCode; }
++			size_t const errorCode = BIT_initDStream(&bitD2, istart2, length2);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
++		{
++			size_t const errorCode = BIT_initDStream(&bitD3, istart3, length3);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
++		{
++			size_t const errorCode = BIT_initDStream(&bitD4, istart4, length4);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
 +
 +		/* 16-32 symbols per loop (4-8 symbols per stream) */
 +		endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
@@ -10426,9 +10932,12 @@ index 0000000..1ed6826
 +		}
 +
 +		/* check corruption */
-+		if (op1 > opStart2) return ERROR(corruption_detected);
++		if (op1 > opStart2)
-+		if (op2 > opStart3) return ERROR(corruption_detected);
++			return ERROR(corruption_detected);
-+		if (op3 > opStart4) return ERROR(corruption_detected);
++		if (op2 > opStart3)
++			return ERROR(corruption_detected);
++		if (op3 > opStart4)
++			return ERROR(corruption_detected);
 +		/* note : op4 supposed already verified within main loop */
 +
 +		/* finish bitStreams one by one */
@@ -10439,33 +10948,33 @@ index 0000000..1ed6826
 +
 +		/* check */
 +		endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-+		if (!endSignal) return ERROR(corruption_detected);
++		if (!endSignal)
++			return ERROR(corruption_detected);
 +
 +		/* decoded size */
 +		return dstSize;
 +	}
 +}
 +
-+
++size_t HUF_decompress4X2_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+size_t HUF_decompress4X2_usingDTable(
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	DTableDesc dtd = HUF_getDTableDesc(DTable);
-+	if (dtd.tableType != 0) return ERROR(GENERIC);
++	if (dtd.tableType != 0)
++		return ERROR(GENERIC);
 +	return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
 +}
 +
-+
 +size_t HUF_decompress4X2_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
 +{
 +	const BYTE *ip = (const BYTE *)cSrc;
 +
 +	size_t const hSize = HUF_readDTableX2(dctx, cSrc, cSrcSize);
-+	if (HUF_isError(hSize)) return hSize;
++	if (HUF_isError(hSize))
-+	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
++		return hSize;
-+	ip += hSize; cSrcSize -= hSize;
++	if (hSize >= cSrcSize)
++		return ERROR(srcSize_wrong);
++	ip += hSize;
++	cSrcSize -= hSize;
 +
 +	return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);
 +}
@@ -10473,16 +10982,21 @@ index 0000000..1ed6826
 +/* *************************/
 +/* double-symbols decoding */
 +/* *************************/
-+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
++typedef struct {
++	U16 sequence;
++	BYTE nbBits;
++	BYTE length;
++} HUF_DEltX4; /* double-symbols decoding */
 +
-+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
++typedef struct {
++	BYTE symbol;
++	BYTE weight;
++} sortedSymbol_t;
 +
 +/* HUF_fillDTableX4Level2() :
 + * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
-+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
++static void HUF_fillDTableX4Level2(HUF_DEltX4 *DTable, U32 sizeLog, const U32 consumed, const U32 *rankValOrigin, const int minWeight,
-+						   const U32* rankValOrigin, const int minWeight,
++				   const sortedSymbol_t *sortedSymbols, const U32 sortedListSize, U32 nbBitsBaseline, U16 baseSeq)
-+						   const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-+						   U32 nbBitsBaseline, U16 baseSeq)
 +{
 +	HUF_DEltX4 DElt;
 +	U32 rankVal[HUF_TABLELOG_MAX + 1];
@@ -10493,7 +11007,7 @@ index 0000000..1ed6826
 +	/* fill skipped values */
 +	if (minWeight > 1) {
 +		U32 i, skipSize = rankVal[minWeight];
-+		MEM_writeLE16(&(DElt.sequence), baseSeq);
++		ZSTD_writeLE16(&(DElt.sequence), baseSeq);
 +		DElt.nbBits = (BYTE)(consumed);
 +		DElt.length = 1;
 +		for (i = 0; i < skipSize; i++)
@@ -10501,7 +11015,9 @@ index 0000000..1ed6826
 +	}
 +
 +	/* fill DTable */
-+	{	U32 s; for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
++	{
++		U32 s;
++		for (s = 0; s < sortedListSize; s++) { /* note : sortedSymbols already skipped */
 +			const U32 symbol = sortedSymbols[s].symbol;
 +			const U32 weight = sortedSymbols[s].weight;
 +			const U32 nbBits = nbBitsBaseline - weight;
@@ -10510,21 +11026,22 @@ index 0000000..1ed6826
 +			U32 i = start;
 +			const U32 end = start + length;
 +
-+			MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
++			ZSTD_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
 +			DElt.nbBits = (BYTE)(nbBits + consumed);
 +			DElt.length = 2;
-+			do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
++			do {
++				DTable[i++] = DElt;
++			} while (i < end); /* since length >= 1 */
 +
 +			rankVal[weight] += length;
-+	}   }
++		}
++	}
 +}
 +
 +typedef U32 rankVal_t[HUF_TABLELOG_MAX][HUF_TABLELOG_MAX + 1];
 +
-+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
++static void HUF_fillDTableX4(HUF_DEltX4 *DTable, const U32 targetLog, const sortedSymbol_t *sortedList, const U32 sortedListSize, const U32 *rankStart,
-+						   const sortedSymbol_t* sortedList, const U32 sortedListSize,
++			     rankVal_t rankValOrigin, const U32 maxWeight, const U32 nbBitsBaseline)
-+						   const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
-+						   const U32 nbBitsBaseline)
 +{
 +	U32 rankVal[HUF_TABLELOG_MAX + 1];
 +	const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */
@@ -10544,21 +11061,23 @@ index 0000000..1ed6826
 +		if (targetLog - nbBits >= minBits) { /* enough room for a second symbol */
 +			U32 sortedRank;
 +			int minWeight = nbBits + scaleLog;
-+			if (minWeight < 1) minWeight = 1;
++			if (minWeight < 1)
++				minWeight = 1;
 +			sortedRank = rankStart[minWeight];
-+			HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
++			HUF_fillDTableX4Level2(DTable + start, targetLog - nbBits, nbBits, rankValOrigin[nbBits], minWeight, sortedList + sortedRank,
-+						   rankValOrigin[nbBits], minWeight,
++					       sortedListSize - sortedRank, nbBitsBaseline, symbol);
-+						   sortedList+sortedRank, sortedListSize-sortedRank,
-+						   nbBitsBaseline, symbol);
 +		} else {
 +			HUF_DEltX4 DElt;
-+			MEM_writeLE16(&(DElt.sequence), symbol);
++			ZSTD_writeLE16(&(DElt.sequence), symbol);
 +			DElt.nbBits = (BYTE)(nbBits);
 +			DElt.length = 1;
-+			{	U32 const end = start + length;
++			{
++				U32 const end = start + length;
 +				U32 u;
-+				for (u = start; u < end; u++) DTable[u] = DElt;
++				for (u = start; u < end; u++)
-+		}   }
++					DTable[u] = DElt;
++			}
++		}
 +		rankVal[weight] += length;
 +	}
 +}
@@ -10579,20 +11098,25 @@ index 0000000..1ed6826
 +	HUF_DEltX4 *const dt = (HUF_DEltX4 *)dtPtr;
 +
 +	HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(HUF_DTable)); /* if compiler fails here, assertion is wrong */
-+	if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
++	if (maxTableLog > HUF_TABLELOG_MAX)
++		return ERROR(tableLog_tooLarge);
 +	/* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */
 +
 +	iSize = HUF_readStats(weightList, HUF_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-+	if (HUF_isError(iSize)) return iSize;
++	if (HUF_isError(iSize))
++		return iSize;
 +
 +	/* check result */
-+	if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
++	if (tableLog > maxTableLog)
++		return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */
 +
 +	/* find maxWeight */
-+	for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
++	for (maxW = tableLog; rankStats[maxW] == 0; maxW--) {
++	} /* necessarily finds a solution before 0 */
 +
 +	/* Get start index of each weight */
-+	{	U32 w, nextRankStart = 0;
++	{
++		U32 w, nextRankStart = 0;
 +		for (w = 1; w < maxW + 1; w++) {
 +			U32 curr = nextRankStart;
 +			nextRankStart += rankStats[w];
@@ -10603,7 +11127,8 @@ index 0000000..1ed6826
 +	}
 +
 +	/* sort symbols by weight */
-+	{	U32 s;
++	{
++		U32 s;
 +		for (s = 0; s < nbSymbols; s++) {
 +			U32 const w = weightList[s];
 +			U32 const r = rankStart[w]++;
@@ -10614,28 +11139,32 @@ index 0000000..1ed6826
 +	}
 +
 +	/* Build rankVal */
-+	{	U32* const rankVal0 = rankVal[0];
++	{
-+		{	int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
++		U32 *const rankVal0 = rankVal[0];
++		{
++			int const rescale = (maxTableLog - tableLog) - 1; /* tableLog <= maxTableLog */
 +			U32 nextRankVal = 0;
 +			U32 w;
 +			for (w = 1; w < maxW + 1; w++) {
 +				U32 curr = nextRankVal;
 +				nextRankVal += rankStats[w] << (w + rescale);
 +				rankVal0[w] = curr;
-+		}   }
++			}
-+		{	U32 const minBits = tableLog+1 - maxW;
++		}
++		{
++			U32 const minBits = tableLog + 1 - maxW;
 +			U32 consumed;
 +			for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
 +				U32 *const rankValPtr = rankVal[consumed];
 +				U32 w;
 +				for (w = 1; w < maxW + 1; w++) {
 +					rankValPtr[w] = rankVal0[w] >> consumed;
-+	}   }   }   }
++				}
++			}
++		}
++	}
 +
-+	HUF_fillDTableX4(dt, maxTableLog,
++	HUF_fillDTableX4(dt, maxTableLog, sortedSymbol, sizeOfSort, rankStart0, rankVal, maxW, tableLog + 1);
-+				   sortedSymbol, sizeOfSort,
-+				   rankStart0, rankVal, maxW,
-+				   tableLog+1);
 +
 +	dtd.tableLog = (BYTE)maxTableLog;
 +	dtd.tableType = 1;
@@ -10643,7 +11172,6 @@ index 0000000..1ed6826
 +	return iSize;
 +}
 +
-+
 +static U32 HUF_decodeSymbolX4(void *op, BIT_DStream_t *DStream, const HUF_DEltX4 *dt, const U32 dtLog)
 +{
 +	size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
@@ -10656,26 +11184,28 @@ index 0000000..1ed6826
 +{
 +	size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
 +	memcpy(op, dt + val, 1);
-+	if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
++	if (dt[val].length == 1)
++		BIT_skipBits(DStream, dt[val].nbBits);
 +	else {
 +		if (DStream->bitsConsumed < (sizeof(DStream->bitContainer) * 8)) {
 +			BIT_skipBits(DStream, dt[val].nbBits);
 +			if (DStream->bitsConsumed > (sizeof(DStream->bitContainer) * 8))
-+				DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
++				DStream->bitsConsumed =
-+	}   }
++				    (sizeof(DStream->bitContainer) *
++				     8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
++		}
++	}
 +	return 1;
 +}
 +
-+
++#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-+	ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
 +
 +#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr)         \
-+	if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
++	if (ZSTD_64bits() || (HUF_TABLELOG_MAX <= 12)) \
 +	ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
 +
 +#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-+	if (MEM_64bits()) \
++	if (ZSTD_64bits())                     \
 +	ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
 +
 +FORCE_INLINE size_t HUF_decodeStreamX4(BYTE *p, BIT_DStream_t *bitDPtr, BYTE *const pEnd, const HUF_DEltX4 *const dt, const U32 dtLog)
@@ -10703,21 +11233,20 @@ index 0000000..1ed6826
 +	return p - pStart;
 +}
 +
-+
++static size_t HUF_decompress1X4_usingDTable_internal(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+static size_t HUF_decompress1X4_usingDTable_internal(
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	BIT_DStream_t bitD;
 +
 +	/* Init */
-+	{	size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);
++	{
-+		if (HUF_isError(errorCode)) return errorCode;
++		size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);
++		if (HUF_isError(errorCode))
++			return errorCode;
 +	}
 +
 +	/* decode */
-+	{	BYTE* const ostart = (BYTE*) dst;
++	{
++		BYTE *const ostart = (BYTE *)dst;
 +		BYTE *const oend = ostart + dstSize;
 +		const void *const dtPtr = DTable + 1; /* force compiler to not use strict-aliasing */
 +		const HUF_DEltX4 *const dt = (const HUF_DEltX4 *)dtPtr;
@@ -10726,19 +11255,18 @@ index 0000000..1ed6826
 +	}
 +
 +	/* check */
-+	if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
++	if (!BIT_endOfDStream(&bitD))
++		return ERROR(corruption_detected);
 +
 +	/* decoded size */
 +	return dstSize;
 +}
 +
-+size_t HUF_decompress1X4_usingDTable(
++size_t HUF_decompress1X4_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	DTableDesc dtd = HUF_getDTableDesc(DTable);
-+	if (dtd.tableType != 1) return ERROR(GENERIC);
++	if (dtd.tableType != 1)
++		return ERROR(GENERIC);
 +	return HUF_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
 +}
 +
@@ -10747,21 +11275,23 @@ index 0000000..1ed6826
 +	const BYTE *ip = (const BYTE *)cSrc;
 +
 +	size_t const hSize = HUF_readDTableX4(DCtx, cSrc, cSrcSize);
-+	if (HUF_isError(hSize)) return hSize;
++	if (HUF_isError(hSize))
-+	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
++		return hSize;
-+	ip += hSize; cSrcSize -= hSize;
++	if (hSize >= cSrcSize)
++		return ERROR(srcSize_wrong);
++	ip += hSize;
++	cSrcSize -= hSize;
 +
 +	return HUF_decompress1X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx);
 +}
 +
-+static size_t HUF_decompress4X4_usingDTable_internal(
++static size_t HUF_decompress4X4_usingDTable_internal(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
-+	if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
++	if (cSrcSize < 10)
++		return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */
 +
-+	{	const BYTE* const istart = (const BYTE*) cSrc;
++	{
++		const BYTE *const istart = (const BYTE *)cSrc;
 +		BYTE *const ostart = (BYTE *)dst;
 +		BYTE *const oend = ostart + dstSize;
 +		const void *const dtPtr = DTable + 1;
@@ -10772,9 +11302,9 @@ index 0000000..1ed6826
 +		BIT_DStream_t bitD2;
 +		BIT_DStream_t bitD3;
 +		BIT_DStream_t bitD4;
-+		size_t const length1 = MEM_readLE16(istart);
++		size_t const length1 = ZSTD_readLE16(istart);
-+		size_t const length2 = MEM_readLE16(istart+2);
++		size_t const length2 = ZSTD_readLE16(istart + 2);
-+		size_t const length3 = MEM_readLE16(istart+4);
++		size_t const length3 = ZSTD_readLE16(istart + 4);
 +		size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
 +		const BYTE *const istart1 = istart + 6; /* jumpTable */
 +		const BYTE *const istart2 = istart1 + length1;
@@ -10792,15 +11322,28 @@ index 0000000..1ed6826
 +		DTableDesc const dtd = HUF_getDTableDesc(DTable);
 +		U32 const dtLog = dtd.tableLog;
 +
-+		if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
++		if (length4 > cSrcSize)
-+		{ size_t const errorCode = BIT_initDStream(&bitD1, istart1, length1);
++			return ERROR(corruption_detected); /* overflow */
-+		  if (HUF_isError(errorCode)) return errorCode; }
++		{
-+		{ size_t const errorCode = BIT_initDStream(&bitD2, istart2, length2);
++			size_t const errorCode = BIT_initDStream(&bitD1, istart1, length1);
-+		  if (HUF_isError(errorCode)) return errorCode; }
++			if (HUF_isError(errorCode))
-+		{ size_t const errorCode = BIT_initDStream(&bitD3, istart3, length3);
++				return errorCode;
-+		  if (HUF_isError(errorCode)) return errorCode; }
++		}
-+		{ size_t const errorCode = BIT_initDStream(&bitD4, istart4, length4);
++		{
-+		  if (HUF_isError(errorCode)) return errorCode; }
++			size_t const errorCode = BIT_initDStream(&bitD2, istart2, length2);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
++		{
++			size_t const errorCode = BIT_initDStream(&bitD3, istart3, length3);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
++		{
++			size_t const errorCode = BIT_initDStream(&bitD4, istart4, length4);
++			if (HUF_isError(errorCode))
++				return errorCode;
++		}
 +
 +		/* 16-32 symbols per loop (4-8 symbols per stream) */
 +		endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
@@ -10826,9 +11369,12 @@ index 0000000..1ed6826
 +		}
 +
 +		/* check corruption */
-+		if (op1 > opStart2) return ERROR(corruption_detected);
++		if (op1 > opStart2)
-+		if (op2 > opStart3) return ERROR(corruption_detected);
++			return ERROR(corruption_detected);
-+		if (op3 > opStart4) return ERROR(corruption_detected);
++		if (op2 > opStart3)
++			return ERROR(corruption_detected);
++		if (op3 > opStart4)
++			return ERROR(corruption_detected);
 +		/* note : op4 already verified within main loop */
 +
 +		/* finish bitStreams one by one */
@@ -10838,65 +11384,63 @@ index 0000000..1ed6826
 +		HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog);
 +
 +		/* check */
-+		{ U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
++		{
-+		  if (!endCheck) return ERROR(corruption_detected); }
++			U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
++			if (!endCheck)
++				return ERROR(corruption_detected);
++		}
 +
 +		/* decoded size */
 +		return dstSize;
 +	}
 +}
 +
-+
++size_t HUF_decompress4X4_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+size_t HUF_decompress4X4_usingDTable(
-+		  void* dst,  size_t dstSize,
-+	const void* cSrc, size_t cSrcSize,
-+	const HUF_DTable* DTable)
 +{
 +	DTableDesc dtd = HUF_getDTableDesc(DTable);
-+	if (dtd.tableType != 1) return ERROR(GENERIC);
++	if (dtd.tableType != 1)
++		return ERROR(GENERIC);
 +	return HUF_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
 +}
 +
-+
 +size_t HUF_decompress4X4_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
 +{
 +	const BYTE *ip = (const BYTE *)cSrc;
 +
 +	size_t hSize = HUF_readDTableX4(dctx, cSrc, cSrcSize);
-+	if (HUF_isError(hSize)) return hSize;
++	if (HUF_isError(hSize))
-+	if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
++		return hSize;
-+	ip += hSize; cSrcSize -= hSize;
++	if (hSize >= cSrcSize)
++		return ERROR(srcSize_wrong);
++	ip += hSize;
++	cSrcSize -= hSize;
 +
 +	return HUF_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);
 +}
 +
-+
 +/* ********************************/
 +/* Generic decompression selector */
 +/* ********************************/
 +
-+size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
++size_t HUF_decompress1X_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+									const void* cSrc, size_t cSrcSize,
-+									const HUF_DTable* DTable)
 +{
 +	DTableDesc const dtd = HUF_getDTableDesc(DTable);
-+	return dtd.tableType ? HUF_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
++	return dtd.tableType ? HUF_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable)
-+						   HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
++			     : HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
 +}
 +
-+size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
++size_t HUF_decompress4X_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
-+									const void* cSrc, size_t cSrcSize,
-+									const HUF_DTable* DTable)
 +{
 +	DTableDesc const dtd = HUF_getDTableDesc(DTable);
-+	return dtd.tableType ? HUF_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
++	return dtd.tableType ? HUF_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable)
-+						   HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
++			     : HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
 +}
 +
-+
++typedef struct {
-+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
++	U32 tableTime;
-+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
++	U32 decode256Time;
-+{
++} algo_time_t;
++static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = {
 +    /* single, double, quad */
 +    {{0, 0}, {1, 1}, {2, 2}},		     /* Q==0 : impossible */
 +    {{0, 0}, {1, 1}, {2, 2}},		     /* Q==1 : impossible */
@@ -10933,54 +11477,71 @@ index 0000000..1ed6826
 +	return DTime1 < DTime0;
 +}
 +
-+
 +typedef size_t (*decompressionAlgo)(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize);
 +
 +size_t HUF_decompress4X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
 +{
 +	/* validation checks */
-+	if (dstSize == 0) return ERROR(dstSize_tooSmall);
++	if (dstSize == 0)
-+	if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
++		return ERROR(dstSize_tooSmall);
-+	if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
++	if (cSrcSize > dstSize)
-+	if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
++		return ERROR(corruption_detected); /* invalid */
++	if (cSrcSize == dstSize) {
++		memcpy(dst, cSrc, dstSize);
++		return dstSize;
++	} /* not compressed */
++	if (cSrcSize == 1) {
++		memset(dst, *(const BYTE *)cSrc, dstSize);
++		return dstSize;
++	} /* RLE */
 +
-+	{	U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
++	{
-+		return algoNb ? HUF_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
++		U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-+						HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
++		return algoNb ? HUF_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
 +	}
 +}
 +
 +size_t HUF_decompress4X_hufOnly(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
 +{
 +	/* validation checks */
-+	if (dstSize == 0) return ERROR(dstSize_tooSmall);
++	if (dstSize == 0)
-+	if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected);   /* invalid */
++		return ERROR(dstSize_tooSmall);
++	if ((cSrcSize >= dstSize) || (cSrcSize <= 1))
++		return ERROR(corruption_detected); /* invalid */
 +
-+	{	U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
++	{
-+		return algoNb ? HUF_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
++		U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-+						HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
++		return algoNb ? HUF_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
 +	}
 +}
 +
 +size_t HUF_decompress1X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
 +{
 +	/* validation checks */
-+	if (dstSize == 0) return ERROR(dstSize_tooSmall);
++	if (dstSize == 0)
-+	if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
++		return ERROR(dstSize_tooSmall);
-+	if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
++	if (cSrcSize > dstSize)
-+	if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
++		return ERROR(corruption_detected); /* invalid */
++	if (cSrcSize == dstSize) {
++		memcpy(dst, cSrc, dstSize);
++		return dstSize;
++	} /* not compressed */
++	if (cSrcSize == 1) {
++		memset(dst, *(const BYTE *)cSrc, dstSize);
++		return dstSize;
++	} /* RLE */
 +
-+	{	U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
++	{
-+		return algoNb ? HUF_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
++		U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-+						HUF_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
++		return algoNb ? HUF_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : HUF_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
 +	}
 +}
 diff --git a/lib/zstd/mem.h b/lib/zstd/mem.h
 new file mode 100644
-index 0000000..e656a0e
+index 0000000..3a0f34c
 --- /dev/null
 +++ b/lib/zstd/mem.h
-@@ -0,0 +1,216 @@
+@@ -0,0 +1,151 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -11004,19 +11565,13 @@ index 0000000..e656a0e
 +*  Dependencies
 +******************************************/
 +#include <asm/unaligned.h>
-+#include <linux/types.h>     /* size_t, ptrdiff_t */
 +#include <linux/string.h> /* memcpy */
-+
++#include <linux/types.h>  /* size_t, ptrdiff_t */
 +
 +/*-****************************************
 +*  Compiler specifics
 +******************************************/
-+#define MEM_STATIC static __inline __attribute__((unused))
++#define ZSTD_STATIC static __inline __attribute__((unused))
-+
-+/* code only tested on 32 and 64 bits systems */
-+#define MEM_STATIC_ASSERT(c)   { enum { MEM_static_assert = 1/(int)(!!(c)) }; }
-+MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
-+
 +
 +/*-**************************************************************
 +*  Basic Types
@@ -11031,178 +11586,119 @@ index 0000000..e656a0e
 +typedef ptrdiff_t iPtrDiff;
 +typedef uintptr_t uPtrDiff;
 +
-+
 +/*-**************************************************************
 +*  Memory I/O
 +*****************************************************************/
-+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
++ZSTD_STATIC unsigned ZSTD_32bits(void) { return sizeof(size_t) == 4; }
-+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
++ZSTD_STATIC unsigned ZSTD_64bits(void) { return sizeof(size_t) == 8; }
 +
 +#if defined(__LITTLE_ENDIAN)
-+#   define MEM_LITTLE_ENDIAN 1
++#define ZSTD_LITTLE_ENDIAN 1
 +#else
-+#   define MEM_LITTLE_ENDIAN 0
++#define ZSTD_LITTLE_ENDIAN 0
 +#endif
 +
-+MEM_STATIC unsigned MEM_isLittleEndian(void)
++ZSTD_STATIC unsigned ZSTD_isLittleEndian(void) { return ZSTD_LITTLE_ENDIAN; }
-+{
-+	return MEM_LITTLE_ENDIAN;
-+}
 +
-+MEM_STATIC U16 MEM_read16(const void* memPtr)
++ZSTD_STATIC U16 ZSTD_read16(const void *memPtr) { return get_unaligned((const U16 *)memPtr); }
-+{
-+	return get_unaligned((const U16*)memPtr);
-+}
 +
-+MEM_STATIC U32 MEM_read32(const void* memPtr)
++ZSTD_STATIC U32 ZSTD_read32(const void *memPtr) { return get_unaligned((const U32 *)memPtr); }
-+{
-+	return get_unaligned((const U32*)memPtr);
-+}
 +
-+MEM_STATIC U64 MEM_read64(const void* memPtr)
++ZSTD_STATIC U64 ZSTD_read64(const void *memPtr) { return get_unaligned((const U64 *)memPtr); }
-+{
-+	return get_unaligned((const U64*)memPtr);
-+}
 +
-+MEM_STATIC size_t MEM_readST(const void* memPtr)
++ZSTD_STATIC size_t ZSTD_readST(const void *memPtr) { return get_unaligned((const size_t *)memPtr); }
-+{
-+	return get_unaligned((const size_t*)memPtr);
-+}
 +
-+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
++ZSTD_STATIC void ZSTD_write16(void *memPtr, U16 value) { put_unaligned(value, (U16 *)memPtr); }
-+{
-+	put_unaligned(value, (U16*)memPtr);
-+}
 +
-+MEM_STATIC void MEM_write32(void* memPtr, U32 value)
++ZSTD_STATIC void ZSTD_write32(void *memPtr, U32 value) { put_unaligned(value, (U32 *)memPtr); }
-+{
-+	put_unaligned(value, (U32*)memPtr);
-+}
 +
-+MEM_STATIC void MEM_write64(void* memPtr, U64 value)
++ZSTD_STATIC void ZSTD_write64(void *memPtr, U64 value) { put_unaligned(value, (U64 *)memPtr); }
-+{
-+	put_unaligned(value, (U64*)memPtr);
-+}
 +
 +/*=== Little endian r/w ===*/
 +
-+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
++ZSTD_STATIC U16 ZSTD_readLE16(const void *memPtr) { return get_unaligned_le16(memPtr); }
-+{
-+	return get_unaligned_le16(memPtr);
-+}
 +
-+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
++ZSTD_STATIC void ZSTD_writeLE16(void *memPtr, U16 val) { put_unaligned_le16(val, memPtr); }
-+{
-+	put_unaligned_le16(val, memPtr);
-+}
 +
-+MEM_STATIC U32 MEM_readLE24(const void* memPtr)
++ZSTD_STATIC U32 ZSTD_readLE24(const void *memPtr) { return ZSTD_readLE16(memPtr) + (((const BYTE *)memPtr)[2] << 16); }
-+{
-+	return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
-+}
 +
-+MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
++ZSTD_STATIC void ZSTD_writeLE24(void *memPtr, U32 val)
 +{
-+	MEM_writeLE16(memPtr, (U16)val);
++	ZSTD_writeLE16(memPtr, (U16)val);
 +	((BYTE *)memPtr)[2] = (BYTE)(val >> 16);
 +}
 +
-+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
++ZSTD_STATIC U32 ZSTD_readLE32(const void *memPtr) { return get_unaligned_le32(memPtr); }
-+{
-+	return get_unaligned_le32(memPtr);
-+}
 +
-+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
++ZSTD_STATIC void ZSTD_writeLE32(void *memPtr, U32 val32) { put_unaligned_le32(val32, memPtr); }
-+{
-+	put_unaligned_le32(val32, memPtr);
-+}
 +
-+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
++ZSTD_STATIC U64 ZSTD_readLE64(const void *memPtr) { return get_unaligned_le64(memPtr); }
-+{
-+	return get_unaligned_le64(memPtr);
-+}
 +
-+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
++ZSTD_STATIC void ZSTD_writeLE64(void *memPtr, U64 val64) { put_unaligned_le64(val64, memPtr); }
-+{
-+	put_unaligned_le64(val64, memPtr);
-+}
 +
-+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
++ZSTD_STATIC size_t ZSTD_readLEST(const void *memPtr)
 +{
-+	if (MEM_32bits())
++	if (ZSTD_32bits())
-+		return (size_t)MEM_readLE32(memPtr);
++		return (size_t)ZSTD_readLE32(memPtr);
 +	else
-+		return (size_t)MEM_readLE64(memPtr);
++		return (size_t)ZSTD_readLE64(memPtr);
 +}
 +
-+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
++ZSTD_STATIC void ZSTD_writeLEST(void *memPtr, size_t val)
 +{
-+	if (MEM_32bits())
++	if (ZSTD_32bits())
-+		MEM_writeLE32(memPtr, (U32)val);
++		ZSTD_writeLE32(memPtr, (U32)val);
 +	else
-+		MEM_writeLE64(memPtr, (U64)val);
++		ZSTD_writeLE64(memPtr, (U64)val);
 +}
 +
 +/*=== Big endian r/w ===*/
 +
-+MEM_STATIC U32 MEM_readBE32(const void* memPtr)
++ZSTD_STATIC U32 ZSTD_readBE32(const void *memPtr) { return get_unaligned_be32(memPtr); }
-+{
-+	return get_unaligned_be32(memPtr);
-+}
 +
-+MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
++ZSTD_STATIC void ZSTD_writeBE32(void *memPtr, U32 val32) { put_unaligned_be32(val32, memPtr); }
-+{
-+	put_unaligned_be32(val32, memPtr);
-+}
 +
-+MEM_STATIC U64 MEM_readBE64(const void* memPtr)
++ZSTD_STATIC U64 ZSTD_readBE64(const void *memPtr) { return get_unaligned_be64(memPtr); }
-+{
-+	return get_unaligned_be64(memPtr);
-+}
 +
-+MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
++ZSTD_STATIC void ZSTD_writeBE64(void *memPtr, U64 val64) { put_unaligned_be64(val64, memPtr); }
-+{
-+	put_unaligned_be64(val64, memPtr);
-+}
 +
-+MEM_STATIC size_t MEM_readBEST(const void* memPtr)
++ZSTD_STATIC size_t ZSTD_readBEST(const void *memPtr)
 +{
-+	if (MEM_32bits())
++	if (ZSTD_32bits())
-+		return (size_t)MEM_readBE32(memPtr);
++		return (size_t)ZSTD_readBE32(memPtr);
 +	else
-+		return (size_t)MEM_readBE64(memPtr);
++		return (size_t)ZSTD_readBE64(memPtr);
 +}
 +
-+MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
++ZSTD_STATIC void ZSTD_writeBEST(void *memPtr, size_t val)
 +{
-+	if (MEM_32bits())
++	if (ZSTD_32bits())
-+		MEM_writeBE32(memPtr, (U32)val);
++		ZSTD_writeBE32(memPtr, (U32)val);
 +	else
-+		MEM_writeBE64(memPtr, (U64)val);
++		ZSTD_writeBE64(memPtr, (U64)val);
 +}
 +
-+
 +/* function safe only for comparisons */
-+MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length)
++ZSTD_STATIC U32 ZSTD_readMINMATCH(const void *memPtr, U32 length)
-+{
-+	switch (length)
 +{
++	switch (length) {
 +	default:
-+	case 4 : return MEM_read32(memPtr);
++	case 4: return ZSTD_read32(memPtr);
-+	case 3 : if (MEM_isLittleEndian())
++	case 3:
-+				return MEM_read32(memPtr)<<8;
++		if (ZSTD_isLittleEndian())
++			return ZSTD_read32(memPtr) << 8;
 +		else
-+				return MEM_read32(memPtr)>>8;
++			return ZSTD_read32(memPtr) >> 8;
 +	}
 +}
 +
 +#endif /* MEM_H_MODULE */
 diff --git a/lib/zstd/zstd_common.c b/lib/zstd/zstd_common.c
 new file mode 100644
-index 0000000..4ff3cc8
+index 0000000..6ebf68d
 --- /dev/null
 +++ b/lib/zstd/zstd_common.c
-@@ -0,0 +1,76 @@
+@@ -0,0 +1,75 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -11219,8 +11715,6 @@ index 0000000..4ff3cc8
 + * ("BSD").
 + */
 +
-+
-+
 +/*-*************************************
 +*  Dependencies
 +***************************************/
@@ -11228,18 +11722,19 @@ index 0000000..4ff3cc8
 +#include "zstd_internal.h" /* declaration of ZSTD_isError, ZSTD_getErrorName, ZSTD_getErrorCode, ZSTD_getErrorString, ZSTD_versionNumber */
 +#include <linux/kernel.h>
 +
-+
 +/*=**************************************************************
 +*  Custom allocator
 +****************************************************************/
 +
-+#define stack_push(stack, size) ({                                             \
++#define stack_push(stack, size)                                 \
++	({                                                      \
 +		void *const ptr = ZSTD_PTR_ALIGN((stack)->ptr); \
 +		(stack)->ptr = (char *)ptr + (size);            \
 +		(stack)->ptr <= (stack)->end ? ptr : NULL;      \
 +	})
 +
-+ZSTD_customMem ZSTD_initStack(void* workspace, size_t workspaceSize) {
++ZSTD_customMem ZSTD_initStack(void *workspace, size_t workspaceSize)
++{
 +	ZSTD_customMem stackMem = {ZSTD_stackAlloc, ZSTD_stackFree, workspace};
 +	ZSTD_stack *stack = (ZSTD_stack *)workspace;
 +	/* Verify preconditions */
@@ -11254,25 +11749,25 @@ index 0000000..4ff3cc8
 +	return stackMem;
 +}
 +
-+void* ZSTD_stackAllocAll(void* opaque, size_t* size) {
++void *ZSTD_stackAllocAll(void *opaque, size_t *size)
++{
 +	ZSTD_stack *stack = (ZSTD_stack *)opaque;
 +	*size = stack->end - ZSTD_PTR_ALIGN(stack->ptr);
 +	return stack_push(stack, *size);
 +}
 +
-+void* ZSTD_stackAlloc(void* opaque, size_t size) {
++void *ZSTD_stackAlloc(void *opaque, size_t size)
++{
 +	ZSTD_stack *stack = (ZSTD_stack *)opaque;
 +	return stack_push(stack, size);
 +}
-+void ZSTD_stackFree(void* opaque, void* address) {
++void ZSTD_stackFree(void *opaque, void *address)
++{
 +	(void)opaque;
 +	(void)address;
 +}
 +
-+void* ZSTD_malloc(size_t size, ZSTD_customMem customMem)
++void *ZSTD_malloc(size_t size, ZSTD_customMem customMem) { return customMem.customAlloc(customMem.opaque, size); }
-+{
-+	return customMem.customAlloc(customMem.opaque, size);
-+}
 +
 +void ZSTD_free(void *ptr, ZSTD_customMem customMem)
 +{
@@ -11281,10 +11776,10 @@ index 0000000..4ff3cc8
 +}
 diff --git a/lib/zstd/zstd_internal.h b/lib/zstd/zstd_internal.h
 new file mode 100644
-index 0000000..91365ea
+index 0000000..6748719
 --- /dev/null
 +++ b/lib/zstd/zstd_internal.h
-@@ -0,0 +1,268 @@
+@@ -0,0 +1,269 @@
 +/**
 + * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -11310,26 +11805,37 @@ index 0000000..91365ea
 +#define FORCE_INLINE static __always_inline
 +#define FORCE_NOINLINE static noinline
 +
-+
 +/*-*************************************
 +*  Dependencies
 +***************************************/
++#include "error_private.h"
++#include "mem.h"
 +#include <linux/compiler.h>
 +#include <linux/kernel.h>
 +#include <linux/xxhash.h>
 +#include <linux/zstd.h>
-+#include "mem.h"
-+#include "error_private.h"
-+
 +
 +/*-*************************************
 +*  shared macros
 +***************************************/
 +#define MIN(a, b) ((a) < (b) ? (a) : (b))
 +#define MAX(a, b) ((a) > (b) ? (a) : (b))
-+#define CHECK_F(f) { size_t const errcod = f; if (ERR_isError(errcod)) return errcod; }  /* check and Forward error code */
++#define CHECK_F(f)                       \
-+#define CHECK_E(f, e) { size_t const errcod = f; if (ERR_isError(errcod)) return ERROR(e); }  /* check and send Error code */
++	{                                \
-+
++		size_t const errcod = f; \
++		if (ERR_isError(errcod)) \
++			return errcod;   \
++	} /* check and Forward error code */
++#define CHECK_E(f, e)                    \
++	{                                \
++		size_t const errcod = f; \
++		if (ERR_isError(errcod)) \
++			return ERROR(e); \
++	} /* check and send Error code */
++#define ZSTD_STATIC_ASSERT(c)                                   \
++	{                                                       \
++		enum { ZSTD_static_assert = 1 / (int)(!!(c)) }; \
++	}
 +
 +/*-*************************************
 +*  Common constants
@@ -11383,42 +11889,37 @@ index 0000000..91365ea
 +#define LLFSELog 9
 +#define OffFSELog 8
 +
-+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++static const U32 LL_bits[MaxLL + 1] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-+									  1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12,
++static const S16 LL_defaultNorm[MaxLL + 1] = {4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1, -1, -1, -1, -1};
-+									 13,14,15,16 };
-+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
-+											 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
-+											-1,-1,-1,-1 };
 +#define LL_DEFAULTNORMLOG 6 /* for static allocation */
 +static const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;
 +
-+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++static const U32 ML_bits[MaxML + 1] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0, 0,
-+									  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++				       0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-+									  1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11,
++static const S16 ML_defaultNorm[MaxML + 1] = {1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,  1,  1,  1,  1, 1,
-+									 12,13,14,15,16 };
++					      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1};
-+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
-+											 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-+											 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
-+											-1,-1,-1,-1,-1 };
 +#define ML_DEFAULTNORMLOG 6 /* for static allocation */
 +static const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;
 +
-+static const S16 OF_defaultNorm[MaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
++static const S16 OF_defaultNorm[MaxOff + 1] = {1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1};
-+											  1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };
 +#define OF_DEFAULTNORMLOG 5 /* for static allocation */
 +static const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
 +
-+
 +/*-*******************************************
 +*  Shared functions to include for inlining
 +*********************************************/
 +static void ZSTD_copy8(void *dst, const void *src) { memcpy(dst, src, 8); }
-+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
++#define COPY8(d, s)               \
++	{                         \
++		ZSTD_copy8(d, s); \
++		d += 8;           \
++		s += 8;           \
++	}
 +
 +/*! ZSTD_wildcopy() :
 +*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
 +#define WILDCOPY_OVERLENGTH 8
-+MEM_STATIC void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
++ZSTD_STATIC void ZSTD_wildcopy(void *dst, const void *src, ptrdiff_t length)
 +{
 +	const BYTE *ip = (const BYTE *)src;
 +	BYTE *op = (BYTE *)dst;
@@ -11428,7 +11929,7 @@ index 0000000..91365ea
 +	while (op < oend);
 +}
 +
-+MEM_STATIC void ZSTD_wildcopy_e(void* dst, const void* src, void* dstEnd)   /* should be faster for decoding, but strangely, not verified on all platform */
++ZSTD_STATIC void ZSTD_wildcopy_e(void *dst, const void *src, void *dstEnd) /* should be faster for decoding, but strangely, not verified on all platform */
 +{
 +	const BYTE *ip = (const BYTE *)src;
 +	BYTE *op = (BYTE *)dst;
@@ -11438,7 +11939,6 @@ index 0000000..91365ea
 +	while (op < oend);
 +}
 +
-+
 +/*-*******************************************
 +*  Private interfaces
 +*********************************************/
@@ -11457,14 +11957,12 @@ index 0000000..91365ea
 +	U32 rep[ZSTD_REP_NUM];
 +} ZSTD_optimal_t;
 +
-+
 +typedef struct seqDef_s {
 +	U32 offset;
 +	U16 litLength;
 +	U16 matchLength;
 +} seqDef;
 +
-+
 +typedef struct {
 +	seqDef *sequencesStart;
 +	seqDef *sequences;
@@ -11506,7 +12004,11 @@ index 0000000..91365ea
 +/*= Custom memory allocation functions */
 +typedef void *(*ZSTD_allocFunction)(void *opaque, size_t size);
 +typedef void (*ZSTD_freeFunction)(void *opaque, void *address);
-+typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
++typedef struct {
++	ZSTD_allocFunction customAlloc;
++	ZSTD_freeFunction customFree;
++	void *opaque;
++} ZSTD_customMem;
 +
 +void *ZSTD_malloc(size_t size, ZSTD_customMem customMem);
 +void ZSTD_free(void *ptr, ZSTD_customMem customMem);
@@ -11527,14 +12029,9 @@ index 0000000..91365ea
 +void *ZSTD_stackAlloc(void *opaque, size_t size);
 +void ZSTD_stackFree(void *opaque, void *address);
 +
-+
 +/*======  common function  ======*/
 +
-+MEM_STATIC U32 ZSTD_highbit32(U32 val)
++ZSTD_STATIC U32 ZSTD_highbit32(U32 val) { return 31 - __builtin_clz(val); }
-+{
-+	return 31 - __builtin_clz(val);
-+}
-+
 +
 +/* hidden functions */
 +
@@ -11551,14 +12048,13 @@ index 0000000..91365ea
 +size_t ZSTD_freeCStream(ZSTD_CStream *zcs);
 +size_t ZSTD_freeDStream(ZSTD_DStream *zds);
 +
-+
 +#endif /* ZSTD_CCOMMON_H_MODULE */
 diff --git a/lib/zstd/zstd_opt.h b/lib/zstd/zstd_opt.h
 new file mode 100644
-index 0000000..6855e3c
+index 0000000..468c143
 --- /dev/null
 +++ b/lib/zstd/zstd_opt.h
-@@ -0,0 +1,928 @@
+@@ -0,0 +1,1014 @@
 +/**
 + * Copyright (c) 2016-present, Przemyslaw Skibinski, Yann Collet, Facebook, Inc.
 + * All rights reserved.
@@ -11575,14 +12071,11 @@ index 0000000..6855e3c
 + * ("BSD").
 + */
 +
-+
 +/* Note : this file is intended to be included within zstd_compress.c */
 +
-+
 +#ifndef ZSTD_OPT_H_91842398743
 +#define ZSTD_OPT_H_91842398743
 +
-+
 +#define ZSTD_LITFREQ_ADD 2
 +#define ZSTD_FREQ_DIV 4
 +#define ZSTD_MAX_PRICE (1 << 30)
@@ -11599,8 +12092,7 @@ index 0000000..6855e3c
 +	ssPtr->factor = 1 + ((ssPtr->litSum >> 5) / ssPtr->litLengthSum) + ((ssPtr->litSum << 1) / (ssPtr->litSum + ssPtr->matchSum));
 +}
 +
-+
++ZSTD_STATIC void ZSTD_rescaleFreqs(seqStore_t *ssPtr, const BYTE *src, size_t srcSize)
-+MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr, const BYTE* src, size_t srcSize)
 +{
 +	unsigned u;
 +
@@ -11609,7 +12101,8 @@ index 0000000..6855e3c
 +	ssPtr->staticPrices = 0;
 +
 +	if (ssPtr->litLengthSum == 0) {
-+		if (srcSize <= 1024) ssPtr->staticPrices = 1;
++		if (srcSize <= 1024)
++			ssPtr->staticPrices = 1;
 +
 +		for (u = 0; u <= MaxLit; u++)
 +			ssPtr->litFreq[u] = 0;
@@ -11662,7 +12155,6 @@ index 0000000..6855e3c
 +	ZSTD_setLog2Prices(ssPtr);
 +}
 +
-+
 +FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t *ssPtr, U32 litLength, const BYTE *literals)
 +{
 +	U32 price, u;
@@ -11695,7 +12187,8 @@ index 0000000..6855e3c
 +	}
 +
 +	/* literal Length */
-+	{	const BYTE LL_deltaCode = 19;
++	{
++		const BYTE LL_deltaCode = 19;
 +		const BYTE llCode = (litLength > 63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
 +		price += LL_bits[llCode] + ssPtr->log2litLengthSum - ZSTD_highbit32(ssPtr->litLengthFreq[llCode] + 1);
 +	}
@@ -11703,7 +12196,6 @@ index 0000000..6855e3c
 +	return price;
 +}
 +
-+
 +FORCE_INLINE U32 ZSTD_getPrice(seqStore_t *seqStorePtr, U32 litLength, const BYTE *literals, U32 offset, U32 matchLength, const int ultra)
 +{
 +	/* offset */
@@ -11714,10 +12206,12 @@ index 0000000..6855e3c
 +		return ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + ZSTD_highbit32((U32)matchLength + 1) + 16 + offCode;
 +
 +	price = offCode + seqStorePtr->log2offCodeSum - ZSTD_highbit32(seqStorePtr->offCodeFreq[offCode] + 1);
-+	if (!ultra && offCode >= 20) price += (offCode-19)*2;
++	if (!ultra && offCode >= 20)
++		price += (offCode - 19) * 2;
 +
 +	/* match Length */
-+	{	const BYTE ML_deltaCode = 36;
++	{
++		const BYTE ML_deltaCode = 36;
 +		const BYTE mlCode = (matchLength > 127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
 +		price += ML_bits[mlCode] + seqStorePtr->log2matchLengthSum - ZSTD_highbit32(seqStorePtr->matchLengthFreq[mlCode] + 1);
 +	}
@@ -11725,8 +12219,7 @@ index 0000000..6855e3c
 +	return price + ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + seqStorePtr->factor;
 +}
 +
-+
++ZSTD_STATIC void ZSTD_updatePrice(seqStore_t *seqStorePtr, U32 litLength, const BYTE *literals, U32 offset, U32 matchLength)
-+MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
 +{
 +	U32 u;
 +
@@ -11736,20 +12229,23 @@ index 0000000..6855e3c
 +		seqStorePtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
 +
 +	/* literal Length */
-+	{	const BYTE LL_deltaCode = 19;
++	{
++		const BYTE LL_deltaCode = 19;
 +		const BYTE llCode = (litLength > 63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
 +		seqStorePtr->litLengthFreq[llCode]++;
 +		seqStorePtr->litLengthSum++;
 +	}
 +
 +	/* match offset */
-+	{	BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
++	{
++		BYTE const offCode = (BYTE)ZSTD_highbit32(offset + 1);
 +		seqStorePtr->offCodeSum++;
 +		seqStorePtr->offCodeFreq[offCode]++;
 +	}
 +
 +	/* match Length */
-+	{	const BYTE ML_deltaCode = 36;
++	{
++		const BYTE ML_deltaCode = 36;
 +		const BYTE mlCode = (matchLength > 127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
 +		seqStorePtr->matchLengthFreq[mlCode]++;
 +		seqStorePtr->matchLengthSum++;
@@ -11758,18 +12254,18 @@ index 0000000..6855e3c
 +	ZSTD_setLog2Prices(seqStorePtr);
 +}
 +
-+
 +#define SET_PRICE(pos, mlen_, offset_, litlen_, price_)           \
 +	{                                                         \
-+		while (last_pos < pos)  { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } \
++		while (last_pos < pos) {                          \
++			opt[last_pos + 1].price = ZSTD_MAX_PRICE; \
++			last_pos++;                               \
++		}                                                 \
 +		opt[pos].mlen = mlen_;                            \
 +		opt[pos].off = offset_;                           \
 +		opt[pos].litlen = litlen_;                        \
 +		opt[pos].price = price_;                          \
 +	}
 +
-+
-+
 +/* Update hashTable3 up to ip (excluded)
 +   Assumption : always within prefix (i.e. not within extDict) */
 +FORCE_INLINE
@@ -11790,15 +12286,11 @@ index 0000000..6855e3c
 +	return hashTable3[hash3];
 +}
 +
-+
 +/*-*************************************
 +*  Binary Tree search
 +***************************************/
-+static U32 ZSTD_insertBtAndGetAllMatches (
++static U32 ZSTD_insertBtAndGetAllMatches(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iLimit, U32 nbCompares, const U32 mls, U32 extDict,
-+						ZSTD_CCtx* zc,
++					 ZSTD_match_t *matches, const U32 minMatchLen)
-+						const BYTE* const ip, const BYTE* const iLimit,
-+						U32 nbCompares, const U32 mls,
-+						U32 extDict, ZSTD_match_t* matches, const U32 minMatchLen)
 +{
 +	const BYTE *const base = zc->base;
 +	const U32 curr = (U32)(ip - base);
@@ -11832,10 +12324,12 @@ index 0000000..6855e3c
 +			size_t currMl = 0;
 +			if ((!extDict) || matchIndex3 >= dictLimit) {
 +				match = base + matchIndex3;
-+				if (match[bestLength] == ip[bestLength]) currMl = ZSTD_count(ip, match, iLimit);
++				if (match[bestLength] == ip[bestLength])
++					currMl = ZSTD_count(ip, match, iLimit);
 +			} else {
 +				match = dictBase + matchIndex3;
-+				if (MEM_readMINMATCH(match, MINMATCH) == MEM_readMINMATCH(ip, MINMATCH))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
++				if (ZSTD_readMINMATCH(match, MINMATCH) ==
++				    ZSTD_readMINMATCH(ip, MINMATCH)) /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
 +					currMl = ZSTD_count_2segments(ip + MINMATCH, match + MINMATCH, iLimit, dictEnd, prefixStart) + MINMATCH;
 +			}
 +
@@ -11845,8 +12339,10 @@ index 0000000..6855e3c
 +				matches[mnum].off = ZSTD_REP_MOVE_OPT + curr - matchIndex3;
 +				matches[mnum].len = (U32)currMl;
 +				mnum++;
-+				if (currMl > ZSTD_OPT_NUM) goto update;
++				if (currMl > ZSTD_OPT_NUM)
-+				if (ip+currMl == iLimit) goto update; /* best possible, and avoid read overflow*/
++					goto update;
++				if (ip + currMl == iLimit)
++					goto update; /* best possible, and avoid read overflow*/
 +			}
 +		}
 +	}
@@ -11871,12 +12367,14 @@ index 0000000..6855e3c
 +		}
 +
 +		if (matchLength > bestLength) {
-+			if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength;
++			if (matchLength > matchEndIdx - matchIndex)
++				matchEndIdx = matchIndex + (U32)matchLength;
 +			bestLength = matchLength;
 +			matches[mnum].off = ZSTD_REP_MOVE_OPT + curr - matchIndex;
 +			matches[mnum].len = (U32)matchLength;
 +			mnum++;
-+			if (matchLength > ZSTD_OPT_NUM) break;
++			if (matchLength > ZSTD_OPT_NUM)
++				break;
 +			if (ip + matchLength == iLimit) /* equal : no way to know if inf or sup */
 +				break;			/* drop, to guarantee consistency (miss a little bit of compression) */
 +		}
@@ -11885,17 +12383,24 @@ index 0000000..6855e3c
 +			/* match is smaller than curr */
 +			*smallerPtr = matchIndex;	  /* update smaller idx */
 +			commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */
-+			if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				smallerPtr = &dummy32;
++				break;
++			}			  /* beyond tree size, stop the search */
 +			smallerPtr = nextPtr + 1; /* new "smaller" => larger of match */
 +			matchIndex = nextPtr[1];  /* new matchIndex larger than previous (closer to curr) */
 +		} else {
 +			/* match is larger than curr */
 +			*largerPtr = matchIndex;
 +			commonLengthLarger = matchLength;
-+			if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
++			if (matchIndex <= btLow) {
++				largerPtr = &dummy32;
++				break;
++			} /* beyond tree size, stop the search */
 +			largerPtr = nextPtr;
 +			matchIndex = nextPtr[0];
-+	}   }
++		}
++	}
 +
 +	*smallerPtr = *largerPtr = 0;
 +
@@ -11904,26 +12409,21 @@ index 0000000..6855e3c
 +	return mnum;
 +}
 +
-+
 +/** Tree updater, providing best match */
-+static U32 ZSTD_BtGetAllMatches (
++static U32 ZSTD_BtGetAllMatches(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iLimit, const U32 maxNbAttempts, const U32 mls, ZSTD_match_t *matches,
-+						ZSTD_CCtx* zc,
++				const U32 minMatchLen)
-+						const BYTE* const ip, const BYTE* const iLimit,
-+						const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
 +{
-+	if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
++	if (ip < zc->base + zc->nextToUpdate)
++		return 0; /* skipped area */
 +	ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
 +	return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, matches, minMatchLen);
 +}
 +
-+
++static U32 ZSTD_BtGetAllMatches_selectMLS(ZSTD_CCtx *zc, /* Index table will be updated */
-+static U32 ZSTD_BtGetAllMatches_selectMLS (
++					  const BYTE *ip, const BYTE *const iHighLimit, const U32 maxNbAttempts, const U32 matchLengthSearch,
-+						ZSTD_CCtx* zc,   /* Index table will be updated */
++					  ZSTD_match_t *matches, const U32 minMatchLen)
-+						const BYTE* ip, const BYTE* const iHighLimit,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	case 3: return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
 +	default:
 +	case 4: return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
@@ -11934,24 +12434,20 @@ index 0000000..6855e3c
 +}
 +
 +/** Tree updater, providing best match */
-+static U32 ZSTD_BtGetAllMatches_extDict (
++static U32 ZSTD_BtGetAllMatches_extDict(ZSTD_CCtx *zc, const BYTE *const ip, const BYTE *const iLimit, const U32 maxNbAttempts, const U32 mls,
-+						ZSTD_CCtx* zc,
++					ZSTD_match_t *matches, const U32 minMatchLen)
-+						const BYTE* const ip, const BYTE* const iLimit,
-+						const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
 +{
-+	if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
++	if (ip < zc->base + zc->nextToUpdate)
++		return 0; /* skipped area */
 +	ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
 +	return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, matches, minMatchLen);
 +}
 +
-+
++static U32 ZSTD_BtGetAllMatches_selectMLS_extDict(ZSTD_CCtx *zc, /* Index table will be updated */
-+static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
++						  const BYTE *ip, const BYTE *const iHighLimit, const U32 maxNbAttempts, const U32 matchLengthSearch,
-+						ZSTD_CCtx* zc,   /* Index table will be updated */
++						  ZSTD_match_t *matches, const U32 minMatchLen)
-+						const BYTE* ip, const BYTE* const iHighLimit,
-+						const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
-+{
-+	switch(matchLengthSearch)
 +{
++	switch (matchLengthSearch) {
 +	case 3: return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
 +	default:
 +	case 4: return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
@@ -11961,13 +12457,11 @@ index 0000000..6855e3c
 +	}
 +}
 +
-+
 +/*-*******************************
 +*  Optimal parser
 +*********************************/
 +FORCE_INLINE
-+void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
++void ZSTD_compressBlock_opt_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const int ultra)
-+									const void* src, size_t srcSize, const int ultra)
 +{
 +	seqStore_t *seqStorePtr = &(ctx->seqStore);
 +	const BYTE *const istart = (const BYTE *)src;
@@ -11992,7 +12486,11 @@ index 0000000..6855e3c
 +	ctx->nextToUpdate3 = ctx->nextToUpdate;
 +	ZSTD_rescaleFreqs(seqStorePtr, (const BYTE *)src, srcSize);
 +	ip += (ip == prefixStart);
-+	{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=ctx->rep[i]; }
++	{
++		U32 i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			rep[i] = ctx->rep[i];
++	}
 +
 +	/* Match Loop */
 +	while (ip < ilimit) {
@@ -12003,14 +12501,18 @@ index 0000000..6855e3c
 +		litlen = (U32)(ip - anchor);
 +
 +		/* check repCode */
-+		{	U32 i, last_i = ZSTD_REP_CHECK + (ip==anchor);
++		{
++			U32 i, last_i = ZSTD_REP_CHECK + (ip == anchor);
 +			for (i = (ip == anchor); i < last_i; i++) {
 +				const S32 repCur = (i == ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
-+				if ( (repCur > 0) && (repCur < (S32)(ip-prefixStart))
++				if ((repCur > 0) && (repCur < (S32)(ip - prefixStart)) &&
-+					&& (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(ip - repCur, minMatch))) {
++				    (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repCur, minMatch))) {
 +					mlen = (U32)ZSTD_count(ip + minMatch, ip + minMatch - repCur, iend) + minMatch;
 +					if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
-+						best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
++						best_mlen = mlen;
++						best_off = i;
++						cur = 0;
++						last_pos = 1;
 +						goto _storeSequence;
 +					}
 +					best_off = i - (ip == anchor);
@@ -12020,11 +12522,16 @@ index 0000000..6855e3c
 +							SET_PRICE(mlen, mlen, i, litlen, price); /* note : macro modifies last_pos */
 +						mlen--;
 +					} while (mlen >= minMatch);
-+		}   }   }
++				}
++			}
++		}
 +
 +		match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
 +
-+		if (!last_pos && !match_num) { ip++; continue; }
++		if (!last_pos && !match_num) {
++			ip++;
++			continue;
++		}
 +
 +		if (match_num && (matches[match_num - 1].len > sufficient_len || matches[match_num - 1].len >= ZSTD_OPT_NUM)) {
 +			best_mlen = matches[match_num - 1].len;
@@ -12044,12 +12551,20 @@ index 0000000..6855e3c
 +				if (mlen > last_pos || price < opt[mlen].price)
 +					SET_PRICE(mlen, mlen, matches[u].off, litlen, price); /* note : macro modifies last_pos */
 +				mlen++;
-+		}   }
++			}
++		}
 +
-+		if (last_pos < minMatch) { ip++; continue; }
++		if (last_pos < minMatch) {
++			ip++;
++			continue;
++		}
 +
 +		/* initialize opt[0] */
-+		{ U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				opt[0].rep[i] = rep[i];
++		}
 +		opt[0].mlen = 1;
 +		opt[0].litlen = litlen;
 +
@@ -12071,7 +12586,8 @@ index 0000000..6855e3c
 +			if (cur > last_pos || price <= opt[cur].price)
 +				SET_PRICE(cur, 1, 0, litlen, price);
 +
-+		   if (cur == last_pos) break;
++			if (cur == last_pos)
++				break;
 +
 +			if (inr > ilimit) /* last match must start at a minimum distance of 8 from oend */
 +				continue;
@@ -12084,30 +12600,36 @@ index 0000000..6855e3c
 +			} else {
 +				opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur - mlen].rep[1] : opt[cur - mlen].rep[2];
 +				opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur - mlen].rep[0] : opt[cur - mlen].rep[1];
-+				opt[cur].rep[0] = ((opt[cur].off==ZSTD_REP_MOVE_OPT) && (mlen != 1)) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
++				opt[cur].rep[0] =
++				    ((opt[cur].off == ZSTD_REP_MOVE_OPT) && (mlen != 1)) ? (opt[cur - mlen].rep[0] - 1) : (opt[cur - mlen].rep[opt[cur].off]);
 +			}
 +
 +			best_mlen = minMatch;
-+			{	U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
++			{
++				U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
 +				for (i = (opt[cur].mlen != 1); i < last_i; i++) { /* check rep */
 +					const S32 repCur = (i == ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[i];
-+					if ( (repCur > 0) && (repCur < (S32)(inr-prefixStart))
++					if ((repCur > 0) && (repCur < (S32)(inr - prefixStart)) &&
-+					   && (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(inr - repCur, minMatch))) {
++					    (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(inr - repCur, minMatch))) {
 +						mlen = (U32)ZSTD_count(inr + minMatch, inr + minMatch - repCur, iend) + minMatch;
 +
 +						if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-+							best_mlen = mlen; best_off = i; last_pos = cur + 1;
++							best_mlen = mlen;
++							best_off = i;
++							last_pos = cur + 1;
 +							goto _storeSequence;
 +						}
 +
 +						best_off = i - (opt[cur].mlen != 1);
-+					   if (mlen > best_mlen) best_mlen = mlen;
++						if (mlen > best_mlen)
++							best_mlen = mlen;
 +
 +						do {
 +							if (opt[cur].mlen == 1) {
 +								litlen = opt[cur].litlen;
 +								if (cur > litlen) {
-+									price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
++									price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr - litlen,
++															best_off, mlen - MINMATCH, ultra);
 +								} else
 +									price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
 +							} else {
@@ -12119,7 +12641,9 @@ index 0000000..6855e3c
 +								SET_PRICE(cur + mlen, mlen, i, litlen, price);
 +							mlen--;
 +						} while (mlen >= minMatch);
-+			}   }   }
++					}
++				}
++			}
 +
 +			match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen);
 +
@@ -12139,7 +12663,8 @@ index 0000000..6855e3c
 +					if (opt[cur].mlen == 1) {
 +						litlen = opt[cur].litlen;
 +						if (cur > litlen)
-+							price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
++							price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip + cur - litlen,
++													matches[u].off - 1, mlen - MINMATCH, ultra);
 +						else
 +							price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off - 1, mlen - MINMATCH, ultra);
 +					} else {
@@ -12151,7 +12676,9 @@ index 0000000..6855e3c
 +						SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
 +
 +					mlen++;
-+		}   }   }
++				}
++			}
++		}
 +
 +		best_mlen = opt[last_pos].mlen;
 +		best_off = opt[last_pos].off;
@@ -12168,7 +12695,8 @@ index 0000000..6855e3c
 +			opt[cur].off = best_off;
 +			best_mlen = mlen;
 +			best_off = offset;
-+			if (mlen > cur) break;
++			if (mlen > cur)
++				break;
 +			cur -= mlen;
 +		}
 +
@@ -12178,7 +12706,11 @@ index 0000000..6855e3c
 +
 +		for (cur = 0; cur < last_pos;) {
 +			mlen = opt[cur].mlen;
-+			if (mlen == 1) { ip++; cur++; continue; }
++			if (mlen == 1) {
++				ip++;
++				cur++;
++				continue;
++			}
 +			offset = opt[cur].off;
 +			cur += mlen;
 +			litLength = (U32)(ip - anchor);
@@ -12191,32 +12723,38 @@ index 0000000..6855e3c
 +			} else {
 +				if (offset != 0) {
 +					best_off = (offset == ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : (rep[offset]);
-+					if (offset != 1) rep[2] = rep[1];
++					if (offset != 1)
++						rep[2] = rep[1];
 +					rep[1] = rep[0];
 +					rep[0] = best_off;
 +				}
-+				if (litLength==0) offset--;
++				if (litLength == 0)
++					offset--;
 +			}
 +
 +			ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen - MINMATCH);
 +			ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen - MINMATCH);
 +			anchor = ip = ip + mlen;
-+	}    }   /* for (cur=0; cur < last_pos; ) */
++		}
++	} /* for (cur=0; cur < last_pos; ) */
 +
 +	/* Save reps for next block */
-+	{ int i; for (i=0; i<ZSTD_REP_NUM; i++) ctx->repToConfirm[i] = rep[i]; }
++	{
++		int i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			ctx->repToConfirm[i] = rep[i];
++	}
 +
 +	/* Last Literals */
-+	{	size_t const lastLLSize = iend - anchor;
++	{
++		size_t const lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}
 +}
 +
-+
 +FORCE_INLINE
-+void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
++void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx *ctx, const void *src, size_t srcSize, const int ultra)
-+									 const void* src, size_t srcSize, const int ultra)
 +{
 +	seqStore_t *seqStorePtr = &(ctx->seqStore);
 +	const BYTE *const istart = (const BYTE *)src;
@@ -12242,7 +12780,11 @@ index 0000000..6855e3c
 +
 +	/* init */
 +	U32 offset, rep[ZSTD_REP_NUM];
-+	{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=ctx->rep[i]; }
++	{
++		U32 i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			rep[i] = ctx->rep[i];
++	}
 +
 +	ctx->nextToUpdate3 = ctx->nextToUpdate;
 +	ZSTD_rescaleFreqs(seqStorePtr, (const BYTE *)src, srcSize);
@@ -12258,21 +12800,25 @@ index 0000000..6855e3c
 +		opt[0].litlen = (U32)(ip - anchor);
 +
 +		/* check repCode */
-+		{	U32 i, last_i = ZSTD_REP_CHECK + (ip==anchor);
++		{
++			U32 i, last_i = ZSTD_REP_CHECK + (ip == anchor);
 +			for (i = (ip == anchor); i < last_i; i++) {
 +				const S32 repCur = (i == ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
 +				const U32 repIndex = (U32)(curr - repCur);
 +				const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +				const BYTE *const repMatch = repBase + repIndex;
-+				if ( (repCur > 0 && repCur <= (S32)curr)
++				if ((repCur > 0 && repCur <= (S32)curr) &&
-+				   && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>lowestIndex))  /* intentional overflow */
++				    (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+				   && (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
++				    && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch))) {
 +					/* repcode detected we should take it */
 +					const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
 +					mlen = (U32)ZSTD_count_2segments(ip + minMatch, repMatch + minMatch, iend, repEnd, prefixStart) + minMatch;
 +
 +					if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
-+						best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
++						best_mlen = mlen;
++						best_off = i;
++						cur = 0;
++						last_pos = 1;
 +						goto _storeSequence;
 +					}
 +
@@ -12284,13 +12830,22 @@ index 0000000..6855e3c
 +							SET_PRICE(mlen, mlen, i, litlen, price); /* note : macro modifies last_pos */
 +						mlen--;
 +					} while (mlen >= minMatch);
-+		}   }   }
++				}
++			}
++		}
 +
 +		match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, matches, minMatch); /* first search (depth 0) */
 +
-+		if (!last_pos && !match_num) { ip++; continue; }
++		if (!last_pos && !match_num) {
++			ip++;
++			continue;
++		}
 +
-+		{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
++		{
++			U32 i;
++			for (i = 0; i < ZSTD_REP_NUM; i++)
++				opt[0].rep[i] = rep[i];
++		}
 +		opt[0].mlen = 1;
 +
 +		if (match_num && (matches[match_num - 1].len > sufficient_len || matches[match_num - 1].len >= ZSTD_OPT_NUM)) {
@@ -12313,10 +12868,12 @@ index 0000000..6855e3c
 +				if (mlen > last_pos || price < opt[mlen].price)
 +					SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
 +				mlen++;
-+		}   }
++			}
++		}
 +
 +		if (last_pos < minMatch) {
-+			ip++; continue;
++			ip++;
++			continue;
 +		}
 +
 +		/* check further positions */
@@ -12337,7 +12894,8 @@ index 0000000..6855e3c
 +			if (cur > last_pos || price <= opt[cur].price)
 +				SET_PRICE(cur, 1, 0, litlen, price);
 +
-+			if (cur == last_pos) break;
++			if (cur == last_pos)
++				break;
 +
 +			if (inr > ilimit) /* last match must start at a minimum distance of 8 from oend */
 +				continue;
@@ -12350,36 +12908,42 @@ index 0000000..6855e3c
 +			} else {
 +				opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur - mlen].rep[1] : opt[cur - mlen].rep[2];
 +				opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur - mlen].rep[0] : opt[cur - mlen].rep[1];
-+				opt[cur].rep[0] = ((opt[cur].off==ZSTD_REP_MOVE_OPT) && (mlen != 1)) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
++				opt[cur].rep[0] =
++				    ((opt[cur].off == ZSTD_REP_MOVE_OPT) && (mlen != 1)) ? (opt[cur - mlen].rep[0] - 1) : (opt[cur - mlen].rep[opt[cur].off]);
 +			}
 +
 +			best_mlen = minMatch;
-+			{	U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
++			{
++				U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
 +				for (i = (mlen != 1); i < last_i; i++) {
 +					const S32 repCur = (i == ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[i];
 +					const U32 repIndex = (U32)(curr + cur - repCur);
 +					const BYTE *const repBase = repIndex < dictLimit ? dictBase : base;
 +					const BYTE *const repMatch = repBase + repIndex;
-+					if ( (repCur > 0 && repCur <= (S32)(curr+cur))
++					if ((repCur > 0 && repCur <= (S32)(curr + cur)) &&
-+					  && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>lowestIndex))  /* intentional overflow */
++					    (((U32)((dictLimit - 1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */
-+					  && (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
++					    && (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch))) {
 +						/* repcode detected */
 +						const BYTE *const repEnd = repIndex < dictLimit ? dictEnd : iend;
 +						mlen = (U32)ZSTD_count_2segments(inr + minMatch, repMatch + minMatch, iend, repEnd, prefixStart) + minMatch;
 +
 +						if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-+							best_mlen = mlen; best_off = i; last_pos = cur + 1;
++							best_mlen = mlen;
++							best_off = i;
++							last_pos = cur + 1;
 +							goto _storeSequence;
 +						}
 +
 +						best_off = i - (opt[cur].mlen != 1);
-+						if (mlen > best_mlen) best_mlen = mlen;
++						if (mlen > best_mlen)
++							best_mlen = mlen;
 +
 +						do {
 +							if (opt[cur].mlen == 1) {
 +								litlen = opt[cur].litlen;
 +								if (cur > litlen) {
-+									price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
++									price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr - litlen,
++															best_off, mlen - MINMATCH, ultra);
 +								} else
 +									price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
 +							} else {
@@ -12391,7 +12955,9 @@ index 0000000..6855e3c
 +								SET_PRICE(cur + mlen, mlen, i, litlen, price);
 +							mlen--;
 +						} while (mlen >= minMatch);
-+			}   }   }
++					}
++				}
++			}
 +
 +			match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, matches, minMatch);
 +
@@ -12411,7 +12977,8 @@ index 0000000..6855e3c
 +					if (opt[cur].mlen == 1) {
 +						litlen = opt[cur].litlen;
 +						if (cur > litlen)
-+							price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
++							price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip + cur - litlen,
++													matches[u].off - 1, mlen - MINMATCH, ultra);
 +						else
 +							price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off - 1, mlen - MINMATCH, ultra);
 +					} else {
@@ -12423,7 +12990,9 @@ index 0000000..6855e3c
 +						SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
 +
 +					mlen++;
-+		}   }   }   /* for (cur = 1; cur <= last_pos; cur++) */
++				}
++			}
++		} /* for (cur = 1; cur <= last_pos; cur++) */
 +
 +		best_mlen = opt[last_pos].mlen;
 +		best_off = opt[last_pos].off;
@@ -12440,7 +13009,8 @@ index 0000000..6855e3c
 +			opt[cur].off = best_off;
 +			best_mlen = mlen;
 +			best_off = offset;
-+			if (mlen > cur) break;
++			if (mlen > cur)
++				break;
 +			cur -= mlen;
 +		}
 +
@@ -12450,7 +13020,11 @@ index 0000000..6855e3c
 +
 +		for (cur = 0; cur < last_pos;) {
 +			mlen = opt[cur].mlen;
-+			if (mlen == 1) { ip++; cur++; continue; }
++			if (mlen == 1) {
++				ip++;
++				cur++;
++				continue;
++			}
 +			offset = opt[cur].off;
 +			cur += mlen;
 +			litLength = (U32)(ip - anchor);
@@ -12463,24 +13037,32 @@ index 0000000..6855e3c
 +			} else {
 +				if (offset != 0) {
 +					best_off = (offset == ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : (rep[offset]);
-+					if (offset != 1) rep[2] = rep[1];
++					if (offset != 1)
++						rep[2] = rep[1];
 +					rep[1] = rep[0];
 +					rep[0] = best_off;
 +				}
 +
-+				if (litLength==0) offset--;
++				if (litLength == 0)
++					offset--;
 +			}
 +
 +			ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen - MINMATCH);
 +			ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen - MINMATCH);
 +			anchor = ip = ip + mlen;
-+	}    }   /* for (cur=0; cur < last_pos; ) */
++		}
++	} /* for (cur=0; cur < last_pos; ) */
 +
 +	/* Save reps for next block */
-+	{ int i; for (i=0; i<ZSTD_REP_NUM; i++) ctx->repToConfirm[i] = rep[i]; }
++	{
++		int i;
++		for (i = 0; i < ZSTD_REP_NUM; i++)
++			ctx->repToConfirm[i] = rep[i];
++	}
 +
 +	/* Last Literals */
-+	{	size_t lastLLSize = iend - anchor;
++	{
++		size_t lastLLSize = iend - anchor;
 +		memcpy(seqStorePtr->lit, anchor, lastLLSize);
 +		seqStorePtr->lit += lastLLSize;
 +	}