Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 2 of 2.

1 files changed, 231 insertions, 231 deletions

diff --git a/contrib/libs/lz4/lz4frame.h b/contrib/libs/lz4/lz4frame.h
index da959b367f..4573317ef2 100644
--- a/contrib/libs/lz4/lz4frame.h
+++ b/contrib/libs/lz4/lz4frame.h
@@ -1,37 +1,37 @@
-/* 
-   LZ4 auto-framing library 
-   Header File 
+/*
+   LZ4 auto-framing library
+   Header File
    Copyright (C) 2011-2017, Yann Collet.
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
- 
-   Redistribution and use in source and binary forms, with or without 
-   modification, are permitted provided that the following conditions are 
-   met: 
- 
-       * Redistributions of source code must retain the above copyright 
-   notice, this list of conditions and the following disclaimer. 
-       * Redistributions in binary form must reproduce the above 
-   copyright notice, this list of conditions and the following disclaimer 
-   in the documentation and/or other materials provided with the 
-   distribution. 
- 
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- 
-   You can contact the author at : 
-   - LZ4 source repository : https://github.com/lz4/lz4 
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c 
-*/ 
- 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - LZ4 source repository : https://github.com/lz4/lz4
+   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
 /* LZ4F is a stand-alone API able to create and decode LZ4 frames
  * conformant with specification v1.6.1 in doc/lz4_Frame_format.md .
  * Generated frames are compatible with `lz4` CLI.
@@ -40,18 +40,18 @@
  *
  * lz4.h is not required when using lz4frame.h,
  * except to extract common constant such as LZ4_VERSION_NUMBER.
- * */ 
- 
-#ifndef LZ4F_H_09782039843 
-#define LZ4F_H_09782039843 
- 
-#if defined (__cplusplus) 
-extern "C" { 
-#endif 
- 
-/* ---   Dependency   --- */ 
-#include <stddef.h>   /* size_t */ 
- 
+ * */
+
+#ifndef LZ4F_H_09782039843
+#define LZ4F_H_09782039843
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* ---   Dependency   --- */
+#include <stddef.h>   /* size_t */
+
 
 /**
   Introduction
@@ -61,32 +61,32 @@ extern "C" {
   of encoding standard metadata alongside LZ4-compressed blocks.
 */
 
-/*-*************************************************************** 
+/*-***************************************************************
  *  Compiler specifics
  *****************************************************************/
 /*  LZ4_DLL_EXPORT :
  *  Enable exporting of functions when building a Windows DLL
- *  LZ4FLIB_VISIBILITY : 
+ *  LZ4FLIB_VISIBILITY :
  *  Control library symbols visibility.
  */
-#ifndef LZ4FLIB_VISIBILITY 
-#  if defined(__GNUC__) && (__GNUC__ >= 4) 
-#    define LZ4FLIB_VISIBILITY __attribute__ ((visibility ("default"))) 
-#  else 
-#    define LZ4FLIB_VISIBILITY 
-#  endif 
-#endif 
-#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1) 
-#  define LZ4FLIB_API __declspec(dllexport) LZ4FLIB_VISIBILITY 
-#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1) 
-#  define LZ4FLIB_API __declspec(dllimport) LZ4FLIB_VISIBILITY 
-#else 
-#  define LZ4FLIB_API LZ4FLIB_VISIBILITY 
-#endif 
- 
+#ifndef LZ4FLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define LZ4FLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define LZ4FLIB_VISIBILITY
+#  endif
+#endif
+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
+#  define LZ4FLIB_API __declspec(dllexport) LZ4FLIB_VISIBILITY
+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
+#  define LZ4FLIB_API __declspec(dllimport) LZ4FLIB_VISIBILITY
+#else
+#  define LZ4FLIB_API LZ4FLIB_VISIBILITY
+#endif
+
 #ifdef LZ4F_DISABLE_DEPRECATE_WARNINGS
 #  define LZ4F_DEPRECATE(x) x
-#else 
+#else
 #  if defined(_MSC_VER)
 #    define LZ4F_DEPRECATE(x) x   /* __declspec(deprecated) x - only works with C++ */
 #  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
@@ -94,85 +94,85 @@ extern "C" {
 #  else
 #    define LZ4F_DEPRECATE(x) x   /* no deprecation warning for this compiler */
 #  endif
-#endif 
- 
- 
-/*-************************************ 
+#endif
+
+
+/*-************************************
  *  Error management
  **************************************/
-typedef size_t LZ4F_errorCode_t; 
- 
+typedef size_t LZ4F_errorCode_t;
+
 LZ4FLIB_API unsigned    LZ4F_isError(LZ4F_errorCode_t code);   /**< tells when a function result is an error code */
 LZ4FLIB_API const char* LZ4F_getErrorName(LZ4F_errorCode_t code);   /**< return error code string; for debugging */
- 
- 
-/*-************************************ 
+
+
+/*-************************************
  *  Frame compression types
- ************************************* */ 
+ ************************************* */
 /* #define LZ4F_ENABLE_OBSOLETE_ENUMS   // uncomment to enable obsolete enums */
 #ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
-#  define LZ4F_OBSOLETE_ENUM(x) , LZ4F_DEPRECATE(x) = LZ4F_##x 
-#else 
-#  define LZ4F_OBSOLETE_ENUM(x) 
-#endif 
- 
+#  define LZ4F_OBSOLETE_ENUM(x) , LZ4F_DEPRECATE(x) = LZ4F_##x
+#else
+#  define LZ4F_OBSOLETE_ENUM(x)
+#endif
+
 /* The larger the block size, the (slightly) better the compression ratio,
  * though there are diminishing returns.
- * Larger blocks also increase memory usage on both compression and decompression sides. 
- */ 
-typedef enum { 
-    LZ4F_default=0, 
-    LZ4F_max64KB=4, 
-    LZ4F_max256KB=5, 
-    LZ4F_max1MB=6, 
-    LZ4F_max4MB=7 
-    LZ4F_OBSOLETE_ENUM(max64KB) 
-    LZ4F_OBSOLETE_ENUM(max256KB) 
-    LZ4F_OBSOLETE_ENUM(max1MB) 
-    LZ4F_OBSOLETE_ENUM(max4MB) 
-} LZ4F_blockSizeID_t; 
- 
+ * Larger blocks also increase memory usage on both compression and decompression sides.
+ */
+typedef enum {
+    LZ4F_default=0,
+    LZ4F_max64KB=4,
+    LZ4F_max256KB=5,
+    LZ4F_max1MB=6,
+    LZ4F_max4MB=7
+    LZ4F_OBSOLETE_ENUM(max64KB)
+    LZ4F_OBSOLETE_ENUM(max256KB)
+    LZ4F_OBSOLETE_ENUM(max1MB)
+    LZ4F_OBSOLETE_ENUM(max4MB)
+} LZ4F_blockSizeID_t;
+
 /* Linked blocks sharply reduce inefficiencies when using small blocks,
  * they compress better.
  * However, some LZ4 decoders are only compatible with independent blocks */
-typedef enum { 
-    LZ4F_blockLinked=0, 
-    LZ4F_blockIndependent 
-    LZ4F_OBSOLETE_ENUM(blockLinked) 
-    LZ4F_OBSOLETE_ENUM(blockIndependent) 
-} LZ4F_blockMode_t; 
- 
-typedef enum { 
-    LZ4F_noContentChecksum=0, 
-    LZ4F_contentChecksumEnabled 
-    LZ4F_OBSOLETE_ENUM(noContentChecksum) 
-    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled) 
-} LZ4F_contentChecksum_t; 
- 
-typedef enum { 
+typedef enum {
+    LZ4F_blockLinked=0,
+    LZ4F_blockIndependent
+    LZ4F_OBSOLETE_ENUM(blockLinked)
+    LZ4F_OBSOLETE_ENUM(blockIndependent)
+} LZ4F_blockMode_t;
+
+typedef enum {
+    LZ4F_noContentChecksum=0,
+    LZ4F_contentChecksumEnabled
+    LZ4F_OBSOLETE_ENUM(noContentChecksum)
+    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled)
+} LZ4F_contentChecksum_t;
+
+typedef enum {
     LZ4F_noBlockChecksum=0,
     LZ4F_blockChecksumEnabled
 } LZ4F_blockChecksum_t;
 
 typedef enum {
-    LZ4F_frame=0, 
-    LZ4F_skippableFrame 
-    LZ4F_OBSOLETE_ENUM(skippableFrame) 
-} LZ4F_frameType_t; 
- 
+    LZ4F_frame=0,
+    LZ4F_skippableFrame
+    LZ4F_OBSOLETE_ENUM(skippableFrame)
+} LZ4F_frameType_t;
+
 #ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
-typedef LZ4F_blockSizeID_t blockSizeID_t; 
-typedef LZ4F_blockMode_t blockMode_t; 
-typedef LZ4F_frameType_t frameType_t; 
-typedef LZ4F_contentChecksum_t contentChecksum_t; 
-#endif 
- 
+typedef LZ4F_blockSizeID_t blockSizeID_t;
+typedef LZ4F_blockMode_t blockMode_t;
+typedef LZ4F_frameType_t frameType_t;
+typedef LZ4F_contentChecksum_t contentChecksum_t;
+#endif
+
 /*! LZ4F_frameInfo_t :
  *  makes it possible to set or read frame parameters.
  *  Structure must be first init to 0, using memset() or LZ4F_INIT_FRAMEINFO,
  *  setting all parameters to default.
  *  It's then possible to update selectively some parameters */
-typedef struct { 
+typedef struct {
   LZ4F_blockSizeID_t     blockSizeID;         /* max64KB, max256KB, max1MB, max4MB; 0 == default */
   LZ4F_blockMode_t       blockMode;           /* LZ4F_blockLinked, LZ4F_blockIndependent; 0 == default */
   LZ4F_contentChecksum_t contentChecksumFlag; /* 1: frame terminated with 32-bit checksum of decompressed data; 0: disabled (default) */
@@ -180,29 +180,29 @@ typedef struct {
   unsigned long long     contentSize;         /* Size of uncompressed content ; 0 == unknown */
   unsigned               dictID;              /* Dictionary ID, sent by compressor to help decoder select correct dictionary; 0 == no dictID provided */
   LZ4F_blockChecksum_t   blockChecksumFlag;   /* 1: each block followed by a checksum of block's compressed data; 0: disabled (default) */
-} LZ4F_frameInfo_t; 
- 
-#define LZ4F_INIT_FRAMEINFO   { LZ4F_default, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame, 0ULL, 0U, LZ4F_noBlockChecksum }    /* v1.8.3+ */ 
+} LZ4F_frameInfo_t;
+
+#define LZ4F_INIT_FRAMEINFO   { LZ4F_default, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame, 0ULL, 0U, LZ4F_noBlockChecksum }    /* v1.8.3+ */
 
 /*! LZ4F_preferences_t :
  *  makes it possible to supply advanced compression instructions to streaming interface.
  *  Structure must be first init to 0, using memset() or LZ4F_INIT_PREFERENCES,
  *  setting all parameters to default.
  *  All reserved fields must be set to zero. */
-typedef struct { 
-  LZ4F_frameInfo_t frameInfo; 
+typedef struct {
+  LZ4F_frameInfo_t frameInfo;
   int      compressionLevel;    /* 0: default (fast mode); values > LZ4HC_CLEVEL_MAX count as LZ4HC_CLEVEL_MAX; values < 0 trigger "fast acceleration" */
   unsigned autoFlush;           /* 1: always flush; reduces usage of internal buffers */
   unsigned favorDecSpeed;       /* 1: parser favors decompression speed vs compression ratio. Only works for high compression modes (>= LZ4HC_CLEVEL_OPT_MIN) */  /* v1.8.2+ */
   unsigned reserved[3];         /* must be zero for forward compatibility */
-} LZ4F_preferences_t; 
- 
-#define LZ4F_INIT_PREFERENCES   { LZ4F_INIT_FRAMEINFO, 0, 0u, 0u, { 0u, 0u, 0u } }    /* v1.8.3+ */ 
- 
+} LZ4F_preferences_t;
+
+#define LZ4F_INIT_PREFERENCES   { LZ4F_INIT_FRAMEINFO, 0, 0u, 0u, { 0u, 0u, 0u } }    /* v1.8.3+ */
+
 
-/*-********************************* 
-*  Simple compression function 
-***********************************/ 
+/*-*********************************
+*  Simple compression function
+***********************************/
 
 LZ4FLIB_API int LZ4F_compressionLevel_max(void);   /* v1.8.0+ */
 
@@ -211,51 +211,51 @@ LZ4FLIB_API int LZ4F_compressionLevel_max(void);   /* v1.8.0+ */
  * `preferencesPtr` is optional. It can be replaced by NULL, in which case, the function will assume default preferences.
  *  Note : this result is only usable with LZ4F_compressFrame().
  *         It may also be used with LZ4F_compressUpdate() _if no flush() operation_ is performed.
- */ 
-LZ4FLIB_API size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr); 
- 
+ */
+LZ4FLIB_API size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
+
 /*! LZ4F_compressFrame() :
  *  Compress an entire srcBuffer into a valid LZ4 frame.
  *  dstCapacity MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
  *  The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
- * @return : number of bytes written into dstBuffer. 
- *           or an error code if it fails (can be tested using LZ4F_isError()) 
- */ 
+ * @return : number of bytes written into dstBuffer.
+ *           or an error code if it fails (can be tested using LZ4F_isError())
+ */
 LZ4FLIB_API size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity,
                                 const void* srcBuffer, size_t srcSize,
                                 const LZ4F_preferences_t* preferencesPtr);
- 
- 
-/*-*********************************** 
-*  Advanced compression functions 
-*************************************/ 
-typedef struct LZ4F_cctx_s LZ4F_cctx;   /* incomplete type */ 
-typedef LZ4F_cctx* LZ4F_compressionContext_t;   /* for compatibility with previous API version */ 
- 
-typedef struct { 
-  unsigned stableSrc;    /* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */ 
-  unsigned reserved[3]; 
-} LZ4F_compressOptions_t; 
- 
+
+
+/*-***********************************
+*  Advanced compression functions
+*************************************/
+typedef struct LZ4F_cctx_s LZ4F_cctx;   /* incomplete type */
+typedef LZ4F_cctx* LZ4F_compressionContext_t;   /* for compatibility with previous API version */
+
+typedef struct {
+  unsigned stableSrc;    /* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */
+  unsigned reserved[3];
+} LZ4F_compressOptions_t;
+
 /*---   Resource Management   ---*/
- 
+
 #define LZ4F_VERSION 100    /* This number can be used to check for an incompatible API breaking change */
-LZ4FLIB_API unsigned LZ4F_getVersion(void); 
+LZ4FLIB_API unsigned LZ4F_getVersion(void);
 
 /*! LZ4F_createCompressionContext() :
- * The first thing to do is to create a compressionContext object, which will be used in all compression operations. 
+ * The first thing to do is to create a compressionContext object, which will be used in all compression operations.
  * This is achieved using LZ4F_createCompressionContext(), which takes as argument a version.
- * The version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL. 
- * The function will provide a pointer to a fully allocated LZ4F_cctx object. 
- * If @return != zero, there was an error during context creation. 
- * Object can release its memory using LZ4F_freeCompressionContext(); 
- */ 
+ * The version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL.
+ * The function will provide a pointer to a fully allocated LZ4F_cctx object.
+ * If @return != zero, there was an error during context creation.
+ * Object can release its memory using LZ4F_freeCompressionContext();
+ */
 LZ4FLIB_API LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** cctxPtr, unsigned version);
 LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
- 
- 
+
+
 /*----    Compression    ----*/
- 
+
 #define LZ4F_HEADER_SIZE_MIN  7   /* LZ4 Frame header size can vary, depending on selected paramaters */
 #define LZ4F_HEADER_SIZE_MAX 19
 
@@ -271,14 +271,14 @@ LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
 /*! LZ4F_compressBegin() :
  *  will write the frame header into dstBuffer.
  *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
- * `prefsPtr` is optional : you can provide NULL as argument, all preferences will then be set to default. 
- * @return : number of bytes written into dstBuffer for the header 
- *           or an error code (which can be tested using LZ4F_isError()) 
- */ 
+ * `prefsPtr` is optional : you can provide NULL as argument, all preferences will then be set to default.
+ * @return : number of bytes written into dstBuffer for the header
+ *           or an error code (which can be tested using LZ4F_isError())
+ */
 LZ4FLIB_API size_t LZ4F_compressBegin(LZ4F_cctx* cctx,
                                       void* dstBuffer, size_t dstCapacity,
                                       const LZ4F_preferences_t* prefsPtr);
- 
+
 /*! LZ4F_compressBound() :
  *  Provides minimum dstCapacity required to guarantee success of
  *  LZ4F_compressUpdate(), given a srcSize and preferences, for a worst case scenario.
@@ -290,12 +290,12 @@ LZ4FLIB_API size_t LZ4F_compressBegin(LZ4F_cctx* cctx,
  * @return is always the same for a srcSize and prefsPtr.
  *  prefsPtr is optional : when NULL is provided, preferences will be set to cover worst case scenario.
  *  tech details :
- * @return if automatic flushing is not enabled, includes the possibility that internal buffer might already be filled by up to (blockSize-1) bytes. 
+ * @return if automatic flushing is not enabled, includes the possibility that internal buffer might already be filled by up to (blockSize-1) bytes.
  *  It also includes frame footer (ending + checksum), since it might be generated by LZ4F_compressEnd().
  * @return doesn't include frame header, as it was already generated by LZ4F_compressBegin().
  */
-LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr); 
- 
+LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr);
+
 /*! LZ4F_compressUpdate() :
  *  LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
  *  Important rule: dstCapacity MUST be large enough to ensure operation success even in worst case situations.
@@ -303,57 +303,57 @@ LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t*
  *  If this condition is not respected, LZ4F_compress() will fail (result is an errorCode).
  *  LZ4F_compressUpdate() doesn't guarantee error recovery.
  *  When an error occurs, compression context must be freed or resized.
- * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default. 
- * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered). 
- *           or an error code if it fails (which can be tested using LZ4F_isError()) 
- */ 
+ * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default.
+ * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered).
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
+ */
 LZ4FLIB_API size_t LZ4F_compressUpdate(LZ4F_cctx* cctx,
                                        void* dstBuffer, size_t dstCapacity,
                                  const void* srcBuffer, size_t srcSize,
                                  const LZ4F_compressOptions_t* cOptPtr);
- 
+
 /*! LZ4F_flush() :
  *  When data must be generated and sent immediately, without waiting for a block to be completely filled,
  *  it's possible to call LZ4_flush(). It will immediately compress any data buffered within cctx.
- * `dstCapacity` must be large enough to ensure the operation will be successful. 
- * `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default. 
+ * `dstCapacity` must be large enough to ensure the operation will be successful.
+ * `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default.
  * @return : nb of bytes written into dstBuffer (can be zero, when there is no data stored within cctx)
- *           or an error code if it fails (which can be tested using LZ4F_isError()) 
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
  *  Note : LZ4F_flush() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr).
- */ 
+ */
 LZ4FLIB_API size_t LZ4F_flush(LZ4F_cctx* cctx,
                               void* dstBuffer, size_t dstCapacity,
                         const LZ4F_compressOptions_t* cOptPtr);
- 
+
 /*! LZ4F_compressEnd() :
  *  To properly finish an LZ4 frame, invoke LZ4F_compressEnd().
  *  It will flush whatever data remained within `cctx` (like LZ4_flush())
  *  and properly finalize the frame, with an endMark and a checksum.
- * `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default. 
+ * `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default.
  * @return : nb of bytes written into dstBuffer, necessarily >= 4 (endMark),
- *           or an error code if it fails (which can be tested using LZ4F_isError()) 
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
  *  Note : LZ4F_compressEnd() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr).
  *  A successful call to LZ4F_compressEnd() makes `cctx` available again for another compression task.
- */ 
+ */
 LZ4FLIB_API size_t LZ4F_compressEnd(LZ4F_cctx* cctx,
                                     void* dstBuffer, size_t dstCapacity,
                               const LZ4F_compressOptions_t* cOptPtr);
- 
- 
-/*-********************************* 
-*  Decompression functions 
-***********************************/ 
-typedef struct LZ4F_dctx_s LZ4F_dctx;   /* incomplete type */ 
-typedef LZ4F_dctx* LZ4F_decompressionContext_t;   /* compatibility with previous API versions */ 
- 
-typedef struct { 
+
+
+/*-*********************************
+*  Decompression functions
+***********************************/
+typedef struct LZ4F_dctx_s LZ4F_dctx;   /* incomplete type */
+typedef LZ4F_dctx* LZ4F_decompressionContext_t;   /* compatibility with previous API versions */
+
+typedef struct {
   unsigned stableDst;    /* pledges that last 64KB decompressed data will remain available unmodified. This optimization skips storage operations in tmp buffers. */
   unsigned reserved[3];  /* must be set to zero for forward compatibility */
-} LZ4F_decompressOptions_t; 
- 
- 
-/* Resource management */ 
- 
+} LZ4F_decompressOptions_t;
+
+
+/* Resource management */
+
 /*! LZ4F_createDecompressionContext() :
  *  Create an LZ4F_dctx object, to track all decompression operations.
  *  The version provided MUST be LZ4F_VERSION.
@@ -362,15 +362,15 @@ typedef struct {
  *  dctx memory can be released using LZ4F_freeDecompressionContext();
  *  Result of LZ4F_freeDecompressionContext() indicates current state of decompressionContext when being released.
  *  That is, it should be == 0 if decompression has been completed fully and correctly.
- */ 
-LZ4FLIB_API LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version); 
+ */
+LZ4FLIB_API LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version);
 LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx);
- 
- 
+
+
 /*-***********************************
 *  Streaming decompression functions
 *************************************/
- 
+
 #define LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH 5
 
 /*! LZ4F_headerSize() : v1.9.0+
@@ -381,8 +381,8 @@ LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx);
  *           or an error code, which can be tested using LZ4F_isError()
  *  note : Frame header size is variable, but is guaranteed to be
  *         >= LZ4F_HEADER_SIZE_MIN bytes, and <= LZ4F_HEADER_SIZE_MAX bytes.
- */ 
-LZ4FLIB_API size_t LZ4F_headerSize(const void* src, size_t srcSize); 
+ */
+LZ4FLIB_API size_t LZ4F_headerSize(const void* src, size_t srcSize);
 
 /*! LZ4F_getFrameInfo() :
  *  This function extracts frame parameters (max blockSize, dictID, etc.).
@@ -427,31 +427,31 @@ LZ4FLIB_API size_t LZ4F_headerSize(const void* src, size_t srcSize);
  *  note 1 : in case of error, dctx is not modified. Decoding operation can resume from beginning safely.
  *  note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure.
  */
-LZ4FLIB_API size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx, 
-                                     LZ4F_frameInfo_t* frameInfoPtr, 
-                                     const void* srcBuffer, size_t* srcSizePtr); 
- 
+LZ4FLIB_API size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
+                                     LZ4F_frameInfo_t* frameInfoPtr,
+                                     const void* srcBuffer, size_t* srcSizePtr);
+
 /*! LZ4F_decompress() :
- *  Call this function repetitively to regenerate data compressed in `srcBuffer`. 
- * 
- *  The function requires a valid dctx state. 
- *  It will read up to *srcSizePtr bytes from srcBuffer, 
+ *  Call this function repetitively to regenerate data compressed in `srcBuffer`.
+ *
+ *  The function requires a valid dctx state.
+ *  It will read up to *srcSizePtr bytes from srcBuffer,
  *  and decompress data into dstBuffer, of capacity *dstSizePtr.
- * 
+ *
  *  The nb of bytes consumed from srcBuffer will be written into *srcSizePtr (necessarily <= original value).
  *  The nb of bytes decompressed into dstBuffer will be written into *dstSizePtr (necessarily <= original value).
- * 
+ *
  *  The function does not necessarily read all input bytes, so always check value in *srcSizePtr.
  *  Unconsumed source data must be presented again in subsequent invocations.
- * 
+ *
  * `dstBuffer` can freely change between each consecutive function invocation.
  * `dstBuffer` content will be overwritten.
- * 
+ *
  * @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call.
  *  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
  *  Respecting the hint provides some small speed benefit, because it skips intermediate buffers.
  *  This is just a hint though, it's always possible to provide any srcSize.
- * 
+ *
  *  When a frame is fully decoded, @return will be 0 (no more data expected).
  *  When provided with more bytes than necessary to decode a frame,
  *  LZ4F_decompress() will stop reading exactly at end of current frame, and @return 0.
@@ -461,27 +461,27 @@ LZ4FLIB_API size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
  *  Use LZ4F_resetDecompressionContext() to return to clean state.
  *
  *  After a frame is fully decoded, dctx can be used again to decompress another frame.
- */ 
-LZ4FLIB_API size_t LZ4F_decompress(LZ4F_dctx* dctx, 
-                                   void* dstBuffer, size_t* dstSizePtr, 
-                                   const void* srcBuffer, size_t* srcSizePtr, 
-                                   const LZ4F_decompressOptions_t* dOptPtr); 
- 
- 
+ */
+LZ4FLIB_API size_t LZ4F_decompress(LZ4F_dctx* dctx,
+                                   void* dstBuffer, size_t* dstSizePtr,
+                                   const void* srcBuffer, size_t* srcSizePtr,
+                                   const LZ4F_decompressOptions_t* dOptPtr);
+
+
 /*! LZ4F_resetDecompressionContext() : added in v1.8.0
  *  In case of an error, the context is left in "undefined" state.
  *  In which case, it's necessary to reset it, before re-using it.
  *  This method can also be used to abruptly stop any unfinished decompression,
  *  and start a new one using same context resources. */
 LZ4FLIB_API void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx);   /* always successful */
- 
 
 
-#if defined (__cplusplus) 
-} 
-#endif 
- 
-#endif  /* LZ4F_H_09782039843 */ 
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* LZ4F_H_09782039843 */
 
 #if defined(LZ4F_STATIC_LINKING_ONLY) && !defined(LZ4F_H_STATIC_09782039843)
 #define LZ4F_H_STATIC_09782039843
@@ -501,9 +501,9 @@ extern "C" {
  * Use at your own risk.
  */
 #ifdef LZ4F_PUBLISH_STATIC_FUNCTIONS
-# define LZ4FLIB_STATIC_API LZ4FLIB_API 
+# define LZ4FLIB_STATIC_API LZ4FLIB_API
 #else
-# define LZ4FLIB_STATIC_API 
+# define LZ4FLIB_STATIC_API
 #endif