Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 289 insertions, 289 deletions

diff --git a/contrib/libs/zstd/lib/zstd.h b/contrib/libs/zstd/lib/zstd.h
index a88ae7bf8ed..8d25f23bfe8 100644
--- a/contrib/libs/zstd/lib/zstd.h
+++ b/contrib/libs/zstd/lib/zstd.h
@@ -2,10 +2,10 @@
  * Copyright (c) Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
+ * This source code is licensed under both the BSD-style license (found in the 
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
+ * in the COPYING file in the root directory of this source tree). 
+ * You may select, at your option, one of the above-listed licenses. 
  */
 #if defined (__cplusplus)
 extern "C" {
@@ -24,12 +24,12 @@ extern "C" {
 #  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
 #    define ZSTDLIB_VISIBLE __attribute__ ((visibility ("default")))
 #    define ZSTDLIB_HIDDEN __attribute__ ((visibility ("hidden")))
-#  else
+#  else 
 #    define ZSTDLIB_VISIBLE
 #    define ZSTDLIB_HIDDEN
-#  endif
-#endif
-#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  endif 
+#endif 
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) 
 #  define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBLE
 #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
 #  define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
@@ -54,7 +54,7 @@ extern "C" {
 
   Compression can be done in:
     - a single step (described as Simple API)
-    - a single step, reusing a context (described as Explicit context)
+    - a single step, reusing a context (described as Explicit context) 
     - unbounded multiple steps (described as Streaming compression)
 
   The compression ratio achievable on small data can be highly improved using
@@ -75,8 +75,8 @@ extern "C" {
 #define ZSTD_VERSION_MAJOR    1
 #define ZSTD_VERSION_MINOR    5
 #define ZSTD_VERSION_RELEASE  2
-#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) 
+ 
 /*! ZSTD_versionNumber() :
  *  Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE). */
 ZSTDLIB_API unsigned ZSTD_versionNumber(void);
@@ -115,55 +115,55 @@ ZSTDLIB_API const char* ZSTD_versionString(void);
 *  Simple API
 ***************************************/
 /*! ZSTD_compress() :
- *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
- *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
- *  @return : compressed size written into `dst` (<= `dstCapacity),
- *            or an error code if it fails (which can be tested using ZSTD_isError()). */
+ *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`. 
+ *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`. 
+ *  @return : compressed size written into `dst` (<= `dstCapacity), 
+ *            or an error code if it fails (which can be tested using ZSTD_isError()). */ 
 ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,
                             const void* src, size_t srcSize,
                                   int compressionLevel);
 
 /*! ZSTD_decompress() :
- *  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
- *  `dstCapacity` is an upper bound of originalSize to regenerate.
- *  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
- *  @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
- *            or an errorCode if it fails (which can be tested using ZSTD_isError()). */
+ *  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames. 
+ *  `dstCapacity` is an upper bound of originalSize to regenerate. 
+ *  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data. 
+ *  @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), 
+ *            or an errorCode if it fails (which can be tested using ZSTD_isError()). */ 
 ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
                               const void* src, size_t compressedSize);
 
 /*! ZSTD_getFrameContentSize() : requires v1.3.0+
- *  `src` should point to the start of a ZSTD encoded frame.
- *  `srcSize` must be at least as large as the frame header.
- *            hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
+ *  `src` should point to the start of a ZSTD encoded frame. 
+ *  `srcSize` must be at least as large as the frame header. 
+ *            hint : any size >= `ZSTD_frameHeaderSize_max` is large enough. 
  *  @return : - decompressed size of `src` frame content, if known
- *            - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
- *            - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
- *   note 1 : a 0 return value means the frame is valid but "empty".
- *   note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode.
- *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *            Optionally, application can rely on some implicit limit,
- *            as ZSTD_decompress() only needs an upper bound of decompressed size.
- *            (For example, data could be necessarily cut into blocks <= 16 KB).
+ *            - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined 
+ *            - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) 
+ *   note 1 : a 0 return value means the frame is valid but "empty". 
+ *   note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode. 
+ *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. 
+ *            In which case, it's necessary to use streaming mode to decompress data. 
+ *            Optionally, application can rely on some implicit limit, 
+ *            as ZSTD_decompress() only needs an upper bound of decompressed size. 
+ *            (For example, data could be necessarily cut into blocks <= 16 KB). 
  *   note 3 : decompressed size is always present when compression is completed using single-pass functions,
  *            such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().
- *   note 4 : decompressed size can be very large (64-bits value),
- *            potentially larger than what local system can handle as a single memory segment.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.
- *            Always ensure return value fits within application's authorized limits.
- *            Each application can set its own limits.
- *   note 6 : This function replaces ZSTD_getDecompressedSize() */
-#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
-#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
-ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);
-
+ *   note 4 : decompressed size can be very large (64-bits value), 
+ *            potentially larger than what local system can handle as a single memory segment. 
+ *            In which case, it's necessary to use streaming mode to decompress data. 
+ *   note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified. 
+ *            Always ensure return value fits within application's authorized limits. 
+ *            Each application can set its own limits. 
+ *   note 6 : This function replaces ZSTD_getDecompressedSize() */ 
+#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1) 
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2) 
+ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize); 
+ 
 /*! ZSTD_getDecompressedSize() :
- *  NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize().
- *  Both functions work the same way, but ZSTD_getDecompressedSize() blends
- *  "empty", "unknown" and "error" results to the same return value (0),
- *  while ZSTD_getFrameContentSize() gives them separate return values.
+ *  NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize(). 
+ *  Both functions work the same way, but ZSTD_getDecompressedSize() blends 
+ *  "empty", "unknown" and "error" results to the same return value (0), 
+ *  while ZSTD_getFrameContentSize() gives them separate return values. 
  * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */
 ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);
 
@@ -177,23 +177,23 @@ ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize)
 
 
 /*======  Helper functions  ======*/
-#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
-ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */
+#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */ 
+ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */ 
 ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
 ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string from an error code */
 ZSTDLIB_API int         ZSTD_minCLevel(void);               /*!< minimum negative compression level allowed, requires v1.4.0+ */
-ZSTDLIB_API int         ZSTD_maxCLevel(void);               /*!< maximum compression level available */
+ZSTDLIB_API int         ZSTD_maxCLevel(void);               /*!< maximum compression level available */ 
 ZSTDLIB_API int         ZSTD_defaultCLevel(void);           /*!< default compression level, specified by ZSTD_CLEVEL_DEFAULT, requires v1.5.0+ */
 
 
 /***************************************
-*  Explicit context
+*  Explicit context 
 ***************************************/
 /*= Compression context
- *  When compressing many times,
+ *  When compressing many times, 
  *  it is recommended to allocate a context just once,
  *  and re-use it for each successive compression operation.
- *  This will make workload friendlier for system's memory.
+ *  This will make workload friendlier for system's memory. 
  *  Note : re-using context is just a speed / resource optimization.
  *         It doesn't change the compression ratio, which remains identical.
  *  Note 2 : In multi-threaded environments,
@@ -212,16 +212,16 @@ ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);  /* accept NULL pointer *
  *  they will all be reset. Only `compressionLevel` remains.
  */
 ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
-                                     void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                                     int compressionLevel);
-
-/*= Decompression context
- *  When decompressing many times,
- *  it is recommended to allocate a context only once,
- *  and re-use it for each successive compression operation.
- *  This will make workload friendlier for system's memory.
- *  Use one context per thread for parallel execution. */
+                                     void* dst, size_t dstCapacity, 
+                               const void* src, size_t srcSize, 
+                                     int compressionLevel); 
+
+/*= Decompression context 
+ *  When decompressing many times, 
+ *  it is recommended to allocate a context only once, 
+ *  and re-use it for each successive compression operation. 
+ *  This will make workload friendlier for system's memory. 
+ *  Use one context per thread for parallel execution. */ 
 typedef struct ZSTD_DCtx_s ZSTD_DCtx;
 ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
 ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer */
@@ -232,8 +232,8 @@ ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer *
  *  Compatible with sticky parameters.
  */
 ZSTDLIB_API size_t ZSTD_decompressDCtx(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); 
 
 
 /*********************************************
@@ -662,19 +662,19 @@ typedef struct ZSTD_outBuffer_s {
 *  start a new frame.
 *  note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will
 *        block until the flush is complete or the output buffer is full.
-*  @return : 0 if frame fully completed and fully flushed,
+*  @return : 0 if frame fully completed and fully flushed, 
 *            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
 *            or an error code, which can be tested using ZSTD_isError().
 *
 * *******************************************************************/
 
-typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
+typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */ 
                                  /* Continue to distinguish them for compatibility with older versions <= v1.2.0 */
-/*===== ZSTD_CStream management functions =====*/
+/*===== ZSTD_CStream management functions =====*/ 
 ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
 ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);  /* accept NULL pointer */
 
-/*===== Streaming compression functions =====*/
+/*===== Streaming compression functions =====*/ 
 typedef enum {
     ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */
     ZSTD_e_flush=1,    /* flush any data provided so far,
@@ -789,13 +789,13 @@ ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
 *                                that will never request more than the remaining frame size.
 * *******************************************************************************/
 
-typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
+typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */ 
                                  /* For compatibility with versions <= v1.2.0, prefer differentiating them. */
-/*===== ZSTD_DStream management functions =====*/
+/*===== ZSTD_DStream management functions =====*/ 
 ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
 ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);  /* accept NULL pointer */
 
-/*===== Streaming decompression functions =====*/
+/*===== Streaming decompression functions =====*/ 
 
 /* This function is redundant with the advanced API and equivalent to:
  *
@@ -1068,13 +1068,13 @@ ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
  ****************************************************************************************
  * The definitions in the following section are considered experimental.
  * They are provided for advanced scenarios.
- * They should never be used with a dynamic library, as prototypes may change in the future.
+ * They should never be used with a dynamic library, as prototypes may change in the future. 
  * Use them only in association with static linking.
  * ***************************************************************************************/
 
-#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
-#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
-
+#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY) 
+#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY 
+ 
 /* This can be overridden externally to hide static symbols. */
 #ifndef ZSTDLIB_STATIC_API
 #  if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
@@ -1233,24 +1233,24 @@ typedef struct {
     ZSTD_frameParameters fParams;
 } ZSTD_parameters;
 
-typedef enum {
+typedef enum { 
     ZSTD_dct_auto = 0,       /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
     ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
     ZSTD_dct_fullDict = 2    /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
-} ZSTD_dictContentType_e;
+} ZSTD_dictContentType_e; 
 
-typedef enum {
+typedef enum { 
     ZSTD_dlm_byCopy = 0,  /**< Copy dictionary content internally */
     ZSTD_dlm_byRef = 1    /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
-} ZSTD_dictLoadMethod_e;
-
+} ZSTD_dictLoadMethod_e; 
+ 
 typedef enum {
     ZSTD_f_zstd1 = 0,           /* zstd frame format, specified in zstd_compression_format.md (default) */
     ZSTD_f_zstd1_magicless = 1  /* Variant of zstd frame format, without initial 4-bytes magic number.
                                  * Useful to save 4 bytes per generated frame.
                                  * Decoder cannot recognise automatically this format, requiring this instruction. */
 } ZSTD_format_e;
-
+ 
 typedef enum {
     /* Note: this enum controls ZSTD_d_forceIgnoreChecksum */
     ZSTD_d_validateChecksum = 0,
@@ -1301,7 +1301,7 @@ typedef enum {
     ZSTD_dictForceCopy     = 2, /* Always copy the dictionary. */
     ZSTD_dictForceLoad     = 3  /* Always reload the dictionary */
 } ZSTD_dictAttachPref_e;
-
+ 
 typedef enum {
   ZSTD_lcm_auto = 0,          /**< Automatically determine the compression mode based on the compression level.
                                *   Negative compression levels will be uncompressed, and positive compression
@@ -1322,32 +1322,32 @@ typedef enum {
 } ZSTD_paramSwitch_e;
 
 /***************************************
-*  Frame size functions
+*  Frame size functions 
 ***************************************/
 
-/*! ZSTD_findDecompressedSize() :
+/*! ZSTD_findDecompressedSize() : 
  *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
- *  `srcSize` must be the _exact_ size of this series
+ *  `srcSize` must be the _exact_ size of this series 
  *       (i.e. there should be a frame boundary at `src + srcSize`)
- *  @return : - decompressed size of all data in all successive frames
- *            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
- *            - if an error occurred: ZSTD_CONTENTSIZE_ERROR
- *
- *   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
- *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 2 : decompressed size is always present when compression is done with ZSTD_compress()
- *   note 3 : decompressed size can be very large (64-bits value),
- *            potentially larger than what local system can handle as a single memory segment.
- *            In which case, it's necessary to use streaming mode to decompress data.
- *   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
- *            Always ensure result fits within application's authorized limits.
- *            Each application can set its own limits.
- *   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
- *            read each contained frame header.  This is fast as most of the data is skipped,
- *            however it does mean that all frame data must be present and valid. */
+ *  @return : - decompressed size of all data in all successive frames 
+ *            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN 
+ *            - if an error occurred: ZSTD_CONTENTSIZE_ERROR 
+ * 
+ *   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode. 
+ *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. 
+ *            In which case, it's necessary to use streaming mode to decompress data. 
+ *   note 2 : decompressed size is always present when compression is done with ZSTD_compress() 
+ *   note 3 : decompressed size can be very large (64-bits value), 
+ *            potentially larger than what local system can handle as a single memory segment. 
+ *            In which case, it's necessary to use streaming mode to decompress data. 
+ *   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified. 
+ *            Always ensure result fits within application's authorized limits. 
+ *            Each application can set its own limits. 
+ *   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to 
+ *            read each contained frame header.  This is fast as most of the data is skipped, 
+ *            however it does mean that all frame data must be present and valid. */ 
 ZSTDLIB_STATIC_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);
-
+ 
 /*! ZSTD_decompressBound() :
  *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
  *  `srcSize` must be the _exact_ size of this series
@@ -1363,12 +1363,12 @@ ZSTDLIB_STATIC_API unsigned long long ZSTD_findDecompressedSize(const void* src,
  */
 ZSTDLIB_STATIC_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);
 
-/*! ZSTD_frameHeaderSize() :
+/*! ZSTD_frameHeaderSize() : 
  *  srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.
  * @return : size of the Frame Header,
  *           or an error code (if srcSize is too small) */
 ZSTDLIB_STATIC_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
-
+ 
 typedef enum {
   ZSTD_sf_noBlockDelimiters = 0,         /* Representation of ZSTD_Sequence has no block delimiters, sequences only */
   ZSTD_sf_explicitBlockDelimiters = 1    /* Representation of ZSTD_Sequence contains explicit block delimiters */
@@ -1389,7 +1389,7 @@ typedef enum {
  * setting of ZSTD_c_blockDelimiters as ZSTD_sf_explicitBlockDelimiters
  * @return : number of sequences generated
  */
-
+ 
 ZSTDLIB_STATIC_API size_t ZSTD_generateSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
                                           size_t outSeqsSize, const void* src, size_t srcSize);
 
@@ -1476,11 +1476,11 @@ ZSTDLIB_API unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size);
 
 
 
-/***************************************
-*  Memory management
-***************************************/
-
-/*! ZSTD_estimate*() :
+/*************************************** 
+*  Memory management 
+***************************************/ 
+ 
+/*! ZSTD_estimate*() : 
  *  These functions make it possible to estimate memory usage
  *  of a future {D,C}Ctx, before its creation.
  *
@@ -1507,100 +1507,100 @@ ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize(int compressionLevel);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateDCtxSize(void);
-
-/*! ZSTD_estimateCStreamSize() :
- *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
- *  It will also consider src size to be arbitrarily "large", which is worst case.
- *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
- *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
+ 
+/*! ZSTD_estimateCStreamSize() : 
+ *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one. 
+ *  It will also consider src size to be arbitrarily "large", which is worst case. 
+ *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation. 
+ *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel. 
  *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
- *  Note : CStream size estimation is only correct for single-threaded compression.
- *  ZSTD_DStream memory budget depends on window Size.
- *  This information can be passed manually, using ZSTD_estimateDStreamSize,
- *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
- *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
- *         an internal ?Dict will be created, which additional size is not estimated here.
- *         In this case, get total size by adding ZSTD_estimate?DictSize */
+ *  Note : CStream size estimation is only correct for single-threaded compression. 
+ *  ZSTD_DStream memory budget depends on window Size. 
+ *  This information can be passed manually, using ZSTD_estimateDStreamSize, 
+ *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame(); 
+ *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(), 
+ *         an internal ?Dict will be created, which additional size is not estimated here. 
+ *         In this case, get total size by adding ZSTD_estimate?DictSize */ 
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
-
-/*! ZSTD_estimate?DictSize() :
- *  ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict().
- *  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().
- *  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.
- */
+ 
+/*! ZSTD_estimate?DictSize() : 
+ *  ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict(). 
+ *  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced(). 
+ *  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller. 
+ */ 
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
 ZSTDLIB_STATIC_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);
-
-/*! ZSTD_initStatic*() :
- *  Initialize an object using a pre-allocated fixed-size buffer.
- *  workspace: The memory area to emplace the object into.
- *             Provided pointer *must be 8-bytes aligned*.
- *             Buffer must outlive object.
- *  workspaceSize: Use ZSTD_estimate*Size() to determine
- *                 how large workspace must be to support target scenario.
- * @return : pointer to object (same address as workspace, just different type),
- *           or NULL if error (size too small, incorrect alignment, etc.)
- *  Note : zstd will never resize nor malloc() when using a static buffer.
- *         If the object requires more memory than available,
- *         zstd will just error out (typically ZSTD_error_memory_allocation).
- *  Note 2 : there is no corresponding "free" function.
- *           Since workspace is allocated externally, it must be freed externally too.
- *  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
- *           into its associated cParams.
- *  Limitation 1 : currently not compatible with internal dictionary creation, triggered by
- *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
- *  Limitation 2 : static cctx currently not compatible with multi-threading.
- *  Limitation 3 : static dctx is incompatible with legacy support.
- */
+ 
+/*! ZSTD_initStatic*() : 
+ *  Initialize an object using a pre-allocated fixed-size buffer. 
+ *  workspace: The memory area to emplace the object into. 
+ *             Provided pointer *must be 8-bytes aligned*. 
+ *             Buffer must outlive object. 
+ *  workspaceSize: Use ZSTD_estimate*Size() to determine 
+ *                 how large workspace must be to support target scenario. 
+ * @return : pointer to object (same address as workspace, just different type), 
+ *           or NULL if error (size too small, incorrect alignment, etc.) 
+ *  Note : zstd will never resize nor malloc() when using a static buffer. 
+ *         If the object requires more memory than available, 
+ *         zstd will just error out (typically ZSTD_error_memory_allocation). 
+ *  Note 2 : there is no corresponding "free" function. 
+ *           Since workspace is allocated externally, it must be freed externally too. 
+ *  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level 
+ *           into its associated cParams. 
+ *  Limitation 1 : currently not compatible with internal dictionary creation, triggered by 
+ *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict(). 
+ *  Limitation 2 : static cctx currently not compatible with multi-threading. 
+ *  Limitation 3 : static dctx is incompatible with legacy support. 
+ */ 
 ZSTDLIB_STATIC_API ZSTD_CCtx*    ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
 ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
-
+ 
 ZSTDLIB_STATIC_API ZSTD_DCtx*    ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);
 ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
-
+ 
 ZSTDLIB_STATIC_API const ZSTD_CDict* ZSTD_initStaticCDict(
-                                        void* workspace, size_t workspaceSize,
-                                        const void* dict, size_t dictSize,
-                                        ZSTD_dictLoadMethod_e dictLoadMethod,
-                                        ZSTD_dictContentType_e dictContentType,
-                                        ZSTD_compressionParameters cParams);
-
+                                        void* workspace, size_t workspaceSize, 
+                                        const void* dict, size_t dictSize, 
+                                        ZSTD_dictLoadMethod_e dictLoadMethod, 
+                                        ZSTD_dictContentType_e dictContentType, 
+                                        ZSTD_compressionParameters cParams); 
+ 
 ZSTDLIB_STATIC_API const ZSTD_DDict* ZSTD_initStaticDDict(
-                                        void* workspace, size_t workspaceSize,
-                                        const void* dict, size_t dictSize,
-                                        ZSTD_dictLoadMethod_e dictLoadMethod,
-                                        ZSTD_dictContentType_e dictContentType);
-
-
-/*! Custom memory allocation :
- *  These prototypes make it possible to pass your own allocation/free functions.
- *  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.
- *  All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones.
- */
-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;
+                                        void* workspace, size_t workspaceSize, 
+                                        const void* dict, size_t dictSize, 
+                                        ZSTD_dictLoadMethod_e dictLoadMethod, 
+                                        ZSTD_dictContentType_e dictContentType); 
+ 
+
+/*! Custom memory allocation : 
+ *  These prototypes make it possible to pass your own allocation/free functions. 
+ *  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below. 
+ *  All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones. 
+ */ 
+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; 
 static
 #ifdef __GNUC__
 __attribute__((__unused__))
 #endif
 ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };  /**< this constant defers to stdlib's functions */
-
+ 
 ZSTDLIB_STATIC_API ZSTD_CCtx*    ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
 ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTDLIB_STATIC_API ZSTD_DCtx*    ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
 ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
-
+ 
 ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,
-                                                  ZSTD_dictLoadMethod_e dictLoadMethod,
-                                                  ZSTD_dictContentType_e dictContentType,
-                                                  ZSTD_compressionParameters cParams,
-                                                  ZSTD_customMem customMem);
+                                                  ZSTD_dictLoadMethod_e dictLoadMethod, 
+                                                  ZSTD_dictContentType_e dictContentType, 
+                                                  ZSTD_compressionParameters cParams, 
+                                                  ZSTD_customMem customMem); 
 
 /*! Thread pool :
  *  These prototypes make it possible to share a thread pool among multiple compression contexts.
@@ -1635,18 +1635,18 @@ ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_advanced(
     ZSTD_customMem customMem);
 
 
-/***************************************
-*  Advanced compression functions
-***************************************/
-
-/*! ZSTD_createCDict_byReference() :
- *  Create a digested dictionary for compression
+/*************************************** 
+*  Advanced compression functions 
+***************************************/ 
+ 
+/*! ZSTD_createCDict_byReference() : 
+ *  Create a digested dictionary for compression 
  *  Dictionary content is just referenced, not duplicated.
  *  As a consequence, `dictBuffer` **must** outlive CDict,
  *  and its content must remain unmodified throughout the lifetime of CDict.
  *  note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef */
 ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);
-
+ 
 /*! ZSTD_getCParams() :
  * @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.
  * `estimatedSrcSize` value is optional, select 0 if not known */
@@ -1663,7 +1663,7 @@ ZSTDLIB_STATIC_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned
 ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
 
 /*! ZSTD_adjustCParams() :
- *  optimize params for a given `srcSize` and `dictSize`.
+ *  optimize params for a given `srcSize` and `dictSize`. 
  * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.
  * `dictSize` must be `0` when there is no dictionary.
  *  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.
@@ -1681,7 +1681,7 @@ size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
                                     const void* dict,size_t dictSize,
                                           ZSTD_parameters params);
 
-/*! ZSTD_compress_usingCDict_advanced() :
+/*! ZSTD_compress_usingCDict_advanced() : 
  *  Note : this function is now DEPRECATED.
  *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.
  *  This prototype will generate compilation warnings. */
@@ -1692,7 +1692,7 @@ size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
                                         const ZSTD_CDict* cdict,
                                               ZSTD_frameParameters fParams);
 
-
+ 
 /*! ZSTD_CCtx_loadDictionary_byReference() :
  *  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
  *  It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
@@ -2045,11 +2045,11 @@ ZSTDLIB_STATIC_API size_t ZSTD_compressStream2_simpleArgs (
  *  Note 3 : Skippable Frame Identifiers are considered valid. */
 ZSTDLIB_STATIC_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
 
-/*! ZSTD_createDDict_byReference() :
- *  Create a digested dictionary, ready to start decompression operation without startup delay.
- *  Dictionary content is referenced, and therefore stays in dictBuffer.
- *  It is important that dictBuffer outlives DDict,
- *  it must remain read accessible throughout the lifetime of DDict */
+/*! ZSTD_createDDict_byReference() : 
+ *  Create a digested dictionary, ready to start decompression operation without startup delay. 
+ *  Dictionary content is referenced, and therefore stays in dictBuffer. 
+ *  It is important that dictBuffer outlives DDict, 
+ *  it must remain read accessible throughout the lifetime of DDict */ 
 ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);
 
 /*! ZSTD_DCtx_loadDictionary_byReference() :
@@ -2276,7 +2276,7 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
                                      ZSTD_frameParameters fParams,
                                      unsigned long long pledgedSrcSize);
 
-/*! ZSTD_resetCStream() :
+/*! ZSTD_resetCStream() : 
  * This function is DEPRECATED, and is equivalent to:
  *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
  *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
@@ -2286,35 +2286,35 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
  *
  *  start a new frame, using same parameters from previous frame.
  *  This is typically useful to skip dictionary loading stage, since it will re-use it in-place.
- *  Note that zcs must be init at least once before using ZSTD_resetCStream().
- *  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
- *  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
- *  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
- *  but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.
+ *  Note that zcs must be init at least once before using ZSTD_resetCStream(). 
+ *  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN. 
+ *  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end. 
+ *  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs, 
+ *  but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead. 
  * @return : 0, or an error code (which can be tested using ZSTD_isError())
  *  This prototype will generate compilation warnings.
  */
 ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
 size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
 
-
-typedef struct {
+ 
+typedef struct { 
     unsigned long long ingested;   /* nb input bytes read and buffered */
     unsigned long long consumed;   /* nb input bytes actually compressed */
     unsigned long long produced;   /* nb of compressed bytes generated and buffered */
     unsigned long long flushed;    /* nb of compressed bytes flushed : not provided; can be tracked from caller side */
     unsigned currentJobID;         /* MT only : latest started job nb */
     unsigned nbActiveWorkers;      /* MT only : nb of workers actively compressing at probe time */
-} ZSTD_frameProgression;
-
+} ZSTD_frameProgression; 
+ 
 /* ZSTD_getFrameProgression() :
- * tells how much data has been ingested (read from input)
- * consumed (input actually compressed) and produced (output) for current frame.
+ * tells how much data has been ingested (read from input) 
+ * consumed (input actually compressed) and produced (output) for current frame. 
  * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
  * Aggregates progression inside active worker threads.
- */
+ */ 
 ZSTDLIB_STATIC_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);
-
+ 
 /*! ZSTD_toFlushNow() :
  *  Tell how many bytes are ready to be flushed immediately.
  *  Useful for multithreading scenarios (nbWorkers >= 1).
@@ -2329,8 +2329,8 @@ ZSTDLIB_STATIC_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCt
  *    irrespective of the speed of concurrent (and newer) jobs.
  */
 ZSTDLIB_STATIC_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);
-
-
+ 
+ 
 /*=====   Advanced Streaming decompression functions  =====*/
 
 /*!
@@ -2370,8 +2370,8 @@ ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
 *  Buffer-less and synchronous inner streaming functions
 *
 *  This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
-*  But it's also a complex one, with several restrictions, documented below.
-*  Prefer normal streaming API for an easier experience.
+*  But it's also a complex one, with several restrictions, documented below. 
+*  Prefer normal streaming API for an easier experience. 
 ********************************************************************* */
 
 /**
@@ -2387,8 +2387,8 @@ ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
 
   Then, consume your input using ZSTD_compressContinue().
   There are some important considerations to keep in mind when using this advanced function :
-  - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
-  - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
+  - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only. 
+  - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks. 
   - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
     Worst case evaluation is provided by ZSTD_compressBound().
     ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
@@ -2398,10 +2398,10 @@ ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
     In which case, it will "discard" the relevant memory section from its history.
 
   Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
-  It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
-  Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
+  It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame. 
+  Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders. 
 
-  `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
+  `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again. 
 */
 
 /*=====   Buffer-less streaming compression functions  =====*/
@@ -2409,7 +2409,7 @@ ZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLev
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
 ZSTDLIB_STATIC_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
-
+ 
 ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 
@@ -2425,52 +2425,52 @@ size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_
   Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
   A ZSTD_DCtx object can be re-used multiple times.
 
-  First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
-  Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
-  Data fragment must be large enough to ensure successful decoding.
- `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
-  @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
+  First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader(). 
+  Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough. 
+  Data fragment must be large enough to ensure successful decoding. 
+ `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough. 
+  @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled. 
            >0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
            errorCode, which can be tested using ZSTD_isError().
 
-  It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
-  such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
-  Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
-  As a consequence, check that values remain within valid application range.
-  For example, do not allocate memory blindly, check that `windowSize` is within expectation.
-  Each application can set its own limits, depending on local restrictions.
-  For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
-
-  ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
-  ZSTD_decompressContinue() is very sensitive to contiguity,
-  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
-  or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
-  There are multiple ways to guarantee this condition.
-
-  The most memory efficient way is to use a round buffer of sufficient size.
-  Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
-  which can @return an error code if required value is too large for current system (in 32-bits mode).
-  In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
-  up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
-  which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
-  At which point, decoding can resume from the beginning of the buffer.
-  Note that already decoded data stored in the buffer should be flushed before being overwritten.
-
-  There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.
-
-  Finally, if you control the compression process, you can also ignore all buffer size rules,
-  as long as the encoder and decoder progress in "lock-step",
-  aka use exactly the same buffer sizes, break contiguity at the same place, etc.
-
-  Once buffers are setup, start decompression, with ZSTD_decompressBegin().
-  If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
-
+  It fills a ZSTD_frameHeader structure with important information to correctly decode the frame, 
+  such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`). 
+  Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information. 
+  As a consequence, check that values remain within valid application range. 
+  For example, do not allocate memory blindly, check that `windowSize` is within expectation. 
+  Each application can set its own limits, depending on local restrictions. 
+  For extended interoperability, it is recommended to support `windowSize` of at least 8 MB. 
+
+  ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes. 
+  ZSTD_decompressContinue() is very sensitive to contiguity, 
+  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place, 
+  or that previous contiguous segment is large enough to properly handle maximum back-reference distance. 
+  There are multiple ways to guarantee this condition. 
+ 
+  The most memory efficient way is to use a round buffer of sufficient size. 
+  Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(), 
+  which can @return an error code if required value is too large for current system (in 32-bits mode). 
+  In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one, 
+  up to the moment there is not enough room left in the buffer to guarantee decoding another full block, 
+  which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`. 
+  At which point, decoding can resume from the beginning of the buffer. 
+  Note that already decoded data stored in the buffer should be flushed before being overwritten. 
+ 
+  There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory. 
+ 
+  Finally, if you control the compression process, you can also ignore all buffer size rules, 
+  as long as the encoder and decoder progress in "lock-step", 
+  aka use exactly the same buffer sizes, break contiguity at the same place, etc. 
+ 
+  Once buffers are setup, start decompression, with ZSTD_decompressBegin(). 
+  If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict(). 
+ 
   Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
   ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
   ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
 
- @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
-  It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
+ @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). 
+  It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item. 
   It can also be an error code, which can be tested with ZSTD_isError().
 
   A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
@@ -2482,26 +2482,26 @@ size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_
   == Special case : skippable frames ==
 
   Skippable frames allow integration of user-defined data into a flow of concatenated frames.
-  Skippable frames will be ignored (skipped) by decompressor.
-  The format of skippable frames is as follows :
+  Skippable frames will be ignored (skipped) by decompressor. 
+  The format of skippable frames is as follows : 
   a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
   b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
   c) Frame Content - any content (User Data) of length equal to Frame Size
-  For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
-  For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
+  For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame. 
+  For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content. 
 */
 
-/*=====   Buffer-less streaming decompression functions  =====*/
-typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
+/*=====   Buffer-less streaming decompression functions  =====*/ 
+typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e; 
 typedef struct {
-    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
-    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
-    unsigned blockSizeMax;
-    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
-    unsigned headerSize;
+    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */ 
+    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */ 
+    unsigned blockSizeMax; 
+    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */ 
+    unsigned headerSize; 
     unsigned dictID;
     unsigned checksumFlag;
-} ZSTD_frameHeader;
+} ZSTD_frameHeader; 
 
 /*! ZSTD_getFrameHeader() :
  *  decode Frame Header, or requires larger `srcSize`.
@@ -2518,23 +2518,23 @@ ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowS
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
-
+ 
 ZSTDLIB_STATIC_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/* misc */
+ 
+/* misc */ 
 ZSTDLIB_STATIC_API void   ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
 typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
 ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
 
 
-
-
-/* ============================ */
-/**       Block level API       */
-/* ============================ */
-
-/*!
+ 
+ 
+/* ============================ */ 
+/**       Block level API       */ 
+/* ============================ */ 
+ 
+/*! 
     Block functions produce and decode raw zstd blocks, without frame metadata.
     Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).
     But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.
@@ -2543,11 +2543,11 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
     - Compressing and decompressing require a context structure
       + Use ZSTD_createCCtx() and ZSTD_createDCtx()
     - It is necessary to init context before starting
-      + compression : any ZSTD_compressBegin*() variant, including with dictionary
-      + decompression : any ZSTD_decompressBegin*() variant, including with dictionary
-      + copyCCtx() and copyDCtx() can be used too
-    - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB
-      + If input is larger than a block size, it's necessary to split input data into multiple blocks
+      + compression : any ZSTD_compressBegin*() variant, including with dictionary 
+      + decompression : any ZSTD_decompressBegin*() variant, including with dictionary 
+      + copyCCtx() and copyDCtx() can be used too 
+    - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB 
+      + If input is larger than a block size, it's necessary to split input data into multiple blocks 
       + For inputs larger than a single block, consider using regular ZSTD_compress() instead.
         Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.
     - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !
@@ -2556,9 +2556,9 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
       + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.
         Doing so would mess up with statistics history, leading to potential data corruption.
       + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!
-      + In case of multiple successive blocks, should some of them be uncompressed,
-        decoder must be informed of their existence in order to follow proper history.
-        Use ZSTD_insertBlock() for such a case.
+      + In case of multiple successive blocks, should some of them be uncompressed, 
+        decoder must be informed of their existence in order to follow proper history. 
+        Use ZSTD_insertBlock() for such a case. 
 */
 
 /*=====   Raw zstd block functions  =====*/