Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

11 files changed, 1816 insertions, 1816 deletions

diff --git a/contrib/libs/snappy/snappy-c.cc b/contrib/libs/snappy/snappy-c.cc
index 0cb59c7296..473a0b0978 100644
--- a/contrib/libs/snappy/snappy-c.cc
+++ b/contrib/libs/snappy/snappy-c.cc
@@ -1,90 +1,90 @@
-// Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-#include "snappy.h" 
-#include "snappy-c.h" 
- 
-extern "C" { 
- 
-snappy_status snappy_compress(const char* input, 
-                              size_t input_length, 
-                              char* compressed, 
-                              size_t *compressed_length) { 
-  if (*compressed_length < snappy_max_compressed_length(input_length)) { 
-    return SNAPPY_BUFFER_TOO_SMALL; 
-  } 
-  snappy::RawCompress(input, input_length, compressed, compressed_length); 
-  return SNAPPY_OK; 
-} 
- 
-snappy_status snappy_uncompress(const char* compressed, 
-                                size_t compressed_length, 
-                                char* uncompressed, 
-                                size_t* uncompressed_length) { 
-  size_t real_uncompressed_length; 
-  if (!snappy::GetUncompressedLength(compressed, 
-                                     compressed_length, 
-                                     &real_uncompressed_length)) { 
-    return SNAPPY_INVALID_INPUT; 
-  } 
-  if (*uncompressed_length < real_uncompressed_length) { 
-    return SNAPPY_BUFFER_TOO_SMALL; 
-  } 
-  if (!snappy::RawUncompress(compressed, compressed_length, uncompressed)) { 
-    return SNAPPY_INVALID_INPUT; 
-  } 
-  *uncompressed_length = real_uncompressed_length; 
-  return SNAPPY_OK; 
-} 
- 
-size_t snappy_max_compressed_length(size_t source_length) { 
-  return snappy::MaxCompressedLength(source_length); 
-} 
- 
-snappy_status snappy_uncompressed_length(const char *compressed, 
-                                         size_t compressed_length, 
-                                         size_t *result) { 
-  if (snappy::GetUncompressedLength(compressed, 
-                                    compressed_length, 
-                                    result)) { 
-    return SNAPPY_OK; 
-  } else { 
-    return SNAPPY_INVALID_INPUT; 
-  } 
-} 
- 
-snappy_status snappy_validate_compressed_buffer(const char *compressed, 
-                                                size_t compressed_length) { 
-  if (snappy::IsValidCompressedBuffer(compressed, compressed_length)) { 
-    return SNAPPY_OK; 
-  } else { 
-    return SNAPPY_INVALID_INPUT; 
-  } 
-} 
- 
-}  // extern "C" 
+// Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+#include "snappy.h"
+#include "snappy-c.h"
+
+extern "C" {
+
+snappy_status snappy_compress(const char* input,
+                              size_t input_length,
+                              char* compressed,
+                              size_t *compressed_length) {
+  if (*compressed_length < snappy_max_compressed_length(input_length)) {
+    return SNAPPY_BUFFER_TOO_SMALL;
+  }
+  snappy::RawCompress(input, input_length, compressed, compressed_length);
+  return SNAPPY_OK;
+}
+
+snappy_status snappy_uncompress(const char* compressed,
+                                size_t compressed_length,
+                                char* uncompressed,
+                                size_t* uncompressed_length) {
+  size_t real_uncompressed_length;
+  if (!snappy::GetUncompressedLength(compressed,
+                                     compressed_length,
+                                     &real_uncompressed_length)) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  if (*uncompressed_length < real_uncompressed_length) {
+    return SNAPPY_BUFFER_TOO_SMALL;
+  }
+  if (!snappy::RawUncompress(compressed, compressed_length, uncompressed)) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  *uncompressed_length = real_uncompressed_length;
+  return SNAPPY_OK;
+}
+
+size_t snappy_max_compressed_length(size_t source_length) {
+  return snappy::MaxCompressedLength(source_length);
+}
+
+snappy_status snappy_uncompressed_length(const char *compressed,
+                                         size_t compressed_length,
+                                         size_t *result) {
+  if (snappy::GetUncompressedLength(compressed,
+                                    compressed_length,
+                                    result)) {
+    return SNAPPY_OK;
+  } else {
+    return SNAPPY_INVALID_INPUT;
+  }
+}
+
+snappy_status snappy_validate_compressed_buffer(const char *compressed,
+                                                size_t compressed_length) {
+  if (snappy::IsValidCompressedBuffer(compressed, compressed_length)) {
+    return SNAPPY_OK;
+  } else {
+    return SNAPPY_INVALID_INPUT;
+  }
+}
+
+}  // extern "C"
diff --git a/contrib/libs/snappy/snappy-c.h b/contrib/libs/snappy/snappy-c.h
index 826bccfded..32aa0c6b8b 100644
--- a/contrib/libs/snappy/snappy-c.h
+++ b/contrib/libs/snappy/snappy-c.h
@@ -1,138 +1,138 @@
-/* 
- * Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>. 
- * 
- * 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. 
- *     * Neither the name of Google Inc. nor the names of its 
- * contributors may be used to endorse or promote products derived from 
- * this software without specific prior written permission. 
- * 
- * 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. 
- * 
- * Plain C interface (a wrapper around the C++ implementation). 
- */ 
- 
+/*
+ * Copyright 2011 Martin Gieseking <martin.gieseking@uos.de>.
+ *
+ * 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.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * 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.
+ *
+ * Plain C interface (a wrapper around the C++ implementation).
+ */
+
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_C_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_C_H_
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
-#include <stddef.h> 
- 
-/* 
- * Return values; see the documentation for each function to know 
- * what each can return. 
- */ 
-typedef enum { 
-  SNAPPY_OK = 0, 
-  SNAPPY_INVALID_INPUT = 1, 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+/*
+ * Return values; see the documentation for each function to know
+ * what each can return.
+ */
+typedef enum {
+  SNAPPY_OK = 0,
+  SNAPPY_INVALID_INPUT = 1,
   SNAPPY_BUFFER_TOO_SMALL = 2
-} snappy_status; 
- 
-/* 
- * Takes the data stored in "input[0..input_length-1]" and stores 
- * it in the array pointed to by "compressed". 
- * 
- * <compressed_length> signals the space available in "compressed". 
- * If it is not at least equal to "snappy_max_compressed_length(input_length)", 
- * SNAPPY_BUFFER_TOO_SMALL is returned. After successful compression, 
- * <compressed_length> contains the true length of the compressed output, 
- * and SNAPPY_OK is returned. 
- * 
- * Example: 
- *   size_t output_length = snappy_max_compressed_length(input_length); 
- *   char* output = (char*)malloc(output_length); 
- *   if (snappy_compress(input, input_length, output, &output_length) 
- *       == SNAPPY_OK) { 
- *     ... Process(output, output_length) ... 
- *   } 
- *   free(output); 
- */ 
-snappy_status snappy_compress(const char* input, 
-                              size_t input_length, 
-                              char* compressed, 
-                              size_t* compressed_length); 
- 
-/* 
- * Given data in "compressed[0..compressed_length-1]" generated by 
- * calling the snappy_compress routine, this routine stores 
- * the uncompressed data to 
- *   uncompressed[0..uncompressed_length-1]. 
- * Returns failure (a value not equal to SNAPPY_OK) if the message 
- * is corrupted and could not be decrypted. 
- * 
- * <uncompressed_length> signals the space available in "uncompressed". 
- * If it is not at least equal to the value returned by 
- * snappy_uncompressed_length for this stream, SNAPPY_BUFFER_TOO_SMALL 
- * is returned. After successful decompression, <uncompressed_length> 
- * contains the true length of the decompressed output. 
- * 
- * Example: 
- *   size_t output_length; 
- *   if (snappy_uncompressed_length(input, input_length, &output_length) 
- *       != SNAPPY_OK) { 
- *     ... fail ... 
- *   } 
- *   char* output = (char*)malloc(output_length); 
- *   if (snappy_uncompress(input, input_length, output, &output_length) 
- *       == SNAPPY_OK) { 
- *     ... Process(output, output_length) ... 
- *   } 
- *   free(output); 
- */ 
-snappy_status snappy_uncompress(const char* compressed, 
-                                size_t compressed_length, 
-                                char* uncompressed, 
-                                size_t* uncompressed_length); 
- 
-/* 
- * Returns the maximal size of the compressed representation of 
- * input data that is "source_length" bytes in length. 
- */ 
-size_t snappy_max_compressed_length(size_t source_length); 
- 
-/* 
- * REQUIRES: "compressed[]" was produced by snappy_compress() 
- * Returns SNAPPY_OK and stores the length of the uncompressed data in 
- * *result normally. Returns SNAPPY_INVALID_INPUT on parsing error. 
- * This operation takes O(1) time. 
- */ 
-snappy_status snappy_uncompressed_length(const char* compressed, 
-                                         size_t compressed_length, 
-                                         size_t* result); 
- 
-/* 
- * Check if the contents of "compressed[]" can be uncompressed successfully. 
- * Does not return the uncompressed data; if so, returns SNAPPY_OK, 
- * or if not, returns SNAPPY_INVALID_INPUT. 
- * Takes time proportional to compressed_length, but is usually at least a 
- * factor of four faster than actual decompression. 
- */ 
-snappy_status snappy_validate_compressed_buffer(const char* compressed, 
-                                                size_t compressed_length); 
- 
-#ifdef __cplusplus 
-}  // extern "C" 
-#endif 
- 
+} snappy_status;
+
+/*
+ * Takes the data stored in "input[0..input_length-1]" and stores
+ * it in the array pointed to by "compressed".
+ *
+ * <compressed_length> signals the space available in "compressed".
+ * If it is not at least equal to "snappy_max_compressed_length(input_length)",
+ * SNAPPY_BUFFER_TOO_SMALL is returned. After successful compression,
+ * <compressed_length> contains the true length of the compressed output,
+ * and SNAPPY_OK is returned.
+ *
+ * Example:
+ *   size_t output_length = snappy_max_compressed_length(input_length);
+ *   char* output = (char*)malloc(output_length);
+ *   if (snappy_compress(input, input_length, output, &output_length)
+ *       == SNAPPY_OK) {
+ *     ... Process(output, output_length) ...
+ *   }
+ *   free(output);
+ */
+snappy_status snappy_compress(const char* input,
+                              size_t input_length,
+                              char* compressed,
+                              size_t* compressed_length);
+
+/*
+ * Given data in "compressed[0..compressed_length-1]" generated by
+ * calling the snappy_compress routine, this routine stores
+ * the uncompressed data to
+ *   uncompressed[0..uncompressed_length-1].
+ * Returns failure (a value not equal to SNAPPY_OK) if the message
+ * is corrupted and could not be decrypted.
+ *
+ * <uncompressed_length> signals the space available in "uncompressed".
+ * If it is not at least equal to the value returned by
+ * snappy_uncompressed_length for this stream, SNAPPY_BUFFER_TOO_SMALL
+ * is returned. After successful decompression, <uncompressed_length>
+ * contains the true length of the decompressed output.
+ *
+ * Example:
+ *   size_t output_length;
+ *   if (snappy_uncompressed_length(input, input_length, &output_length)
+ *       != SNAPPY_OK) {
+ *     ... fail ...
+ *   }
+ *   char* output = (char*)malloc(output_length);
+ *   if (snappy_uncompress(input, input_length, output, &output_length)
+ *       == SNAPPY_OK) {
+ *     ... Process(output, output_length) ...
+ *   }
+ *   free(output);
+ */
+snappy_status snappy_uncompress(const char* compressed,
+                                size_t compressed_length,
+                                char* uncompressed,
+                                size_t* uncompressed_length);
+
+/*
+ * Returns the maximal size of the compressed representation of
+ * input data that is "source_length" bytes in length.
+ */
+size_t snappy_max_compressed_length(size_t source_length);
+
+/*
+ * REQUIRES: "compressed[]" was produced by snappy_compress()
+ * Returns SNAPPY_OK and stores the length of the uncompressed data in
+ * *result normally. Returns SNAPPY_INVALID_INPUT on parsing error.
+ * This operation takes O(1) time.
+ */
+snappy_status snappy_uncompressed_length(const char* compressed,
+                                         size_t compressed_length,
+                                         size_t* result);
+
+/*
+ * Check if the contents of "compressed[]" can be uncompressed successfully.
+ * Does not return the uncompressed data; if so, returns SNAPPY_OK,
+ * or if not, returns SNAPPY_INVALID_INPUT.
+ * Takes time proportional to compressed_length, but is usually at least a
+ * factor of four faster than actual decompression.
+ */
+snappy_status snappy_validate_compressed_buffer(const char* compressed,
+                                                size_t compressed_length);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
 #endif  /* THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_C_H_ */
diff --git a/contrib/libs/snappy/snappy-internal.h b/contrib/libs/snappy/snappy-internal.h
index 28c179ee46..1e1c307fef 100644
--- a/contrib/libs/snappy/snappy-internal.h
+++ b/contrib/libs/snappy/snappy-internal.h
@@ -1,94 +1,94 @@
-// Copyright 2008 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
-// 
-// Internals shared between the Snappy implementation and its unittest. 
- 
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Internals shared between the Snappy implementation and its unittest.
+
 #ifndef THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
 #define THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
- 
-#include "snappy-stubs-internal.h" 
- 
-namespace snappy { 
-namespace internal { 
- 
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+namespace internal {
+
 // Working memory performs a single allocation to hold all scratch space
 // required for compression.
-class WorkingMemory { 
- public: 
+class WorkingMemory {
+ public:
   explicit WorkingMemory(size_t input_size);
   ~WorkingMemory();
- 
-  // Allocates and clears a hash table using memory in "*this", 
-  // stores the number of buckets in "*table_size" and returns a pointer to 
-  // the base of the hash table. 
+
+  // Allocates and clears a hash table using memory in "*this",
+  // stores the number of buckets in "*table_size" and returns a pointer to
+  // the base of the hash table.
   uint16* GetHashTable(size_t fragment_size, int* table_size) const;
   char* GetScratchInput() const { return input_; }
   char* GetScratchOutput() const { return output_; }
- 
- private: 
+
+ private:
   char* mem_;      // the allocated memory, never nullptr
   size_t size_;    // the size of the allocated memory, never 0
   uint16* table_;  // the pointer to the hashtable
   char* input_;    // the pointer to the input scratch buffer
   char* output_;   // the pointer to the output scratch buffer
- 
+
   // No copying
   WorkingMemory(const WorkingMemory&);
   void operator=(const WorkingMemory&);
-}; 
- 
-// Flat array compression that does not emit the "uncompressed length" 
-// prefix. Compresses "input" string to the "*op" buffer. 
-// 
-// REQUIRES: "input_length <= kBlockSize" 
-// REQUIRES: "op" points to an array of memory that is at least 
-// "MaxCompressedLength(input_length)" in size. 
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. 
-// REQUIRES: "table_size" is a power of two 
-// 
-// Returns an "end" pointer into "op" buffer. 
-// "end - op" is the compressed size of "input". 
-char* CompressFragment(const char* input, 
-                       size_t input_length, 
-                       char* op, 
-                       uint16* table, 
-                       const int table_size); 
- 
+};
+
+// Flat array compression that does not emit the "uncompressed length"
+// prefix. Compresses "input" string to the "*op" buffer.
+//
+// REQUIRES: "input_length <= kBlockSize"
+// REQUIRES: "op" points to an array of memory that is at least
+// "MaxCompressedLength(input_length)" in size.
+// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+// REQUIRES: "table_size" is a power of two
+//
+// Returns an "end" pointer into "op" buffer.
+// "end - op" is the compressed size of "input".
+char* CompressFragment(const char* input,
+                       size_t input_length,
+                       char* op,
+                       uint16* table,
+                       const int table_size);
+
 // Find the largest n such that
-// 
-//   s1[0,n-1] == s2[0,n-1] 
-//   and n <= (s2_limit - s2). 
-// 
+//
+//   s1[0,n-1] == s2[0,n-1]
+//   and n <= (s2_limit - s2).
+//
 // Return make_pair(n, n < 8).
-// Does not read *s2_limit or beyond. 
-// Does not read *(s1 + (s2_limit - s2)) or beyond. 
-// Requires that s2_limit >= s2. 
-// 
+// Does not read *s2_limit or beyond.
+// Does not read *(s1 + (s2_limit - s2)) or beyond.
+// Requires that s2_limit >= s2.
+//
 // Separate implementation for 64-bit, little-endian cpus.
 #if !defined(SNAPPY_IS_BIG_ENDIAN) && \
     (defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM))
@@ -97,7 +97,7 @@ static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
                                                       const char* s2_limit) {
   assert(s2_limit >= s2);
   size_t matched = 0;
- 
+
   // This block isn't necessary for correctness; we could just start looping
   // immediately.  As an optimization though, it is useful.  It creates some not
   // uncommon code paths that determine, without extra effort, whether the match
@@ -115,59 +115,59 @@ static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
     }
   }
 
-  // Find out how long the match is. We loop over the data 64 bits at a 
-  // time until we find a 64-bit block that doesn't match; then we find 
-  // the first non-matching bit and use that to calculate the total 
-  // length of the match. 
+  // Find out how long the match is. We loop over the data 64 bits at a
+  // time until we find a 64-bit block that doesn't match; then we find
+  // the first non-matching bit and use that to calculate the total
+  // length of the match.
   while (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 8)) {
     if (UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched)) {
-      s2 += 8; 
-      matched += 8; 
-    } else { 
-      uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched); 
-      int matching_bits = Bits::FindLSBSetNonZero64(x); 
-      matched += matching_bits >> 3; 
+      s2 += 8;
+      matched += 8;
+    } else {
+      uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
+      int matching_bits = Bits::FindLSBSetNonZero64(x);
+      matched += matching_bits >> 3;
       assert(matched >= 8);
       return std::pair<size_t, bool>(matched, false);
-    } 
-  } 
+    }
+  }
   while (SNAPPY_PREDICT_TRUE(s2 < s2_limit)) {
     if (s1[matched] == *s2) {
-      ++s2; 
-      ++matched; 
-    } else { 
+      ++s2;
+      ++matched;
+    } else {
       return std::pair<size_t, bool>(matched, matched < 8);
-    } 
-  } 
+    }
+  }
   return std::pair<size_t, bool>(matched, matched < 8);
-} 
-#else 
+}
+#else
 static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
                                                       const char* s2,
                                                       const char* s2_limit) {
-  // Implementation based on the x86-64 version, above. 
+  // Implementation based on the x86-64 version, above.
   assert(s2_limit >= s2);
-  int matched = 0; 
- 
-  while (s2 <= s2_limit - 4 && 
-         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) { 
-    s2 += 4; 
-    matched += 4; 
-  } 
-  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) { 
-    uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched); 
-    int matching_bits = Bits::FindLSBSetNonZero(x); 
-    matched += matching_bits >> 3; 
-  } else { 
-    while ((s2 < s2_limit) && (s1[matched] == *s2)) { 
-      ++s2; 
-      ++matched; 
-    } 
-  } 
+  int matched = 0;
+
+  while (s2 <= s2_limit - 4 &&
+         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
+    s2 += 4;
+    matched += 4;
+  }
+  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
+    uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
+    int matching_bits = Bits::FindLSBSetNonZero(x);
+    matched += matching_bits >> 3;
+  } else {
+    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    }
+  }
   return std::pair<size_t, bool>(matched, matched < 8);
-} 
-#endif 
- 
+}
+#endif
+
 // Lookup tables for decompression code.  Give --snappy_dump_decompression_table
 // to the unit test to recompute char_table.
 
@@ -225,7 +225,7 @@ static const uint16 char_table[256] = {
   0x1801, 0x0f0a, 0x103f, 0x203f, 0x2001, 0x0f0b, 0x1040, 0x2040
 };
 
-}  // end namespace internal 
-}  // end namespace snappy 
- 
+}  // end namespace internal
+}  // end namespace snappy
+
 #endif  // THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_
diff --git a/contrib/libs/snappy/snappy-sinksource.cc b/contrib/libs/snappy/snappy-sinksource.cc
index 42651664bf..369a13215b 100644
--- a/contrib/libs/snappy/snappy-sinksource.cc
+++ b/contrib/libs/snappy/snappy-sinksource.cc
@@ -1,45 +1,45 @@
-// Copyright 2011 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-#include <string.h> 
- 
-#include "snappy-sinksource.h" 
- 
-namespace snappy { 
- 
-Source::~Source() { } 
- 
-Sink::~Sink() { } 
- 
-char* Sink::GetAppendBuffer(size_t length, char* scratch) { 
-  return scratch; 
-} 
- 
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+#include <string.h>
+
+#include "snappy-sinksource.h"
+
+namespace snappy {
+
+Source::~Source() { }
+
+Sink::~Sink() { }
+
+char* Sink::GetAppendBuffer(size_t length, char* scratch) {
+  return scratch;
+}
+
 char* Sink::GetAppendBufferVariable(
       size_t min_size, size_t desired_size_hint, char* scratch,
       size_t scratch_size, size_t* allocated_size) {
@@ -55,34 +55,34 @@ void Sink::AppendAndTakeOwnership(
   (*deleter)(deleter_arg, bytes, n);
 }
 
-ByteArraySource::~ByteArraySource() { } 
- 
-size_t ByteArraySource::Available() const { return left_; } 
- 
-const char* ByteArraySource::Peek(size_t* len) { 
-  *len = left_; 
-  return ptr_; 
-} 
- 
-void ByteArraySource::Skip(size_t n) { 
-  left_ -= n; 
-  ptr_ += n; 
-} 
- 
-UncheckedByteArraySink::~UncheckedByteArraySink() { } 
- 
-void UncheckedByteArraySink::Append(const char* data, size_t n) { 
-  // Do no copying if the caller filled in the result of GetAppendBuffer() 
-  if (data != dest_) { 
-    memcpy(dest_, data, n); 
-  } 
-  dest_ += n; 
-} 
- 
-char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) { 
-  return dest_; 
-} 
- 
+ByteArraySource::~ByteArraySource() { }
+
+size_t ByteArraySource::Available() const { return left_; }
+
+const char* ByteArraySource::Peek(size_t* len) {
+  *len = left_;
+  return ptr_;
+}
+
+void ByteArraySource::Skip(size_t n) {
+  left_ -= n;
+  ptr_ += n;
+}
+
+UncheckedByteArraySink::~UncheckedByteArraySink() { }
+
+void UncheckedByteArraySink::Append(const char* data, size_t n) {
+  // Do no copying if the caller filled in the result of GetAppendBuffer()
+  if (data != dest_) {
+    memcpy(dest_, data, n);
+  }
+  dest_ += n;
+}
+
+char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {
+  return dest_;
+}
+
 void UncheckedByteArraySink::AppendAndTakeOwnership(
     char* data, size_t n,
     void (*deleter)(void*, const char*, size_t),
@@ -92,7 +92,7 @@ void UncheckedByteArraySink::AppendAndTakeOwnership(
     (*deleter)(deleter_arg, data, n);
   }
   dest_ += n;
-} 
+}
 
 char* UncheckedByteArraySink::GetAppendBufferVariable(
       size_t min_size, size_t desired_size_hint, char* scratch,
diff --git a/contrib/libs/snappy/snappy-sinksource.h b/contrib/libs/snappy/snappy-sinksource.h
index 75aa872653..8afcdaaa2c 100644
--- a/contrib/libs/snappy/snappy-sinksource.h
+++ b/contrib/libs/snappy/snappy-sinksource.h
@@ -1,69 +1,69 @@
-// Copyright 2011 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
 #ifndef THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
 #define THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
- 
-#include <stddef.h> 
- 
-namespace snappy { 
- 
-// A Sink is an interface that consumes a sequence of bytes. 
-class Sink { 
- public: 
-  Sink() { } 
-  virtual ~Sink(); 
- 
-  // Append "bytes[0,n-1]" to this. 
-  virtual void Append(const char* bytes, size_t n) = 0; 
- 
-  // Returns a writable buffer of the specified length for appending. 
-  // May return a pointer to the caller-owned scratch buffer which 
-  // must have at least the indicated length.  The returned buffer is 
-  // only valid until the next operation on this Sink. 
-  // 
-  // After writing at most "length" bytes, call Append() with the 
-  // pointer returned from this function and the number of bytes 
-  // written.  Many Append() implementations will avoid copying 
-  // bytes if this function returned an internal buffer. 
-  // 
-  // If a non-scratch buffer is returned, the caller may only pass a 
-  // prefix of it to Append().  That is, it is not correct to pass an 
-  // interior pointer of the returned array to Append(). 
-  // 
-  // The default implementation always returns the scratch buffer. 
-  virtual char* GetAppendBuffer(size_t length, char* scratch); 
- 
+
+#include <stddef.h>
+
+namespace snappy {
+
+// A Sink is an interface that consumes a sequence of bytes.
+class Sink {
+ public:
+  Sink() { }
+  virtual ~Sink();
+
+  // Append "bytes[0,n-1]" to this.
+  virtual void Append(const char* bytes, size_t n) = 0;
+
+  // Returns a writable buffer of the specified length for appending.
+  // May return a pointer to the caller-owned scratch buffer which
+  // must have at least the indicated length.  The returned buffer is
+  // only valid until the next operation on this Sink.
+  //
+  // After writing at most "length" bytes, call Append() with the
+  // pointer returned from this function and the number of bytes
+  // written.  Many Append() implementations will avoid copying
+  // bytes if this function returned an internal buffer.
+  //
+  // If a non-scratch buffer is returned, the caller may only pass a
+  // prefix of it to Append().  That is, it is not correct to pass an
+  // interior pointer of the returned array to Append().
+  //
+  // The default implementation always returns the scratch buffer.
+  virtual char* GetAppendBuffer(size_t length, char* scratch);
+
   // For higher performance, Sink implementations can provide custom
   // AppendAndTakeOwnership() and GetAppendBufferVariable() methods.
   // These methods can reduce the number of copies done during
   // compression/decompression.
- 
+
   // Append "bytes[0,n-1] to the sink. Takes ownership of "bytes"
   // and calls the deleter function as (*deleter)(deleter_arg, bytes, n)
   // to free the buffer. deleter function must be non NULL.
@@ -101,82 +101,82 @@ class Sink {
       size_t min_size, size_t desired_size_hint, char* scratch,
       size_t scratch_size, size_t* allocated_size);
 
- private: 
-  // No copying 
-  Sink(const Sink&); 
-  void operator=(const Sink&); 
-}; 
- 
-// A Source is an interface that yields a sequence of bytes 
-class Source { 
- public: 
-  Source() { } 
-  virtual ~Source(); 
- 
-  // Return the number of bytes left to read from the source 
-  virtual size_t Available() const = 0; 
- 
-  // Peek at the next flat region of the source.  Does not reposition 
-  // the source.  The returned region is empty iff Available()==0. 
-  // 
-  // Returns a pointer to the beginning of the region and store its 
-  // length in *len. 
-  // 
-  // The returned region is valid until the next call to Skip() or 
-  // until this object is destroyed, whichever occurs first. 
-  // 
-  // The returned region may be larger than Available() (for example 
-  // if this ByteSource is a view on a substring of a larger source). 
-  // The caller is responsible for ensuring that it only reads the 
-  // Available() bytes. 
-  virtual const char* Peek(size_t* len) = 0; 
- 
-  // Skip the next n bytes.  Invalidates any buffer returned by 
-  // a previous call to Peek(). 
-  // REQUIRES: Available() >= n 
-  virtual void Skip(size_t n) = 0; 
- 
- private: 
-  // No copying 
-  Source(const Source&); 
-  void operator=(const Source&); 
-}; 
- 
-// A Source implementation that yields the contents of a flat array 
-class ByteArraySource : public Source { 
- public: 
-  ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { } 
-  virtual ~ByteArraySource(); 
-  virtual size_t Available() const; 
-  virtual const char* Peek(size_t* len); 
-  virtual void Skip(size_t n); 
- private: 
-  const char* ptr_; 
-  size_t left_; 
-}; 
- 
-// A Sink implementation that writes to a flat array without any bound checks. 
-class UncheckedByteArraySink : public Sink { 
- public: 
-  explicit UncheckedByteArraySink(char* dest) : dest_(dest) { } 
-  virtual ~UncheckedByteArraySink(); 
-  virtual void Append(const char* data, size_t n); 
-  virtual char* GetAppendBuffer(size_t len, char* scratch); 
+ private:
+  // No copying
+  Sink(const Sink&);
+  void operator=(const Sink&);
+};
+
+// A Source is an interface that yields a sequence of bytes
+class Source {
+ public:
+  Source() { }
+  virtual ~Source();
+
+  // Return the number of bytes left to read from the source
+  virtual size_t Available() const = 0;
+
+  // Peek at the next flat region of the source.  Does not reposition
+  // the source.  The returned region is empty iff Available()==0.
+  //
+  // Returns a pointer to the beginning of the region and store its
+  // length in *len.
+  //
+  // The returned region is valid until the next call to Skip() or
+  // until this object is destroyed, whichever occurs first.
+  //
+  // The returned region may be larger than Available() (for example
+  // if this ByteSource is a view on a substring of a larger source).
+  // The caller is responsible for ensuring that it only reads the
+  // Available() bytes.
+  virtual const char* Peek(size_t* len) = 0;
+
+  // Skip the next n bytes.  Invalidates any buffer returned by
+  // a previous call to Peek().
+  // REQUIRES: Available() >= n
+  virtual void Skip(size_t n) = 0;
+
+ private:
+  // No copying
+  Source(const Source&);
+  void operator=(const Source&);
+};
+
+// A Source implementation that yields the contents of a flat array
+class ByteArraySource : public Source {
+ public:
+  ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
+  virtual ~ByteArraySource();
+  virtual size_t Available() const;
+  virtual const char* Peek(size_t* len);
+  virtual void Skip(size_t n);
+ private:
+  const char* ptr_;
+  size_t left_;
+};
+
+// A Sink implementation that writes to a flat array without any bound checks.
+class UncheckedByteArraySink : public Sink {
+ public:
+  explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
+  virtual ~UncheckedByteArraySink();
+  virtual void Append(const char* data, size_t n);
+  virtual char* GetAppendBuffer(size_t len, char* scratch);
   virtual char* GetAppendBufferVariable(
       size_t min_size, size_t desired_size_hint, char* scratch,
       size_t scratch_size, size_t* allocated_size);
   virtual void AppendAndTakeOwnership(
       char* bytes, size_t n, void (*deleter)(void*, const char*, size_t),
       void *deleter_arg);
- 
-  // Return the current output pointer so that a caller can see how 
-  // many bytes were produced. 
-  // Note: this is not a Sink method. 
-  char* CurrentDestination() const { return dest_; } 
- private: 
-  char* dest_; 
-}; 
- 
+
+  // Return the current output pointer so that a caller can see how
+  // many bytes were produced.
+  // Note: this is not a Sink method.
+  char* CurrentDestination() const { return dest_; }
+ private:
+  char* dest_;
+};
+
 }  // namespace snappy
- 
+
 #endif  // THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_
diff --git a/contrib/libs/snappy/snappy-stubs-internal.cc b/contrib/libs/snappy/snappy-stubs-internal.cc
index 3e43a2124b..66ed2e9039 100644
--- a/contrib/libs/snappy/snappy-stubs-internal.cc
+++ b/contrib/libs/snappy/snappy-stubs-internal.cc
@@ -1,42 +1,42 @@
-// Copyright 2011 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-#include <algorithm> 
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+#include <algorithm>
 #include <string>
- 
-#include "snappy-stubs-internal.h" 
- 
-namespace snappy { 
- 
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+
 void Varint::Append32(std::string* s, uint32 value) {
-  char buf[Varint::kMax32]; 
-  const char* p = Varint::Encode32(buf, value); 
+  char buf[Varint::kMax32];
+  const char* p = Varint::Encode32(buf, value);
   s->append(buf, p - buf);
-} 
- 
-}  // namespace snappy 
+}
+
+}  // namespace snappy
diff --git a/contrib/libs/snappy/snappy-stubs-internal.h b/contrib/libs/snappy/snappy-stubs-internal.h
index 48b40bac98..4854689d17 100644
--- a/contrib/libs/snappy/snappy-stubs-internal.h
+++ b/contrib/libs/snappy/snappy-stubs-internal.h
@@ -1,46 +1,46 @@
-// Copyright 2011 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
-// 
-// Various stubs for the open-source version of Snappy. 
- 
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Various stubs for the open-source version of Snappy.
+
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
- 
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif 
- 
+#endif
+
 #include <string>
- 
-#include <assert.h> 
-#include <stdlib.h> 
-#include <string.h> 
- 
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
 #ifdef HAVE_SYS_MMAN_H
 #include <sys/mman.h>
 #endif
@@ -65,13 +65,13 @@
 #define SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) /* empty */
 #endif  // __has_feature(memory_sanitizer)
 
-#include "snappy-stubs-public.h" 
- 
-#if defined(__x86_64__) 
- 
-// Enable 64-bit optimized versions of some routines. 
-#define ARCH_K8 1 
- 
+#include "snappy-stubs-public.h"
+
+#if defined(__x86_64__)
+
+// Enable 64-bit optimized versions of some routines.
+#define ARCH_K8 1
+
 #elif defined(__ppc64__)
 
 #define ARCH_PPC 1
@@ -80,21 +80,21 @@
 
 #define ARCH_ARM 1
 
-#endif 
- 
-// Needed by OS X, among others. 
-#ifndef MAP_ANONYMOUS 
-#define MAP_ANONYMOUS MAP_ANON 
-#endif 
- 
-// The size of an array, if known at compile-time. 
-// Will give unexpected results if used on a pointer. 
-// We undefine it first, since some compilers already have a definition. 
-#ifdef ARRAYSIZE 
-#undef ARRAYSIZE 
-#endif 
-#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a))) 
- 
+#endif
+
+// Needed by OS X, among others.
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+// The size of an array, if known at compile-time.
+// Will give unexpected results if used on a pointer.
+// We undefine it first, since some compilers already have a definition.
+#ifdef ARRAYSIZE
+#undef ARRAYSIZE
+#endif
+#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
+
 // Static prediction hints.
 #ifdef HAVE_BUILTIN_EXPECT
 #define SNAPPY_PREDICT_FALSE(x) (__builtin_expect(x, 0))
@@ -103,44 +103,44 @@
 #define SNAPPY_PREDICT_FALSE(x) x
 #define SNAPPY_PREDICT_TRUE(x) x
 #endif
- 
-// This is only used for recomputing the tag byte table used during 
-// decompression; for simplicity we just remove it from the open-source 
-// version (anyone who wants to regenerate it can just do the call 
-// themselves within main()). 
-#define DEFINE_bool(flag_name, default_value, description) \ 
-  bool FLAGS_ ## flag_name = default_value 
-#define DECLARE_bool(flag_name) \ 
-  extern bool FLAGS_ ## flag_name 
- 
-namespace snappy { 
- 
-static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF); 
-static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL); 
- 
-// Potentially unaligned loads and stores. 
- 
+
+// This is only used for recomputing the tag byte table used during
+// decompression; for simplicity we just remove it from the open-source
+// version (anyone who wants to regenerate it can just do the call
+// themselves within main()).
+#define DEFINE_bool(flag_name, default_value, description) \
+  bool FLAGS_ ## flag_name = default_value
+#define DECLARE_bool(flag_name) \
+  extern bool FLAGS_ ## flag_name
+
+namespace snappy {
+
+static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF);
+static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
+
+// Potentially unaligned loads and stores.
+
 // x86, PowerPC, and ARM64 can simply do these loads and stores native.
- 
+
 #if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) || \
     defined(__aarch64__)
- 
-#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p)) 
-#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p)) 
-#define UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p)) 
- 
-#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val)) 
-#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val)) 
-#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val)) 
- 
-// ARMv7 and newer support native unaligned accesses, but only of 16-bit 
-// and 32-bit values (not 64-bit); older versions either raise a fatal signal, 
-// do an unaligned read and rotate the words around a bit, or do the reads very 
-// slowly (trip through kernel mode). There's no simple #define that says just 
-// “ARMv7 or higher”, so we have to filter away all ARMv5 and ARMv6 
-// sub-architectures. 
-// 
-// This is a mess, but there's not much we can do about it. 
+
+#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
+#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
+#define UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p))
+
+#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
+#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
+#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val))
+
+// ARMv7 and newer support native unaligned accesses, but only of 16-bit
+// and 32-bit values (not 64-bit); older versions either raise a fatal signal,
+// do an unaligned read and rotate the words around a bit, or do the reads very
+// slowly (trip through kernel mode). There's no simple #define that says just
+// “ARMv7 or higher”, so we have to filter away all ARMv5 and ARMv6
+// sub-architectures.
+//
+// This is a mess, but there's not much we can do about it.
 //
 // To further complicate matters, only LDR instructions (single reads) are
 // allowed to be unaligned, not LDRD (two reads) or LDM (many reads). Unless we
@@ -150,30 +150,30 @@ static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
 // (it ignores __attribute__((packed)) on individual variables). However,
 // we can tell it that a _struct_ is unaligned, which has the same effect,
 // so we do that.
- 
-#elif defined(__arm__) && \ 
+
+#elif defined(__arm__) && \
       !defined(__ARM_ARCH_4__) && \
       !defined(__ARM_ARCH_4T__) && \
-      !defined(__ARM_ARCH_5__) && \ 
-      !defined(__ARM_ARCH_5T__) && \ 
-      !defined(__ARM_ARCH_5TE__) && \ 
-      !defined(__ARM_ARCH_5TEJ__) && \ 
-      !defined(__ARM_ARCH_6__) && \ 
-      !defined(__ARM_ARCH_6J__) && \ 
-      !defined(__ARM_ARCH_6K__) && \ 
-      !defined(__ARM_ARCH_6Z__) && \ 
-      !defined(__ARM_ARCH_6ZK__) && \ 
-      !defined(__ARM_ARCH_6T2__) 
- 
+      !defined(__ARM_ARCH_5__) && \
+      !defined(__ARM_ARCH_5T__) && \
+      !defined(__ARM_ARCH_5TE__) && \
+      !defined(__ARM_ARCH_5TEJ__) && \
+      !defined(__ARM_ARCH_6__) && \
+      !defined(__ARM_ARCH_6J__) && \
+      !defined(__ARM_ARCH_6K__) && \
+      !defined(__ARM_ARCH_6Z__) && \
+      !defined(__ARM_ARCH_6ZK__) && \
+      !defined(__ARM_ARCH_6T2__)
+
 #if __GNUC__
 #define ATTRIBUTE_PACKED __attribute__((__packed__))
 #else
 #define ATTRIBUTE_PACKED
 #endif
- 
+
 namespace base {
 namespace internal {
- 
+
 struct Unaligned16Struct {
   uint16 value;
   uint8 dummy;  // To make the size non-power-of-two.
@@ -200,59 +200,59 @@ struct Unaligned32Struct {
          (_val))
 
 // TODO: NEON supports unaligned 64-bit loads and stores.
-// See if that would be more efficient on platforms supporting it, 
-// at least for copies. 
- 
-inline uint64 UNALIGNED_LOAD64(const void *p) { 
-  uint64 t; 
-  memcpy(&t, p, sizeof t); 
-  return t; 
-} 
- 
-inline void UNALIGNED_STORE64(void *p, uint64 v) { 
-  memcpy(p, &v, sizeof v); 
-} 
- 
-#else 
- 
-// These functions are provided for architectures that don't support 
-// unaligned loads and stores. 
- 
-inline uint16 UNALIGNED_LOAD16(const void *p) { 
-  uint16 t; 
-  memcpy(&t, p, sizeof t); 
-  return t; 
-} 
- 
-inline uint32 UNALIGNED_LOAD32(const void *p) { 
-  uint32 t; 
-  memcpy(&t, p, sizeof t); 
-  return t; 
-} 
- 
-inline uint64 UNALIGNED_LOAD64(const void *p) { 
-  uint64 t; 
-  memcpy(&t, p, sizeof t); 
-  return t; 
-} 
- 
-inline void UNALIGNED_STORE16(void *p, uint16 v) { 
-  memcpy(p, &v, sizeof v); 
-} 
- 
-inline void UNALIGNED_STORE32(void *p, uint32 v) { 
-  memcpy(p, &v, sizeof v); 
-} 
- 
-inline void UNALIGNED_STORE64(void *p, uint64 v) { 
-  memcpy(p, &v, sizeof v); 
-} 
- 
-#endif 
- 
+// See if that would be more efficient on platforms supporting it,
+// at least for copies.
+
+inline uint64 UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+#else
+
+// These functions are provided for architectures that don't support
+// unaligned loads and stores.
+
+inline uint16 UNALIGNED_LOAD16(const void *p) {
+  uint16 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32 UNALIGNED_LOAD32(const void *p) {
+  uint32 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64 UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UNALIGNED_STORE16(void *p, uint16 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE32(void *p, uint32 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+#endif
+
 // The following guarantees declaration of the byte swap functions.
 #if defined(SNAPPY_IS_BIG_ENDIAN)
- 
+
 #ifdef HAVE_SYS_BYTEORDER_H
 #include <sys/byteorder.h>
 #endif
@@ -293,8 +293,8 @@ inline void UNALIGNED_STORE64(void *p, uint64 v) {
 
 inline uint16 bswap_16(uint16 x) {
   return (x << 8) | (x >> 8);
-} 
- 
+}
+
 inline uint32 bswap_32(uint32 x) {
   x = ((x & 0xff00ff00UL) >> 8) | ((x & 0x00ff00ffUL) << 8);
   return (x >> 16) | (x << 16);
@@ -310,28 +310,28 @@ inline uint64 bswap_64(uint64 x) {
 
 #endif  // defined(SNAPPY_IS_BIG_ENDIAN)
 
-// Convert to little-endian storage, opposite of network format. 
-// Convert x from host to little endian: x = LittleEndian.FromHost(x); 
-// convert x from little endian to host: x = LittleEndian.ToHost(x); 
-// 
-//  Store values into unaligned memory converting to little endian order: 
-//    LittleEndian.Store16(p, x); 
-// 
-//  Load unaligned values stored in little endian converting to host order: 
-//    x = LittleEndian.Load16(p); 
-class LittleEndian { 
- public: 
-  // Conversion functions. 
+// Convert to little-endian storage, opposite of network format.
+// Convert x from host to little endian: x = LittleEndian.FromHost(x);
+// convert x from little endian to host: x = LittleEndian.ToHost(x);
+//
+//  Store values into unaligned memory converting to little endian order:
+//    LittleEndian.Store16(p, x);
+//
+//  Load unaligned values stored in little endian converting to host order:
+//    x = LittleEndian.Load16(p);
+class LittleEndian {
+ public:
+  // Conversion functions.
 #if defined(SNAPPY_IS_BIG_ENDIAN)
- 
+
   static uint16 FromHost16(uint16 x) { return bswap_16(x); }
   static uint16 ToHost16(uint16 x) { return bswap_16(x); }
- 
+
   static uint32 FromHost32(uint32 x) { return bswap_32(x); }
   static uint32 ToHost32(uint32 x) { return bswap_32(x); }
 
-  static bool IsLittleEndian() { return false; } 
- 
+  static bool IsLittleEndian() { return false; }
+
 #else  // !defined(SNAPPY_IS_BIG_ENDIAN)
 
   static uint16 FromHost16(uint16 x) { return x; }
@@ -344,50 +344,50 @@ class LittleEndian {
 
 #endif  // !defined(SNAPPY_IS_BIG_ENDIAN)
 
-  // Functions to do unaligned loads and stores in little-endian order. 
-  static uint16 Load16(const void *p) { 
-    return ToHost16(UNALIGNED_LOAD16(p)); 
-  } 
- 
-  static void Store16(void *p, uint16 v) { 
-    UNALIGNED_STORE16(p, FromHost16(v)); 
-  } 
- 
-  static uint32 Load32(const void *p) { 
-    return ToHost32(UNALIGNED_LOAD32(p)); 
-  } 
- 
-  static void Store32(void *p, uint32 v) { 
-    UNALIGNED_STORE32(p, FromHost32(v)); 
-  } 
-}; 
- 
-// Some bit-manipulation functions. 
-class Bits { 
- public: 
+  // Functions to do unaligned loads and stores in little-endian order.
+  static uint16 Load16(const void *p) {
+    return ToHost16(UNALIGNED_LOAD16(p));
+  }
+
+  static void Store16(void *p, uint16 v) {
+    UNALIGNED_STORE16(p, FromHost16(v));
+  }
+
+  static uint32 Load32(const void *p) {
+    return ToHost32(UNALIGNED_LOAD32(p));
+  }
+
+  static void Store32(void *p, uint32 v) {
+    UNALIGNED_STORE32(p, FromHost32(v));
+  }
+};
+
+// Some bit-manipulation functions.
+class Bits {
+ public:
   // Return floor(log2(n)) for positive integer n.
   static int Log2FloorNonZero(uint32 n);
 
-  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0. 
-  static int Log2Floor(uint32 n); 
- 
-  // Return the first set least / most significant bit, 0-indexed.  Returns an 
-  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except 
-  // that it's 0-indexed. 
-  static int FindLSBSetNonZero(uint32 n); 
+  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+  static int Log2Floor(uint32 n);
+
+  // Return the first set least / most significant bit, 0-indexed.  Returns an
+  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except
+  // that it's 0-indexed.
+  static int FindLSBSetNonZero(uint32 n);
 
 #if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-  static int FindLSBSetNonZero64(uint64 n); 
+  static int FindLSBSetNonZero64(uint64 n);
 #endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
- 
- private: 
+
+ private:
   // No copying
   Bits(const Bits&);
   void operator=(const Bits&);
-}; 
- 
-#ifdef HAVE_BUILTIN_CTZ 
- 
+};
+
+#ifdef HAVE_BUILTIN_CTZ
+
 inline int Bits::Log2FloorNonZero(uint32 n) {
   assert(n != 0);
   // (31 ^ x) is equivalent to (31 - x) for x in [0, 31]. An easy proof
@@ -399,22 +399,22 @@ inline int Bits::Log2FloorNonZero(uint32 n) {
   return 31 ^ __builtin_clz(n);
 }
 
-inline int Bits::Log2Floor(uint32 n) { 
+inline int Bits::Log2Floor(uint32 n) {
   return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
-} 
- 
-inline int Bits::FindLSBSetNonZero(uint32 n) { 
+}
+
+inline int Bits::FindLSBSetNonZero(uint32 n) {
   assert(n != 0);
-  return __builtin_ctz(n); 
-} 
- 
+  return __builtin_ctz(n);
+}
+
 #if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-inline int Bits::FindLSBSetNonZero64(uint64 n) { 
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
   assert(n != 0);
-  return __builtin_ctzll(n); 
-} 
+  return __builtin_ctzll(n);
+}
 #endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
- 
+
 #elif defined(_MSC_VER)
 
 inline int Bits::Log2FloorNonZero(uint32 n) {
@@ -449,158 +449,158 @@ inline int Bits::FindLSBSetNonZero64(uint64 n) {
 }
 #endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
 
-#else  // Portable versions. 
- 
+#else  // Portable versions.
+
 inline int Bits::Log2FloorNonZero(uint32 n) {
   assert(n != 0);
 
-  int log = 0; 
-  uint32 value = n; 
-  for (int i = 4; i >= 0; --i) { 
-    int shift = (1 << i); 
-    uint32 x = value >> shift; 
-    if (x != 0) { 
-      value = x; 
-      log += shift; 
-    } 
-  } 
-  assert(value == 1); 
-  return log; 
-} 
- 
+  int log = 0;
+  uint32 value = n;
+  for (int i = 4; i >= 0; --i) {
+    int shift = (1 << i);
+    uint32 x = value >> shift;
+    if (x != 0) {
+      value = x;
+      log += shift;
+    }
+  }
+  assert(value == 1);
+  return log;
+}
+
 inline int Bits::Log2Floor(uint32 n) {
   return (n == 0) ? -1 : Bits::Log2FloorNonZero(n);
 }
 
-inline int Bits::FindLSBSetNonZero(uint32 n) { 
+inline int Bits::FindLSBSetNonZero(uint32 n) {
   assert(n != 0);
 
-  int rc = 31; 
-  for (int i = 4, shift = 1 << 4; i >= 0; --i) { 
-    const uint32 x = n << shift; 
-    if (x != 0) { 
-      n = x; 
-      rc -= shift; 
-    } 
-    shift >>= 1; 
-  } 
-  return rc; 
-} 
- 
+  int rc = 31;
+  for (int i = 4, shift = 1 << 4; i >= 0; --i) {
+    const uint32 x = n << shift;
+    if (x != 0) {
+      n = x;
+      rc -= shift;
+    }
+    shift >>= 1;
+  }
+  return rc;
+}
+
 #if defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
-// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero(). 
-inline int Bits::FindLSBSetNonZero64(uint64 n) { 
+// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
   assert(n != 0);
 
-  const uint32 bottombits = static_cast<uint32>(n); 
-  if (bottombits == 0) { 
-    // Bottom bits are zero, so scan in top bits 
-    return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32)); 
-  } else { 
-    return FindLSBSetNonZero(bottombits); 
-  } 
-} 
+  const uint32 bottombits = static_cast<uint32>(n);
+  if (bottombits == 0) {
+    // Bottom bits are zero, so scan in top bits
+    return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32));
+  } else {
+    return FindLSBSetNonZero(bottombits);
+  }
+}
 #endif  // defined(ARCH_K8) || defined(ARCH_PPC) || defined(ARCH_ARM)
- 
-#endif  // End portable versions. 
- 
-// Variable-length integer encoding. 
-class Varint { 
- public: 
-  // Maximum lengths of varint encoding of uint32. 
-  static const int kMax32 = 5; 
- 
-  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1]. 
-  // Never reads a character at or beyond limit.  If a valid/terminated varint32 
-  // was found in the range, stores it in *OUTPUT and returns a pointer just 
-  // past the last byte of the varint32. Else returns NULL.  On success, 
-  // "result <= limit". 
-  static const char* Parse32WithLimit(const char* ptr, const char* limit, 
-                                      uint32* OUTPUT); 
- 
-  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v". 
-  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the 
-  //            byte just past the last encoded byte. 
-  static char* Encode32(char* ptr, uint32 v); 
- 
-  // EFFECTS    Appends the varint representation of "value" to "*s". 
+
+#endif  // End portable versions.
+
+// Variable-length integer encoding.
+class Varint {
+ public:
+  // Maximum lengths of varint encoding of uint32.
+  static const int kMax32 = 5;
+
+  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
+  // Never reads a character at or beyond limit.  If a valid/terminated varint32
+  // was found in the range, stores it in *OUTPUT and returns a pointer just
+  // past the last byte of the varint32. Else returns NULL.  On success,
+  // "result <= limit".
+  static const char* Parse32WithLimit(const char* ptr, const char* limit,
+                                      uint32* OUTPUT);
+
+  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v".
+  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the
+  //            byte just past the last encoded byte.
+  static char* Encode32(char* ptr, uint32 v);
+
+  // EFFECTS    Appends the varint representation of "value" to "*s".
   static void Append32(std::string* s, uint32 value);
-}; 
- 
-inline const char* Varint::Parse32WithLimit(const char* p, 
-                                            const char* l, 
-                                            uint32* OUTPUT) { 
-  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p); 
-  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l); 
-  uint32 b, result; 
-  if (ptr >= limit) return NULL; 
-  b = *(ptr++); result = b & 127;          if (b < 128) goto done; 
-  if (ptr >= limit) return NULL; 
-  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done; 
-  if (ptr >= limit) return NULL; 
-  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done; 
-  if (ptr >= limit) return NULL; 
-  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done; 
-  if (ptr >= limit) return NULL; 
-  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done; 
-  return NULL;       // Value is too long to be a varint32 
- done: 
-  *OUTPUT = result; 
-  return reinterpret_cast<const char*>(ptr); 
-} 
- 
-inline char* Varint::Encode32(char* sptr, uint32 v) { 
-  // Operate on characters as unsigneds 
-  unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr); 
-  static const int B = 128; 
-  if (v < (1<<7)) { 
-    *(ptr++) = v; 
-  } else if (v < (1<<14)) { 
-    *(ptr++) = v | B; 
-    *(ptr++) = v>>7; 
-  } else if (v < (1<<21)) { 
-    *(ptr++) = v | B; 
-    *(ptr++) = (v>>7) | B; 
-    *(ptr++) = v>>14; 
-  } else if (v < (1<<28)) { 
-    *(ptr++) = v | B; 
-    *(ptr++) = (v>>7) | B; 
-    *(ptr++) = (v>>14) | B; 
-    *(ptr++) = v>>21; 
-  } else { 
-    *(ptr++) = v | B; 
-    *(ptr++) = (v>>7) | B; 
-    *(ptr++) = (v>>14) | B; 
-    *(ptr++) = (v>>21) | B; 
-    *(ptr++) = v>>28; 
-  } 
-  return reinterpret_cast<char*>(ptr); 
-} 
- 
+};
+
+inline const char* Varint::Parse32WithLimit(const char* p,
+                                            const char* l,
+                                            uint32* OUTPUT) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
+  uint32 b, result;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result = b & 127;          if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
+  return NULL;       // Value is too long to be a varint32
+ done:
+  *OUTPUT = result;
+  return reinterpret_cast<const char*>(ptr);
+}
+
+inline char* Varint::Encode32(char* sptr, uint32 v) {
+  // Operate on characters as unsigneds
+  unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
+  static const int B = 128;
+  if (v < (1<<7)) {
+    *(ptr++) = v;
+  } else if (v < (1<<14)) {
+    *(ptr++) = v | B;
+    *(ptr++) = v>>7;
+  } else if (v < (1<<21)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = v>>14;
+  } else if (v < (1<<28)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = v>>21;
+  } else {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = (v>>21) | B;
+    *(ptr++) = v>>28;
+  }
+  return reinterpret_cast<char*>(ptr);
+}
+
 // If you know the internal layout of the std::string in use, you can
-// replace this function with one that resizes the string without 
-// filling the new space with zeros (if applicable) -- 
-// it will be non-portable but faster. 
+// replace this function with one that resizes the string without
+// filling the new space with zeros (if applicable) --
+// it will be non-portable but faster.
 inline void STLStringResizeUninitialized(std::string* s, size_t new_size) {
   s->resize(new_size);
-} 
- 
-// Return a mutable char* pointing to a string's internal buffer, 
-// which may not be null-terminated. Writing through this pointer will 
-// modify the string. 
-// 
-// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the 
-// next call to a string method that invalidates iterators. 
-// 
-// As of 2006-04, there is no standard-blessed way of getting a 
-// mutable reference to a string's internal buffer. However, issue 530 
-// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530) 
-// proposes this as the method. It will officially be part of the standard 
-// for C++0x. This should already work on all current implementations. 
+}
+
+// Return a mutable char* pointing to a string's internal buffer,
+// which may not be null-terminated. Writing through this pointer will
+// modify the string.
+//
+// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+// next call to a string method that invalidates iterators.
+//
+// As of 2006-04, there is no standard-blessed way of getting a
+// mutable reference to a string's internal buffer. However, issue 530
+// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
+// proposes this as the method. It will officially be part of the standard
+// for C++0x. This should already work on all current implementations.
 inline char* string_as_array(std::string* str) {
   return str->empty() ? NULL : &*str->begin();
-} 
- 
-}  // namespace snappy 
- 
+}
+
+}  // namespace snappy
+
 #endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
diff --git a/contrib/libs/snappy/snappy-stubs-public.h b/contrib/libs/snappy/snappy-stubs-public.h
index 2a2931c4a4..357c4b2e4b 100644
--- a/contrib/libs/snappy/snappy-stubs-public.h
+++ b/contrib/libs/snappy/snappy-stubs-public.h
@@ -1,58 +1,58 @@
-// Copyright 2011 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
-// 
-// Various type stubs for the open-source version of Snappy. 
-// 
-// This file cannot include config.h, as it is included from snappy.h, 
-// which is a public header. Instead, snappy-stubs-public.h is generated by 
-// from snappy-stubs-public.h.in at configure time. 
- 
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Various type stubs for the open-source version of Snappy.
+//
+// This file cannot include config.h, as it is included from snappy.h,
+// which is a public header. Instead, snappy-stubs-public.h is generated by
+// from snappy-stubs-public.h.in at configure time.
+
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
- 
+
 #include <cstddef>
 #include <cstdint>
 #include <string>
- 
+
 #include "config.h"
  
 #if defined(HAVE_SYS_UIO_H)
 #include <sys/uio.h>
 #endif  // HAVE_SYS_UIO_H
 
-#define SNAPPY_MAJOR 1 
+#define SNAPPY_MAJOR 1
 #define SNAPPY_MINOR 1
 #define SNAPPY_PATCHLEVEL 8
-#define SNAPPY_VERSION \ 
-    ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL) 
- 
-namespace snappy { 
- 
+#define SNAPPY_VERSION \
+    ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
+
+namespace snappy {
+
 using int8 = std::int8_t;
 using uint8 = std::uint8_t;
 using int16 = std::int16_t;
@@ -61,7 +61,7 @@ using int32 = std::int32_t;
 using uint32 = std::uint32_t;
 using int64 = std::int64_t;
 using uint64 = std::uint64_t;
- 
+
 #if !defined(HAVE_SYS_UIO_H)
 // Windows does not have an iovec type, yet the concept is universally useful.
 // It is simple to define it ourselves, so we put it inside our own namespace.
@@ -70,7 +70,7 @@ struct iovec {
   size_t iov_len;
 };
 #endif  // !HAVE_SYS_UIO_H
- 
-}  // namespace snappy 
- 
+
+}  // namespace snappy
+
 #endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
diff --git a/contrib/libs/snappy/snappy.cc b/contrib/libs/snappy/snappy.cc
index 27e491c043..9351b0f21e 100644
--- a/contrib/libs/snappy/snappy.cc
+++ b/contrib/libs/snappy/snappy.cc
@@ -1,35 +1,35 @@
-// Copyright 2005 Google Inc. All Rights Reserved. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-#include "snappy.h" 
-#include "snappy-internal.h" 
-#include "snappy-sinksource.h" 
- 
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+#include "snappy.h"
+#include "snappy-internal.h"
+#include "snappy-sinksource.h"
+
 #if !defined(SNAPPY_HAVE_SSSE3)
 // __SSSE3__ is defined by GCC and Clang. Visual Studio doesn't target SIMD
 // support between SSE2 and AVX (so SSSE3 instructions require AVX support), and
@@ -68,60 +68,60 @@
 #include <immintrin.h>
 #endif
 
-#include <stdio.h> 
- 
-#include <algorithm> 
+#include <stdio.h>
+
+#include <algorithm>
 #include <string>
 #include <vector>
 #include <util/generic/string.h>
- 
-namespace snappy { 
- 
+
+namespace snappy {
+
 using internal::COPY_1_BYTE_OFFSET;
 using internal::COPY_2_BYTE_OFFSET;
 using internal::LITERAL;
 using internal::char_table;
 using internal::kMaximumTagLength;
 
-// Any hash function will produce a valid compressed bitstream, but a good 
-// hash function reduces the number of collisions and thus yields better 
-// compression for compressible input, and more speed for incompressible 
-// input. Of course, it doesn't hurt if the hash function is reasonably fast 
-// either, as it gets called a lot. 
-static inline uint32 HashBytes(uint32 bytes, int shift) { 
-  uint32 kMul = 0x1e35a7bd; 
-  return (bytes * kMul) >> shift; 
-} 
-static inline uint32 Hash(const char* p, int shift) { 
-  return HashBytes(UNALIGNED_LOAD32(p), shift); 
-} 
- 
-size_t MaxCompressedLength(size_t source_len) { 
-  // Compressed data can be defined as: 
-  //    compressed := item* literal* 
-  //    item       := literal* copy 
-  // 
-  // The trailing literal sequence has a space blowup of at most 62/60 
-  // since a literal of length 60 needs one tag byte + one extra byte 
-  // for length information. 
-  // 
-  // Item blowup is trickier to measure.  Suppose the "copy" op copies 
-  // 4 bytes of data.  Because of a special check in the encoding code, 
-  // we produce a 4-byte copy only if the offset is < 65536.  Therefore 
-  // the copy op takes 3 bytes to encode, and this type of item leads 
-  // to at most the 62/60 blowup for representing literals. 
-  // 
-  // Suppose the "copy" op copies 5 bytes of data.  If the offset is big 
-  // enough, it will take 5 bytes to encode the copy op.  Therefore the 
-  // worst case here is a one-byte literal followed by a five-byte copy. 
-  // I.e., 6 bytes of input turn into 7 bytes of "compressed" data. 
-  // 
-  // This last factor dominates the blowup, so the final estimate is: 
-  return 32 + source_len + source_len/6; 
-} 
- 
+// Any hash function will produce a valid compressed bitstream, but a good
+// hash function reduces the number of collisions and thus yields better
+// compression for compressible input, and more speed for incompressible
+// input. Of course, it doesn't hurt if the hash function is reasonably fast
+// either, as it gets called a lot.
+static inline uint32 HashBytes(uint32 bytes, int shift) {
+  uint32 kMul = 0x1e35a7bd;
+  return (bytes * kMul) >> shift;
+}
+static inline uint32 Hash(const char* p, int shift) {
+  return HashBytes(UNALIGNED_LOAD32(p), shift);
+}
+
+size_t MaxCompressedLength(size_t source_len) {
+  // Compressed data can be defined as:
+  //    compressed := item* literal*
+  //    item       := literal* copy
+  //
+  // The trailing literal sequence has a space blowup of at most 62/60
+  // since a literal of length 60 needs one tag byte + one extra byte
+  // for length information.
+  //
+  // Item blowup is trickier to measure.  Suppose the "copy" op copies
+  // 4 bytes of data.  Because of a special check in the encoding code,
+  // we produce a 4-byte copy only if the offset is < 65536.  Therefore
+  // the copy op takes 3 bytes to encode, and this type of item leads
+  // to at most the 62/60 blowup for representing literals.
+  //
+  // Suppose the "copy" op copies 5 bytes of data.  If the offset is big
+  // enough, it will take 5 bytes to encode the copy op.  Therefore the
+  // worst case here is a one-byte literal followed by a five-byte copy.
+  // I.e., 6 bytes of input turn into 7 bytes of "compressed" data.
+  //
+  // This last factor dominates the blowup, so the final estimate is:
+  return 32 + source_len + source_len/6;
+}
+
 namespace {
- 
+
 void UnalignedCopy64(const void* src, void* dst) {
   char tmp[8];
   memcpy(tmp, src, 8);
@@ -145,7 +145,7 @@ void UnalignedCopy128(const void* src, void* dst) {
 //    op_limit  == op + 20
 // After IncrementalCopySlow(src, op, op_limit), the result will have eleven
 // copies of "ab"
-//    ababababababababababab 
+//    ababababababababababab
 // Note that this does not match the semantics of either memcpy() or memmove().
 inline char* IncrementalCopySlow(const char* src, char* op,
                                  char* const op_limit) {
@@ -156,13 +156,13 @@ inline char* IncrementalCopySlow(const char* src, char* op,
 #pragma clang loop unroll(disable)
 #endif
   while (op < op_limit) {
-    *op++ = *src++; 
+    *op++ = *src++;
   }
   return op_limit;
-} 
- 
+}
+
 #if SNAPPY_HAVE_SSSE3
- 
+
 // This is a table of shuffle control masks that can be used as the source
 // operand for PSHUFB to permute the contents of the destination XMM register
 // into a repeating byte pattern.
@@ -175,9 +175,9 @@ alignas(16) const char pshufb_fill_patterns[7][16] = {
   {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3},
   {0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1},
 };
- 
+
 #endif  // SNAPPY_HAVE_SSSE3
- 
+
 // Copy [src, src+(op_limit-op)) to [op, (op_limit-op)) but faster than
 // IncrementalCopySlow. buf_limit is the address past the end of the writable
 // region of the buffer.
@@ -194,7 +194,7 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
   // NOTE: The compressor always emits 4 <= len <= 64. It is ok to assume that
   // to optimize this function but we have to also handle other cases in case
   // the input does not satisfy these conditions.
- 
+
   size_t pattern_size = op - src;
   // The cases are split into different branches to allow the branch predictor,
   // FDO, and static prediction hints to work better. For each input we list the
@@ -286,7 +286,7 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
     // conditionals instead of a loop allows FDO to layout the code with respect
     // to the actual probabilities of each length.
     // TODO: Replace with loop with trip count hint.
-    UnalignedCopy64(src, op); 
+    UnalignedCopy64(src, op);
     UnalignedCopy64(src + 8, op + 8);
 
     if (op + 16 < op_limit) {
@@ -302,7 +302,7 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
       UnalignedCopy64(src + 56, op + 56);
     }
     return op_limit;
-  } 
+  }
 
   // Fall back to doing as much as we can with the available slop in the
   // buffer. This code path is relatively cold however so we save code size by
@@ -314,7 +314,7 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
 #pragma clang loop unroll(disable)
 #endif
   for (char *op_end = buf_limit - 16; op < op_end; op += 16, src += 16) {
-    UnalignedCopy64(src, op); 
+    UnalignedCopy64(src, op);
     UnalignedCopy64(src + 8, op + 8);
   }
   if (op >= op_limit)
@@ -324,17 +324,17 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
   // single 8 byte copy.
   if (SNAPPY_PREDICT_FALSE(op <= buf_limit - 8)) {
     UnalignedCopy64(src, op);
-    src += 8; 
-    op += 8; 
-  } 
+    src += 8;
+    op += 8;
+  }
   return IncrementalCopySlow(src, op, op_limit);
-} 
- 
+}
+
 }  // namespace
 
 template <bool allow_fast_path>
-static inline char* EmitLiteral(char* op, 
-                                const char* literal, 
+static inline char* EmitLiteral(char* op,
+                                const char* literal,
                                 int len) {
   // The vast majority of copies are below 16 bytes, for which a
   // call to memcpy is overkill. This fast path can sometimes
@@ -356,13 +356,13 @@ static inline char* EmitLiteral(char* op,
     return op + len;
   }
 
-  if (n < 60) { 
-    // Fits in tag byte 
-    *op++ = LITERAL | (n << 2); 
-  } else { 
+  if (n < 60) {
+    // Fits in tag byte
+    *op++ = LITERAL | (n << 2);
+  } else {
     int count = (Bits::Log2Floor(n) >> 3) + 1;
-    assert(count >= 1); 
-    assert(count <= 4); 
+    assert(count >= 1);
+    assert(count <= 4);
     *op++ = LITERAL | ((59 + count) << 2);
     // Encode in upcoming bytes.
     // Write 4 bytes, though we may care about only 1 of them. The output buffer
@@ -370,33 +370,33 @@ static inline char* EmitLiteral(char* op,
     // here and there is a memcpy of size 'len' below.
     LittleEndian::Store32(op, n);
     op += count;
-  } 
-  memcpy(op, literal, len); 
-  return op + len; 
-} 
- 
+  }
+  memcpy(op, literal, len);
+  return op + len;
+}
+
 template <bool len_less_than_12>
 static inline char* EmitCopyAtMost64(char* op, size_t offset, size_t len) {
   assert(len <= 64);
   assert(len >= 4);
   assert(offset < 65536);
   assert(len_less_than_12 == (len < 12));
- 
+
   if (len_less_than_12 && SNAPPY_PREDICT_TRUE(offset < 2048)) {
     // offset fits in 11 bits.  The 3 highest go in the top of the first byte,
     // and the rest go in the second byte.
     *op++ = COPY_1_BYTE_OFFSET + ((len - 4) << 2) + ((offset >> 3) & 0xe0);
-    *op++ = offset & 0xff; 
-  } else { 
+    *op++ = offset & 0xff;
+  } else {
     // Write 4 bytes, though we only care about 3 of them.  The output buffer
     // is required to have some slack, so the extra byte won't overrun it.
     uint32 u = COPY_2_BYTE_OFFSET + ((len - 1) << 2) + (offset << 8);
     LittleEndian::Store32(op, u);
     op += 3;
-  } 
-  return op; 
-} 
- 
+  }
+  return op;
+}
+
 template <bool len_less_than_12>
 static inline char* EmitCopy(char* op, size_t offset, size_t len) {
   assert(len_less_than_12 == (len < 12));
@@ -405,7 +405,7 @@ static inline char* EmitCopy(char* op, size_t offset, size_t len) {
   } else {
     // A special case for len <= 64 might help, but so far measurements suggest
     // it's in the noise.
- 
+
     // Emit 64 byte copies but make sure to keep at least four bytes reserved.
     while (SNAPPY_PREDICT_FALSE(len >= 68)) {
       op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, 64);
@@ -425,20 +425,20 @@ static inline char* EmitCopy(char* op, size_t offset, size_t len) {
       op = EmitCopyAtMost64</*len_less_than_12=*/false>(op, offset, len);
     }
     return op;
-  } 
-} 
- 
-bool GetUncompressedLength(const char* start, size_t n, size_t* result) { 
-  uint32 v = 0; 
-  const char* limit = start + n; 
-  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) { 
-    *result = v; 
-    return true; 
-  } else { 
-    return false; 
-  } 
-} 
- 
+  }
+}
+
+bool GetUncompressedLength(const char* start, size_t n, size_t* result) {
+  uint32 v = 0;
+  const char* limit = start + n;
+  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) {
+    *result = v;
+    return true;
+  } else {
+    return false;
+  }
+}
+
 namespace {
 uint32 CalculateTableSize(uint32 input_size) {
   static_assert(
@@ -446,16 +446,16 @@ uint32 CalculateTableSize(uint32 input_size) {
       "kMaxHashTableSize should be greater or equal to kMinHashTableSize.");
   if (input_size > kMaxHashTableSize) {
     return kMaxHashTableSize;
-  } 
+  }
   if (input_size < kMinHashTableSize) {
     return kMinHashTableSize;
-  } 
+  }
   // This is equivalent to Log2Ceiling(input_size), assuming input_size > 1.
   // 2 << Log2Floor(x - 1) is equivalent to 1 << (1 + Log2Floor(x - 1)).
   return 2u << Bits::Log2Floor(input_size - 1);
 }
 }  // namespace
- 
+
 namespace internal {
 WorkingMemory::WorkingMemory(size_t input_size) {
   const size_t max_fragment_size = std::min(input_size, kBlockSize);
@@ -476,225 +476,225 @@ uint16* WorkingMemory::GetHashTable(size_t fragment_size,
                                     int* table_size) const {
   const size_t htsize = CalculateTableSize(fragment_size);
   memset(table_, 0, htsize * sizeof(*table_));
-  *table_size = htsize; 
+  *table_size = htsize;
   return table_;
-} 
-}  // end namespace internal 
- 
-// For 0 <= offset <= 4, GetUint32AtOffset(GetEightBytesAt(p), offset) will 
-// equal UNALIGNED_LOAD32(p + offset).  Motivation: On x86-64 hardware we have 
-// empirically found that overlapping loads such as 
-//  UNALIGNED_LOAD32(p) ... UNALIGNED_LOAD32(p+1) ... UNALIGNED_LOAD32(p+2) 
-// are slower than UNALIGNED_LOAD64(p) followed by shifts and casts to uint32. 
-// 
-// We have different versions for 64- and 32-bit; ideally we would avoid the 
-// two functions and just inline the UNALIGNED_LOAD64 call into 
-// GetUint32AtOffset, but GCC (at least not as of 4.6) is seemingly not clever 
-// enough to avoid loading the value multiple times then. For 64-bit, the load 
-// is done when GetEightBytesAt() is called, whereas for 32-bit, the load is 
-// done at GetUint32AtOffset() time. 
- 
-#ifdef ARCH_K8 
- 
-typedef uint64 EightBytesReference; 
- 
-static inline EightBytesReference GetEightBytesAt(const char* ptr) { 
-  return UNALIGNED_LOAD64(ptr); 
-} 
- 
-static inline uint32 GetUint32AtOffset(uint64 v, int offset) { 
+}
+}  // end namespace internal
+
+// For 0 <= offset <= 4, GetUint32AtOffset(GetEightBytesAt(p), offset) will
+// equal UNALIGNED_LOAD32(p + offset).  Motivation: On x86-64 hardware we have
+// empirically found that overlapping loads such as
+//  UNALIGNED_LOAD32(p) ... UNALIGNED_LOAD32(p+1) ... UNALIGNED_LOAD32(p+2)
+// are slower than UNALIGNED_LOAD64(p) followed by shifts and casts to uint32.
+//
+// We have different versions for 64- and 32-bit; ideally we would avoid the
+// two functions and just inline the UNALIGNED_LOAD64 call into
+// GetUint32AtOffset, but GCC (at least not as of 4.6) is seemingly not clever
+// enough to avoid loading the value multiple times then. For 64-bit, the load
+// is done when GetEightBytesAt() is called, whereas for 32-bit, the load is
+// done at GetUint32AtOffset() time.
+
+#ifdef ARCH_K8
+
+typedef uint64 EightBytesReference;
+
+static inline EightBytesReference GetEightBytesAt(const char* ptr) {
+  return UNALIGNED_LOAD64(ptr);
+}
+
+static inline uint32 GetUint32AtOffset(uint64 v, int offset) {
   assert(offset >= 0);
   assert(offset <= 4);
-  return v >> (LittleEndian::IsLittleEndian() ? 8 * offset : 32 - 8 * offset); 
-} 
- 
-#else 
- 
-typedef const char* EightBytesReference; 
- 
-static inline EightBytesReference GetEightBytesAt(const char* ptr) { 
-  return ptr; 
-} 
- 
-static inline uint32 GetUint32AtOffset(const char* v, int offset) { 
+  return v >> (LittleEndian::IsLittleEndian() ? 8 * offset : 32 - 8 * offset);
+}
+
+#else
+
+typedef const char* EightBytesReference;
+
+static inline EightBytesReference GetEightBytesAt(const char* ptr) {
+  return ptr;
+}
+
+static inline uint32 GetUint32AtOffset(const char* v, int offset) {
   assert(offset >= 0);
   assert(offset <= 4);
-  return UNALIGNED_LOAD32(v + offset); 
-} 
- 
-#endif 
- 
-// Flat array compression that does not emit the "uncompressed length" 
-// prefix. Compresses "input" string to the "*op" buffer. 
-// 
-// REQUIRES: "input" is at most "kBlockSize" bytes long. 
-// REQUIRES: "op" points to an array of memory that is at least 
-// "MaxCompressedLength(input.size())" in size. 
-// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. 
-// REQUIRES: "table_size" is a power of two 
-// 
-// Returns an "end" pointer into "op" buffer. 
-// "end - op" is the compressed size of "input". 
-namespace internal { 
-char* CompressFragment(const char* input, 
-                       size_t input_size, 
-                       char* op, 
-                       uint16* table, 
-                       const int table_size) { 
-  // "ip" is the input pointer, and "op" is the output pointer. 
-  const char* ip = input; 
+  return UNALIGNED_LOAD32(v + offset);
+}
+
+#endif
+
+// Flat array compression that does not emit the "uncompressed length"
+// prefix. Compresses "input" string to the "*op" buffer.
+//
+// REQUIRES: "input" is at most "kBlockSize" bytes long.
+// REQUIRES: "op" points to an array of memory that is at least
+// "MaxCompressedLength(input.size())" in size.
+// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+// REQUIRES: "table_size" is a power of two
+//
+// Returns an "end" pointer into "op" buffer.
+// "end - op" is the compressed size of "input".
+namespace internal {
+char* CompressFragment(const char* input,
+                       size_t input_size,
+                       char* op,
+                       uint16* table,
+                       const int table_size) {
+  // "ip" is the input pointer, and "op" is the output pointer.
+  const char* ip = input;
   assert(input_size <= kBlockSize);
   assert((table_size & (table_size - 1)) == 0);  // table must be power of two
-  const int shift = 32 - Bits::Log2Floor(table_size); 
+  const int shift = 32 - Bits::Log2Floor(table_size);
   assert(static_cast<int>(kuint32max >> shift) == table_size - 1);
-  const char* ip_end = input + input_size; 
-  const char* base_ip = ip; 
-  // Bytes in [next_emit, ip) will be emitted as literal bytes.  Or 
-  // [next_emit, ip_end) after the main loop. 
-  const char* next_emit = ip; 
- 
-  const size_t kInputMarginBytes = 15; 
+  const char* ip_end = input + input_size;
+  const char* base_ip = ip;
+  // Bytes in [next_emit, ip) will be emitted as literal bytes.  Or
+  // [next_emit, ip_end) after the main loop.
+  const char* next_emit = ip;
+
+  const size_t kInputMarginBytes = 15;
   if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) {
-    const char* ip_limit = input + input_size - kInputMarginBytes; 
- 
-    for (uint32 next_hash = Hash(++ip, shift); ; ) { 
+    const char* ip_limit = input + input_size - kInputMarginBytes;
+
+    for (uint32 next_hash = Hash(++ip, shift); ; ) {
       assert(next_emit < ip);
-      // The body of this loop calls EmitLiteral once and then EmitCopy one or 
-      // more times.  (The exception is that when we're close to exhausting 
-      // the input we goto emit_remainder.) 
-      // 
-      // In the first iteration of this loop we're just starting, so 
-      // there's nothing to copy, so calling EmitLiteral once is 
-      // necessary.  And we only start a new iteration when the 
-      // current iteration has determined that a call to EmitLiteral will 
-      // precede the next call to EmitCopy (if any). 
-      // 
-      // Step 1: Scan forward in the input looking for a 4-byte-long match. 
-      // If we get close to exhausting the input then goto emit_remainder. 
-      // 
-      // Heuristic match skipping: If 32 bytes are scanned with no matches 
-      // found, start looking only at every other byte. If 32 more bytes are 
+      // The body of this loop calls EmitLiteral once and then EmitCopy one or
+      // more times.  (The exception is that when we're close to exhausting
+      // the input we goto emit_remainder.)
+      //
+      // In the first iteration of this loop we're just starting, so
+      // there's nothing to copy, so calling EmitLiteral once is
+      // necessary.  And we only start a new iteration when the
+      // current iteration has determined that a call to EmitLiteral will
+      // precede the next call to EmitCopy (if any).
+      //
+      // Step 1: Scan forward in the input looking for a 4-byte-long match.
+      // If we get close to exhausting the input then goto emit_remainder.
+      //
+      // Heuristic match skipping: If 32 bytes are scanned with no matches
+      // found, start looking only at every other byte. If 32 more bytes are
       // scanned (or skipped), look at every third byte, etc.. When a match is
       // found, immediately go back to looking at every byte. This is a small
       // loss (~5% performance, ~0.1% density) for compressible data due to more
-      // bookkeeping, but for non-compressible data (such as JPEG) it's a huge 
-      // win since the compressor quickly "realizes" the data is incompressible 
-      // and doesn't bother looking for matches everywhere. 
-      // 
-      // The "skip" variable keeps track of how many bytes there are since the 
-      // last match; dividing it by 32 (ie. right-shifting by five) gives the 
-      // number of bytes to move ahead for each iteration. 
-      uint32 skip = 32; 
- 
-      const char* next_ip = ip; 
-      const char* candidate; 
-      do { 
-        ip = next_ip; 
-        uint32 hash = next_hash; 
+      // bookkeeping, but for non-compressible data (such as JPEG) it's a huge
+      // win since the compressor quickly "realizes" the data is incompressible
+      // and doesn't bother looking for matches everywhere.
+      //
+      // The "skip" variable keeps track of how many bytes there are since the
+      // last match; dividing it by 32 (ie. right-shifting by five) gives the
+      // number of bytes to move ahead for each iteration.
+      uint32 skip = 32;
+
+      const char* next_ip = ip;
+      const char* candidate;
+      do {
+        ip = next_ip;
+        uint32 hash = next_hash;
         assert(hash == Hash(ip, shift));
         uint32 bytes_between_hash_lookups = skip >> 5;
         skip += bytes_between_hash_lookups;
-        next_ip = ip + bytes_between_hash_lookups; 
+        next_ip = ip + bytes_between_hash_lookups;
         if (SNAPPY_PREDICT_FALSE(next_ip > ip_limit)) {
-          goto emit_remainder; 
-        } 
-        next_hash = Hash(next_ip, shift); 
-        candidate = base_ip + table[hash]; 
+          goto emit_remainder;
+        }
+        next_hash = Hash(next_ip, shift);
+        candidate = base_ip + table[hash];
         assert(candidate >= base_ip);
         assert(candidate < ip);
- 
-        table[hash] = ip - base_ip; 
+
+        table[hash] = ip - base_ip;
       } while (SNAPPY_PREDICT_TRUE(UNALIGNED_LOAD32(ip) !=
                                  UNALIGNED_LOAD32(candidate)));
- 
-      // Step 2: A 4-byte match has been found.  We'll later see if more 
-      // than 4 bytes match.  But, prior to the match, input 
-      // bytes [next_emit, ip) are unmatched.  Emit them as "literal bytes." 
+
+      // Step 2: A 4-byte match has been found.  We'll later see if more
+      // than 4 bytes match.  But, prior to the match, input
+      // bytes [next_emit, ip) are unmatched.  Emit them as "literal bytes."
       assert(next_emit + 16 <= ip_end);
       op = EmitLiteral</*allow_fast_path=*/true>(op, next_emit, ip - next_emit);
- 
-      // Step 3: Call EmitCopy, and then see if another EmitCopy could 
-      // be our next move.  Repeat until we find no match for the 
-      // input immediately after what was consumed by the last EmitCopy call. 
-      // 
-      // If we exit this loop normally then we need to call EmitLiteral next, 
-      // though we don't yet know how big the literal will be.  We handle that 
-      // by proceeding to the next iteration of the main loop.  We also can exit 
-      // this loop via goto if we get close to exhausting the input. 
-      EightBytesReference input_bytes; 
-      uint32 candidate_bytes = 0; 
- 
-      do { 
-        // We have a 4-byte match at ip, and no need to emit any 
-        // "literal bytes" prior to ip. 
-        const char* base = ip; 
+
+      // Step 3: Call EmitCopy, and then see if another EmitCopy could
+      // be our next move.  Repeat until we find no match for the
+      // input immediately after what was consumed by the last EmitCopy call.
+      //
+      // If we exit this loop normally then we need to call EmitLiteral next,
+      // though we don't yet know how big the literal will be.  We handle that
+      // by proceeding to the next iteration of the main loop.  We also can exit
+      // this loop via goto if we get close to exhausting the input.
+      EightBytesReference input_bytes;
+      uint32 candidate_bytes = 0;
+
+      do {
+        // We have a 4-byte match at ip, and no need to emit any
+        // "literal bytes" prior to ip.
+        const char* base = ip;
         std::pair<size_t, bool> p =
             FindMatchLength(candidate + 4, ip + 4, ip_end);
         size_t matched = 4 + p.first;
-        ip += matched; 
-        size_t offset = base - candidate; 
+        ip += matched;
+        size_t offset = base - candidate;
         assert(0 == memcmp(base, candidate, matched));
         if (p.second) {
           op = EmitCopy</*len_less_than_12=*/true>(op, offset, matched);
         } else {
           op = EmitCopy</*len_less_than_12=*/false>(op, offset, matched);
         }
-        next_emit = ip; 
+        next_emit = ip;
         if (SNAPPY_PREDICT_FALSE(ip >= ip_limit)) {
-          goto emit_remainder; 
-        } 
+          goto emit_remainder;
+        }
         // We are now looking for a 4-byte match again.  We read
         // table[Hash(ip, shift)] for that.  To improve compression,
         // we also update table[Hash(ip - 1, shift)] and table[Hash(ip, shift)].
         input_bytes = GetEightBytesAt(ip - 1);
-        uint32 prev_hash = HashBytes(GetUint32AtOffset(input_bytes, 0), shift); 
-        table[prev_hash] = ip - base_ip - 1; 
-        uint32 cur_hash = HashBytes(GetUint32AtOffset(input_bytes, 1), shift); 
-        candidate = base_ip + table[cur_hash]; 
-        candidate_bytes = UNALIGNED_LOAD32(candidate); 
-        table[cur_hash] = ip - base_ip; 
-      } while (GetUint32AtOffset(input_bytes, 1) == candidate_bytes); 
- 
-      next_hash = HashBytes(GetUint32AtOffset(input_bytes, 2), shift); 
-      ++ip; 
-    } 
-  } 
- 
- emit_remainder: 
-  // Emit the remaining bytes as a literal 
-  if (next_emit < ip_end) { 
+        uint32 prev_hash = HashBytes(GetUint32AtOffset(input_bytes, 0), shift);
+        table[prev_hash] = ip - base_ip - 1;
+        uint32 cur_hash = HashBytes(GetUint32AtOffset(input_bytes, 1), shift);
+        candidate = base_ip + table[cur_hash];
+        candidate_bytes = UNALIGNED_LOAD32(candidate);
+        table[cur_hash] = ip - base_ip;
+      } while (GetUint32AtOffset(input_bytes, 1) == candidate_bytes);
+
+      next_hash = HashBytes(GetUint32AtOffset(input_bytes, 2), shift);
+      ++ip;
+    }
+  }
+
+ emit_remainder:
+  // Emit the remaining bytes as a literal
+  if (next_emit < ip_end) {
     op = EmitLiteral</*allow_fast_path=*/false>(op, next_emit,
                                                 ip_end - next_emit);
-  } 
- 
-  return op; 
-} 
-}  // end namespace internal 
- 
+  }
+
+  return op;
+}
+}  // end namespace internal
+
 // Called back at avery compression call to trace parameters and sizes.
 static inline void Report(const char *algorithm, size_t compressed_size,
                           size_t uncompressed_size) {}
 
-// Signature of output types needed by decompression code. 
-// The decompression code is templatized on a type that obeys this 
-// signature so that we do not pay virtual function call overhead in 
-// the middle of a tight decompression loop. 
-// 
-// class DecompressionWriter { 
-//  public: 
-//   // Called before decompression 
-//   void SetExpectedLength(size_t length); 
-// 
-//   // Called after decompression 
-//   bool CheckLength() const; 
-// 
-//   // Called repeatedly during decompression 
-//   bool Append(const char* ip, size_t length); 
-//   bool AppendFromSelf(uint32 offset, size_t length); 
-// 
+// Signature of output types needed by decompression code.
+// The decompression code is templatized on a type that obeys this
+// signature so that we do not pay virtual function call overhead in
+// the middle of a tight decompression loop.
+//
+// class DecompressionWriter {
+//  public:
+//   // Called before decompression
+//   void SetExpectedLength(size_t length);
+//
+//   // Called after decompression
+//   bool CheckLength() const;
+//
+//   // Called repeatedly during decompression
+//   bool Append(const char* ip, size_t length);
+//   bool AppendFromSelf(uint32 offset, size_t length);
+//
 //   // The rules for how TryFastAppend differs from Append are somewhat
 //   // convoluted:
-//   // 
+//   //
 //   //  - TryFastAppend is allowed to decline (return false) at any
 //   //    time, for any reason -- just "return false" would be
 //   //    a perfectly legal implementation of TryFastAppend.
@@ -711,10 +711,10 @@ static inline void Report(const char *algorithm, size_t compressed_size,
 //   //    decoded fully. In practice, this should not be a big problem,
 //   //    as it is unlikely that one would implement a fast path accepting
 //   //    this much data.
-//   // 
-//   bool TryFastAppend(const char* ip, size_t available, size_t length); 
-// }; 
- 
+//   //
+//   bool TryFastAppend(const char* ip, size_t available, size_t length);
+// };
+
 static inline uint32 ExtractLowBytes(uint32 v, int n) {
   assert(n >= 0);
   assert(n <= 4);
@@ -726,8 +726,8 @@ static inline uint32 ExtractLowBytes(uint32 v, int n) {
   uint64 mask = 0xffffffff;
   return v & ~(mask << (8 * n));
 #endif
-} 
- 
+}
+
 static inline bool LeftShiftOverflows(uint8 value, uint32 shift) {
   assert(shift < 32);
   static const uint8 masks[] = {
@@ -736,77 +736,77 @@ static inline bool LeftShiftOverflows(uint8 value, uint32 shift) {
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
       0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};
   return (value & masks[shift]) != 0;
-} 
- 
-// Helper class for decompression 
-class SnappyDecompressor { 
- private: 
-  Source*       reader_;         // Underlying source of bytes to decompress 
-  const char*   ip_;             // Points to next buffered byte 
-  const char*   ip_limit_;       // Points just past buffered bytes 
-  uint32        peeked_;         // Bytes peeked from reader (need to skip) 
-  bool          eof_;            // Hit end of input without an error? 
+}
+
+// Helper class for decompression
+class SnappyDecompressor {
+ private:
+  Source*       reader_;         // Underlying source of bytes to decompress
+  const char*   ip_;             // Points to next buffered byte
+  const char*   ip_limit_;       // Points just past buffered bytes
+  uint32        peeked_;         // Bytes peeked from reader (need to skip)
+  bool          eof_;            // Hit end of input without an error?
   char          scratch_[kMaximumTagLength];  // See RefillTag().
- 
-  // Ensure that all of the tag metadata for the next tag is available 
-  // in [ip_..ip_limit_-1].  Also ensures that [ip,ip+4] is readable even 
-  // if (ip_limit_ - ip_ < 5). 
-  // 
-  // Returns true on success, false on error or end of input. 
-  bool RefillTag(); 
- 
- public: 
-  explicit SnappyDecompressor(Source* reader) 
-      : reader_(reader), 
-        ip_(NULL), 
-        ip_limit_(NULL), 
-        peeked_(0), 
-        eof_(false) { 
-  } 
- 
-  ~SnappyDecompressor() { 
-    // Advance past any bytes we peeked at from the reader 
-    reader_->Skip(peeked_); 
-  } 
- 
-  // Returns true iff we have hit the end of the input without an error. 
-  bool eof() const { 
-    return eof_; 
-  } 
- 
-  // Read the uncompressed length stored at the start of the compressed data. 
+
+  // Ensure that all of the tag metadata for the next tag is available
+  // in [ip_..ip_limit_-1].  Also ensures that [ip,ip+4] is readable even
+  // if (ip_limit_ - ip_ < 5).
+  //
+  // Returns true on success, false on error or end of input.
+  bool RefillTag();
+
+ public:
+  explicit SnappyDecompressor(Source* reader)
+      : reader_(reader),
+        ip_(NULL),
+        ip_limit_(NULL),
+        peeked_(0),
+        eof_(false) {
+  }
+
+  ~SnappyDecompressor() {
+    // Advance past any bytes we peeked at from the reader
+    reader_->Skip(peeked_);
+  }
+
+  // Returns true iff we have hit the end of the input without an error.
+  bool eof() const {
+    return eof_;
+  }
+
+  // Read the uncompressed length stored at the start of the compressed data.
   // On success, stores the length in *result and returns true.
-  // On failure, returns false. 
-  bool ReadUncompressedLength(uint32* result) { 
+  // On failure, returns false.
+  bool ReadUncompressedLength(uint32* result) {
     assert(ip_ == NULL);       // Must not have read anything yet
-    // Length is encoded in 1..5 bytes 
-    *result = 0; 
-    uint32 shift = 0; 
-    while (true) { 
-      if (shift >= 32) return false; 
-      size_t n; 
-      const char* ip = reader_->Peek(&n); 
-      if (n == 0) return false; 
-      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip)); 
-      reader_->Skip(1); 
+    // Length is encoded in 1..5 bytes
+    *result = 0;
+    uint32 shift = 0;
+    while (true) {
+      if (shift >= 32) return false;
+      size_t n;
+      const char* ip = reader_->Peek(&n);
+      if (n == 0) return false;
+      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
+      reader_->Skip(1);
       uint32 val = c & 0x7f;
       if (LeftShiftOverflows(static_cast<uint8>(val), shift)) return false;
       *result |= val << shift;
-      if (c < 128) { 
-        break; 
-      } 
-      shift += 7; 
-    } 
-    return true; 
-  } 
- 
-  // Process the next item found in the input. 
-  // Returns true if successful, false on error or end of input. 
-  template <class Writer> 
+      if (c < 128) {
+        break;
+      }
+      shift += 7;
+    }
+    return true;
+  }
+
+  // Process the next item found in the input.
+  // Returns true if successful, false on error or end of input.
+  template <class Writer>
 #if defined(__GNUC__) && defined(__x86_64__)
   __attribute__((aligned(32)))
 #endif
-  void DecompressAllTags(Writer* writer) { 
+  void DecompressAllTags(Writer* writer) {
     // In x86, pad the function body to start 16 bytes later. This function has
     // a couple of hotspots that are highly sensitive to alignment: we have
     // observed regressions by more than 20% in some metrics just by moving the
@@ -823,22 +823,22 @@ class SnappyDecompressor {
     asm(".byte 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 #endif
 
-    const char* ip = ip_; 
-    // We could have put this refill fragment only at the beginning of the loop. 
-    // However, duplicating it at the end of each branch gives the compiler more 
-    // scope to optimize the <ip_limit_ - ip> expression based on the local 
-    // context, which overall increases speed. 
-    #define MAYBE_REFILL() \ 
+    const char* ip = ip_;
+    // We could have put this refill fragment only at the beginning of the loop.
+    // However, duplicating it at the end of each branch gives the compiler more
+    // scope to optimize the <ip_limit_ - ip> expression based on the local
+    // context, which overall increases speed.
+    #define MAYBE_REFILL() \
         if (ip_limit_ - ip < kMaximumTagLength) { \
-          ip_ = ip; \ 
-          if (!RefillTag()) return; \ 
-          ip = ip_; \ 
-        } 
- 
-    MAYBE_REFILL(); 
-    for ( ;; ) { 
-      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip++)); 
- 
+          ip_ = ip; \
+          if (!RefillTag()) return; \
+          ip = ip_; \
+        }
+
+    MAYBE_REFILL();
+    for ( ;; ) {
+      const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip++));
+
       // Ratio of iterations that have LITERAL vs non-LITERAL for different
       // inputs.
       //
@@ -852,202 +852,202 @@ class SnappyDecompressor {
       // pb              24%        76%
       // bin             24%        76%
       if (SNAPPY_PREDICT_FALSE((c & 0x3) == LITERAL)) {
-        size_t literal_length = (c >> 2) + 1u; 
-        if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length)) { 
+        size_t literal_length = (c >> 2) + 1u;
+        if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length)) {
           assert(literal_length < 61);
-          ip += literal_length; 
+          ip += literal_length;
           // NOTE: There is no MAYBE_REFILL() here, as TryFastAppend()
           // will not return true unless there's already at least five spare
           // bytes in addition to the literal.
-          continue; 
-        } 
+          continue;
+        }
         if (SNAPPY_PREDICT_FALSE(literal_length >= 61)) {
-          // Long literal. 
-          const size_t literal_length_length = literal_length - 60; 
-          literal_length = 
+          // Long literal.
+          const size_t literal_length_length = literal_length - 60;
+          literal_length =
               ExtractLowBytes(LittleEndian::Load32(ip), literal_length_length) +
               1;
-          ip += literal_length_length; 
-        } 
- 
-        size_t avail = ip_limit_ - ip; 
-        while (avail < literal_length) { 
-          if (!writer->Append(ip, avail)) return; 
-          literal_length -= avail; 
-          reader_->Skip(peeked_); 
-          size_t n; 
-          ip = reader_->Peek(&n); 
-          avail = n; 
-          peeked_ = avail; 
-          if (avail == 0) return;  // Premature end of input 
-          ip_limit_ = ip + avail; 
-        } 
-        if (!writer->Append(ip, literal_length)) { 
-          return; 
-        } 
-        ip += literal_length; 
-        MAYBE_REFILL(); 
-      } else { 
+          ip += literal_length_length;
+        }
+
+        size_t avail = ip_limit_ - ip;
+        while (avail < literal_length) {
+          if (!writer->Append(ip, avail)) return;
+          literal_length -= avail;
+          reader_->Skip(peeked_);
+          size_t n;
+          ip = reader_->Peek(&n);
+          avail = n;
+          peeked_ = avail;
+          if (avail == 0) return;  // Premature end of input
+          ip_limit_ = ip + avail;
+        }
+        if (!writer->Append(ip, literal_length)) {
+          return;
+        }
+        ip += literal_length;
+        MAYBE_REFILL();
+      } else {
         const size_t entry = char_table[c];
         const size_t trailer =
             ExtractLowBytes(LittleEndian::Load32(ip), entry >> 11);
         const size_t length = entry & 0xff;
-        ip += entry >> 11; 
- 
-        // copy_offset/256 is encoded in bits 8..10.  By just fetching 
-        // those bits, we get copy_offset (since the bit-field starts at 
-        // bit 8). 
+        ip += entry >> 11;
+
+        // copy_offset/256 is encoded in bits 8..10.  By just fetching
+        // those bits, we get copy_offset (since the bit-field starts at
+        // bit 8).
         const size_t copy_offset = entry & 0x700;
-        if (!writer->AppendFromSelf(copy_offset + trailer, length)) { 
-          return; 
-        } 
-        MAYBE_REFILL(); 
-      } 
-    } 
- 
-#undef MAYBE_REFILL 
-  } 
-}; 
- 
-bool SnappyDecompressor::RefillTag() { 
-  const char* ip = ip_; 
-  if (ip == ip_limit_) { 
-    // Fetch a new fragment from the reader 
-    reader_->Skip(peeked_);   // All peeked bytes are used up 
-    size_t n; 
-    ip = reader_->Peek(&n); 
-    peeked_ = n; 
+        if (!writer->AppendFromSelf(copy_offset + trailer, length)) {
+          return;
+        }
+        MAYBE_REFILL();
+      }
+    }
+
+#undef MAYBE_REFILL
+  }
+};
+
+bool SnappyDecompressor::RefillTag() {
+  const char* ip = ip_;
+  if (ip == ip_limit_) {
+    // Fetch a new fragment from the reader
+    reader_->Skip(peeked_);   // All peeked bytes are used up
+    size_t n;
+    ip = reader_->Peek(&n);
+    peeked_ = n;
     eof_ = (n == 0);
     if (eof_) return false;
-    ip_limit_ = ip + n; 
-  } 
- 
-  // Read the tag character 
+    ip_limit_ = ip + n;
+  }
+
+  // Read the tag character
   assert(ip < ip_limit_);
-  const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip)); 
-  const uint32 entry = char_table[c]; 
-  const uint32 needed = (entry >> 11) + 1;  // +1 byte for 'c' 
+  const unsigned char c = *(reinterpret_cast<const unsigned char*>(ip));
+  const uint32 entry = char_table[c];
+  const uint32 needed = (entry >> 11) + 1;  // +1 byte for 'c'
   assert(needed <= sizeof(scratch_));
- 
-  // Read more bytes from reader if needed 
-  uint32 nbuf = ip_limit_ - ip; 
-  if (nbuf < needed) { 
-    // Stitch together bytes from ip and reader to form the word 
-    // contents.  We store the needed bytes in "scratch_".  They 
-    // will be consumed immediately by the caller since we do not 
-    // read more than we need. 
-    memmove(scratch_, ip, nbuf); 
-    reader_->Skip(peeked_);  // All peeked bytes are used up 
-    peeked_ = 0; 
-    while (nbuf < needed) { 
-      size_t length; 
-      const char* src = reader_->Peek(&length); 
-      if (length == 0) return false; 
+
+  // Read more bytes from reader if needed
+  uint32 nbuf = ip_limit_ - ip;
+  if (nbuf < needed) {
+    // Stitch together bytes from ip and reader to form the word
+    // contents.  We store the needed bytes in "scratch_".  They
+    // will be consumed immediately by the caller since we do not
+    // read more than we need.
+    memmove(scratch_, ip, nbuf);
+    reader_->Skip(peeked_);  // All peeked bytes are used up
+    peeked_ = 0;
+    while (nbuf < needed) {
+      size_t length;
+      const char* src = reader_->Peek(&length);
+      if (length == 0) return false;
       uint32 to_add = std::min<uint32>(needed - nbuf, length);
-      memcpy(scratch_ + nbuf, src, to_add); 
-      nbuf += to_add; 
-      reader_->Skip(to_add); 
-    } 
+      memcpy(scratch_ + nbuf, src, to_add);
+      nbuf += to_add;
+      reader_->Skip(to_add);
+    }
     assert(nbuf == needed);
-    ip_ = scratch_; 
-    ip_limit_ = scratch_ + needed; 
+    ip_ = scratch_;
+    ip_limit_ = scratch_ + needed;
   } else if (nbuf < kMaximumTagLength) {
-    // Have enough bytes, but move into scratch_ so that we do not 
-    // read past end of input 
-    memmove(scratch_, ip, nbuf); 
-    reader_->Skip(peeked_);  // All peeked bytes are used up 
-    peeked_ = 0; 
-    ip_ = scratch_; 
-    ip_limit_ = scratch_ + nbuf; 
-  } else { 
-    // Pass pointer to buffer returned by reader_. 
-    ip_ = ip; 
-  } 
-  return true; 
-} 
- 
-template <typename Writer> 
+    // Have enough bytes, but move into scratch_ so that we do not
+    // read past end of input
+    memmove(scratch_, ip, nbuf);
+    reader_->Skip(peeked_);  // All peeked bytes are used up
+    peeked_ = 0;
+    ip_ = scratch_;
+    ip_limit_ = scratch_ + nbuf;
+  } else {
+    // Pass pointer to buffer returned by reader_.
+    ip_ = ip;
+  }
+  return true;
+}
+
+template <typename Writer>
 static bool InternalUncompress(Source* r, Writer* writer) {
-  // Read the uncompressed length from the front of the compressed input 
-  SnappyDecompressor decompressor(r); 
-  uint32 uncompressed_len = 0; 
-  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) return false; 
+  // Read the uncompressed length from the front of the compressed input
+  SnappyDecompressor decompressor(r);
+  uint32 uncompressed_len = 0;
+  if (!decompressor.ReadUncompressedLength(&uncompressed_len)) return false;
 
   return InternalUncompressAllTags(&decompressor, writer, r->Available(),
                                    uncompressed_len);
-} 
- 
-template <typename Writer> 
-static bool InternalUncompressAllTags(SnappyDecompressor* decompressor, 
-                                      Writer* writer, 
+}
+
+template <typename Writer>
+static bool InternalUncompressAllTags(SnappyDecompressor* decompressor,
+                                      Writer* writer,
                                       uint32 compressed_len,
                                       uint32 uncompressed_len) {
   Report("snappy_uncompress", compressed_len, uncompressed_len);
- 
-  writer->SetExpectedLength(uncompressed_len); 
- 
-  // Process the entire input 
-  decompressor->DecompressAllTags(writer); 
+
+  writer->SetExpectedLength(uncompressed_len);
+
+  // Process the entire input
+  decompressor->DecompressAllTags(writer);
   writer->Flush();
-  return (decompressor->eof() && writer->CheckLength()); 
-} 
- 
-bool GetUncompressedLength(Source* source, uint32* result) { 
-  SnappyDecompressor decompressor(source); 
-  return decompressor.ReadUncompressedLength(result); 
-} 
- 
-size_t Compress(Source* reader, Sink* writer) { 
-  size_t written = 0; 
-  size_t N = reader->Available(); 
+  return (decompressor->eof() && writer->CheckLength());
+}
+
+bool GetUncompressedLength(Source* source, uint32* result) {
+  SnappyDecompressor decompressor(source);
+  return decompressor.ReadUncompressedLength(result);
+}
+
+size_t Compress(Source* reader, Sink* writer) {
+  size_t written = 0;
+  size_t N = reader->Available();
   const size_t uncompressed_size = N;
-  char ulength[Varint::kMax32]; 
-  char* p = Varint::Encode32(ulength, N); 
-  writer->Append(ulength, p-ulength); 
-  written += (p - ulength); 
- 
+  char ulength[Varint::kMax32];
+  char* p = Varint::Encode32(ulength, N);
+  writer->Append(ulength, p-ulength);
+  written += (p - ulength);
+
   internal::WorkingMemory wmem(N);
- 
-  while (N > 0) { 
-    // Get next block to compress (without copying if possible) 
-    size_t fragment_size; 
-    const char* fragment = reader->Peek(&fragment_size); 
+
+  while (N > 0) {
+    // Get next block to compress (without copying if possible)
+    size_t fragment_size;
+    const char* fragment = reader->Peek(&fragment_size);
     assert(fragment_size != 0);  // premature end of input
     const size_t num_to_read = std::min(N, kBlockSize);
-    size_t bytes_read = fragment_size; 
- 
-    size_t pending_advance = 0; 
-    if (bytes_read >= num_to_read) { 
-      // Buffer returned by reader is large enough 
-      pending_advance = num_to_read; 
-      fragment_size = num_to_read; 
-    } else { 
+    size_t bytes_read = fragment_size;
+
+    size_t pending_advance = 0;
+    if (bytes_read >= num_to_read) {
+      // Buffer returned by reader is large enough
+      pending_advance = num_to_read;
+      fragment_size = num_to_read;
+    } else {
       char* scratch = wmem.GetScratchInput();
-      memcpy(scratch, fragment, bytes_read); 
-      reader->Skip(bytes_read); 
- 
-      while (bytes_read < num_to_read) { 
-        fragment = reader->Peek(&fragment_size); 
+      memcpy(scratch, fragment, bytes_read);
+      reader->Skip(bytes_read);
+
+      while (bytes_read < num_to_read) {
+        fragment = reader->Peek(&fragment_size);
         size_t n = std::min<size_t>(fragment_size, num_to_read - bytes_read);
-        memcpy(scratch + bytes_read, fragment, n); 
-        bytes_read += n; 
-        reader->Skip(n); 
-      } 
+        memcpy(scratch + bytes_read, fragment, n);
+        bytes_read += n;
+        reader->Skip(n);
+      }
       assert(bytes_read == num_to_read);
-      fragment = scratch; 
-      fragment_size = num_to_read; 
-    } 
+      fragment = scratch;
+      fragment_size = num_to_read;
+    }
     assert(fragment_size == num_to_read);
- 
-    // Get encoding table for compression 
-    int table_size; 
-    uint16* table = wmem.GetHashTable(num_to_read, &table_size); 
- 
-    // Compress input_fragment and append to dest 
-    const int max_output = MaxCompressedLength(num_to_read); 
- 
-    // Need a scratch buffer for the output, in case the byte sink doesn't 
-    // have room for us directly. 
+
+    // Get encoding table for compression
+    int table_size;
+    uint16* table = wmem.GetHashTable(num_to_read, &table_size);
+
+    // Compress input_fragment and append to dest
+    const int max_output = MaxCompressedLength(num_to_read);
+
+    // Need a scratch buffer for the output, in case the byte sink doesn't
+    // have room for us directly.
 
     // Since we encode kBlockSize regions followed by a region
     // which is <= kBlockSize in length, a previously allocated
@@ -1055,19 +1055,19 @@ size_t Compress(Source* reader, Sink* writer) {
     char* dest = writer->GetAppendBuffer(max_output, wmem.GetScratchOutput());
     char* end = internal::CompressFragment(fragment, fragment_size, dest, table,
                                            table_size);
-    writer->Append(dest, end - dest); 
-    written += (end - dest); 
- 
-    N -= num_to_read; 
-    reader->Skip(pending_advance); 
-  } 
- 
+    writer->Append(dest, end - dest);
+    written += (end - dest);
+
+    N -= num_to_read;
+    reader->Skip(pending_advance);
+  }
+
   Report("snappy_compress", written, uncompressed_size);
- 
-  return written; 
-} 
- 
-// ----------------------------------------------------------------------- 
+
+  return written;
+}
+
+// -----------------------------------------------------------------------
 // IOVec interfaces
 // -----------------------------------------------------------------------
 
@@ -1260,60 +1260,60 @@ bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
 }
 
 // -----------------------------------------------------------------------
-// Flat array interfaces 
-// ----------------------------------------------------------------------- 
- 
-// A type that writes to a flat array. 
-// Note that this is not a "ByteSink", but a type that matches the 
-// Writer template argument to SnappyDecompressor::DecompressAllTags(). 
-class SnappyArrayWriter { 
- private: 
-  char* base_; 
-  char* op_; 
-  char* op_limit_; 
- 
- public: 
-  inline explicit SnappyArrayWriter(char* dst) 
-      : base_(dst), 
+// Flat array interfaces
+// -----------------------------------------------------------------------
+
+// A type that writes to a flat array.
+// Note that this is not a "ByteSink", but a type that matches the
+// Writer template argument to SnappyDecompressor::DecompressAllTags().
+class SnappyArrayWriter {
+ private:
+  char* base_;
+  char* op_;
+  char* op_limit_;
+
+ public:
+  inline explicit SnappyArrayWriter(char* dst)
+      : base_(dst),
         op_(dst),
         op_limit_(dst) {
-  } 
- 
-  inline void SetExpectedLength(size_t len) { 
-    op_limit_ = op_ + len; 
-  } 
- 
-  inline bool CheckLength() const { 
-    return op_ == op_limit_; 
-  } 
- 
-  inline bool Append(const char* ip, size_t len) { 
-    char* op = op_; 
-    const size_t space_left = op_limit_ - op; 
-    if (space_left < len) { 
-      return false; 
-    } 
-    memcpy(op, ip, len); 
-    op_ = op + len; 
-    return true; 
-  } 
- 
-  inline bool TryFastAppend(const char* ip, size_t available, size_t len) { 
-    char* op = op_; 
-    const size_t space_left = op_limit_ - op; 
+  }
+
+  inline void SetExpectedLength(size_t len) {
+    op_limit_ = op_ + len;
+  }
+
+  inline bool CheckLength() const {
+    return op_ == op_limit_;
+  }
+
+  inline bool Append(const char* ip, size_t len) {
+    char* op = op_;
+    const size_t space_left = op_limit_ - op;
+    if (space_left < len) {
+      return false;
+    }
+    memcpy(op, ip, len);
+    op_ = op + len;
+    return true;
+  }
+
+  inline bool TryFastAppend(const char* ip, size_t available, size_t len) {
+    char* op = op_;
+    const size_t space_left = op_limit_ - op;
     if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16) {
-      // Fast path, used for the majority (about 95%) of invocations. 
+      // Fast path, used for the majority (about 95%) of invocations.
       UnalignedCopy128(ip, op);
-      op_ = op + len; 
-      return true; 
-    } else { 
-      return false; 
-    } 
-  } 
- 
-  inline bool AppendFromSelf(size_t offset, size_t len) { 
+      op_ = op + len;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  inline bool AppendFromSelf(size_t offset, size_t len) {
     char* const op_end = op_ + len;
- 
+
     // Check if we try to append from before the start of the buffer.
     // Normally this would just be a check for "produced < offset",
     // but "produced <= offset - 1u" is equivalent for every case
@@ -1323,40 +1323,40 @@ class SnappyArrayWriter {
     // into an infinite loop.
     if (Produced() <= offset - 1u || op_end > op_limit_) return false;
     op_ = IncrementalCopy(op_ - offset, op_, op_end, op_limit_);
- 
-    return true; 
-  } 
+
+    return true;
+  }
   inline size_t Produced() const {
     assert(op_ >= base_);
     return op_ - base_;
   }
   inline void Flush() {}
-}; 
- 
-bool RawUncompress(const char* compressed, size_t n, char* uncompressed) { 
-  ByteArraySource reader(compressed, n); 
-  return RawUncompress(&reader, uncompressed); 
-} 
- 
-bool RawUncompress(Source* compressed, char* uncompressed) { 
-  SnappyArrayWriter output(uncompressed); 
+};
+
+bool RawUncompress(const char* compressed, size_t n, char* uncompressed) {
+  ByteArraySource reader(compressed, n);
+  return RawUncompress(&reader, uncompressed);
+}
+
+bool RawUncompress(Source* compressed, char* uncompressed) {
+  SnappyArrayWriter output(uncompressed);
   return InternalUncompress(compressed, &output);
-} 
- 
+}
+
 bool Uncompress(const char* compressed, size_t n, std::string* uncompressed) {
-  size_t ulength; 
-  if (!GetUncompressedLength(compressed, n, &ulength)) { 
-    return false; 
-  } 
+  size_t ulength;
+  if (!GetUncompressedLength(compressed, n, &ulength)) {
+    return false;
+  }
   // On 32-bit builds: max_size() < kuint32max.  Check for that instead
   // of crashing (e.g., consider externally specified compressed data).
   if (ulength > uncompressed->max_size()) {
-    return false; 
-  } 
-  STLStringResizeUninitialized(uncompressed, ulength); 
-  return RawUncompress(compressed, n, string_as_array(uncompressed)); 
-} 
- 
+    return false;
+  }
+  STLStringResizeUninitialized(uncompressed, ulength);
+  return RawUncompress(compressed, n, string_as_array(uncompressed));
+}
+
 bool Uncompress(const char* compressed, size_t n, TString* uncompressed) {
   size_t ulength;
   if (!GetUncompressedLength(compressed, n, &ulength)) {
@@ -1371,72 +1371,72 @@ bool Uncompress(const char* compressed, size_t n, TString* uncompressed) {
   return RawUncompress(compressed, n, uncompressed->begin());
 }
 
-// A Writer that drops everything on the floor and just does validation 
-class SnappyDecompressionValidator { 
- private: 
-  size_t expected_; 
-  size_t produced_; 
- 
- public: 
+// A Writer that drops everything on the floor and just does validation
+class SnappyDecompressionValidator {
+ private:
+  size_t expected_;
+  size_t produced_;
+
+ public:
   inline SnappyDecompressionValidator() : expected_(0), produced_(0) { }
-  inline void SetExpectedLength(size_t len) { 
-    expected_ = len; 
-  } 
-  inline bool CheckLength() const { 
-    return expected_ == produced_; 
-  } 
-  inline bool Append(const char* ip, size_t len) { 
-    produced_ += len; 
-    return produced_ <= expected_; 
-  } 
-  inline bool TryFastAppend(const char* ip, size_t available, size_t length) { 
-    return false; 
-  } 
-  inline bool AppendFromSelf(size_t offset, size_t len) { 
+  inline void SetExpectedLength(size_t len) {
+    expected_ = len;
+  }
+  inline bool CheckLength() const {
+    return expected_ == produced_;
+  }
+  inline bool Append(const char* ip, size_t len) {
+    produced_ += len;
+    return produced_ <= expected_;
+  }
+  inline bool TryFastAppend(const char* ip, size_t available, size_t length) {
+    return false;
+  }
+  inline bool AppendFromSelf(size_t offset, size_t len) {
     // See SnappyArrayWriter::AppendFromSelf for an explanation of
     // the "offset - 1u" trick.
     if (produced_ <= offset - 1u) return false;
-    produced_ += len; 
-    return produced_ <= expected_; 
-  } 
+    produced_ += len;
+    return produced_ <= expected_;
+  }
   inline void Flush() {}
-}; 
- 
-bool IsValidCompressedBuffer(const char* compressed, size_t n) { 
-  ByteArraySource reader(compressed, n); 
-  SnappyDecompressionValidator writer; 
+};
+
+bool IsValidCompressedBuffer(const char* compressed, size_t n) {
+  ByteArraySource reader(compressed, n);
+  SnappyDecompressionValidator writer;
   return InternalUncompress(&reader, &writer);
-} 
- 
+}
+
 bool IsValidCompressed(Source* compressed) {
   SnappyDecompressionValidator writer;
   return InternalUncompress(compressed, &writer);
 }
 
-void RawCompress(const char* input, 
-                 size_t input_length, 
-                 char* compressed, 
-                 size_t* compressed_length) { 
-  ByteArraySource reader(input, input_length); 
-  UncheckedByteArraySink writer(compressed); 
-  Compress(&reader, &writer); 
- 
-  // Compute how many bytes were added 
-  *compressed_length = (writer.CurrentDestination() - compressed); 
-} 
- 
+void RawCompress(const char* input,
+                 size_t input_length,
+                 char* compressed,
+                 size_t* compressed_length) {
+  ByteArraySource reader(input, input_length);
+  UncheckedByteArraySink writer(compressed);
+  Compress(&reader, &writer);
+
+  // Compute how many bytes were added
+  *compressed_length = (writer.CurrentDestination() - compressed);
+}
+
 size_t Compress(const char* input, size_t input_length,
                 std::string* compressed) {
-  // Pre-grow the buffer to the max length of the compressed output 
+  // Pre-grow the buffer to the max length of the compressed output
   STLStringResizeUninitialized(compressed, MaxCompressedLength(input_length));
- 
-  size_t compressed_length; 
-  RawCompress(input, input_length, string_as_array(compressed), 
-              &compressed_length); 
-  compressed->resize(compressed_length); 
-  return compressed_length; 
-} 
- 
+
+  size_t compressed_length;
+  RawCompress(input, input_length, string_as_array(compressed),
+              &compressed_length);
+  compressed->resize(compressed_length);
+  return compressed_length;
+}
+
 size_t Compress(const char* input, size_t input_length,
                 TString* compressed) {
   // Pre-grow the buffer to the max length of the compressed output
@@ -1452,14 +1452,14 @@ size_t Compress(const char* input, size_t input_length,
 // -----------------------------------------------------------------------
 // Sink interface
 // -----------------------------------------------------------------------
- 
+
 // A type that decompresses into a Sink. The template parameter
 // Allocator must export one method "char* Allocate(int size);", which
 // allocates a buffer of "size" and appends that to the destination.
 template <typename Allocator>
 class SnappyScatteredWriter {
   Allocator allocator_;
- 
+
   // We need random access into the data generated so far.  Therefore
   // we keep track of all of the generated data as an array of blocks.
   // All of the blocks except the last have length kBlockSize.
diff --git a/contrib/libs/snappy/snappy.h b/contrib/libs/snappy/snappy.h
index a91ef2b4d5..9a3bc3fa64 100644
--- a/contrib/libs/snappy/snappy.h
+++ b/contrib/libs/snappy/snappy.h
@@ -1,63 +1,63 @@
-// Copyright 2005 and onwards Google Inc. 
-// 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
-// 
-// A light-weight compression algorithm.  It is designed for speed of 
-// compression and decompression, rather than for the utmost in space 
-// savings. 
-// 
-// For getting better compression ratios when you are compressing data 
-// with long repeated sequences or compressing data that is similar to 
-// other data, while still compressing fast, you might look at first 
-// using BMDiff and then compressing the output of BMDiff with 
-// Snappy. 
- 
+// Copyright 2005 and onwards Google Inc.
+//
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// A light-weight compression algorithm.  It is designed for speed of
+// compression and decompression, rather than for the utmost in space
+// savings.
+//
+// For getting better compression ratios when you are compressing data
+// with long repeated sequences or compressing data that is similar to
+// other data, while still compressing fast, you might look at first
+// using BMDiff and then compressing the output of BMDiff with
+// Snappy.
+
 #ifndef THIRD_PARTY_SNAPPY_SNAPPY_H__
 #define THIRD_PARTY_SNAPPY_SNAPPY_H__
- 
+
 #include <cstddef>
 #include <string>
- 
+
 #include <util/generic/fwd.h>
 
-#include "snappy-stubs-public.h" 
- 
-namespace snappy { 
-  class Source; 
-  class Sink; 
- 
-  // ------------------------------------------------------------------------ 
-  // Generic compression/decompression routines. 
-  // ------------------------------------------------------------------------ 
- 
-  // Compress the bytes read from "*source" and append to "*sink". Return the 
-  // number of bytes written. 
-  size_t Compress(Source* source, Sink* sink); 
- 
+#include "snappy-stubs-public.h"
+
+namespace snappy {
+  class Source;
+  class Sink;
+
+  // ------------------------------------------------------------------------
+  // Generic compression/decompression routines.
+  // ------------------------------------------------------------------------
+
+  // Compress the bytes read from "*source" and append to "*sink". Return the
+  // number of bytes written.
+  size_t Compress(Source* source, Sink* sink);
+
   // Find the uncompressed length of the given stream, as given by the header.
   // Note that the true length could deviate from this; the stream could e.g.
   // be truncated.
@@ -65,37 +65,37 @@ namespace snappy {
   // Also note that this leaves "*source" in a state that is unsuitable for
   // further operations, such as RawUncompress(). You will need to rewind
   // or recreate the source yourself before attempting any further calls.
-  bool GetUncompressedLength(Source* source, uint32* result); 
- 
-  // ------------------------------------------------------------------------ 
-  // Higher-level string based routines (should be sufficient for most users) 
-  // ------------------------------------------------------------------------ 
- 
+  bool GetUncompressedLength(Source* source, uint32* result);
+
+  // ------------------------------------------------------------------------
+  // Higher-level string based routines (should be sufficient for most users)
+  // ------------------------------------------------------------------------
+
   // Sets "*compressed" to the compressed version of "input[0,input_length-1]".
   // Original contents of *compressed are lost.
-  // 
+  //
   // REQUIRES: "input[]" is not an alias of "*compressed".
   size_t Compress(const char* input, size_t input_length,
                   std::string* compressed);
   size_t Compress(const char* input, size_t input_length,
                   TString* compressed);
- 
-  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed". 
-  // Original contents of "*uncompressed" are lost. 
-  // 
-  // REQUIRES: "compressed[]" is not an alias of "*uncompressed". 
-  // 
-  // returns false if the message is corrupted and could not be decompressed 
-  bool Uncompress(const char* compressed, size_t compressed_length, 
+
+  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
+  // Original contents of "*uncompressed" are lost.
+  //
+  // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
+  //
+  // returns false if the message is corrupted and could not be decompressed
+  bool Uncompress(const char* compressed, size_t compressed_length,
                   std::string* uncompressed);
   bool Uncompress(const char* compressed, size_t compressed_length,
                   TString* uncompressed);
- 
+
   // Decompresses "compressed" to "*uncompressed".
   //
   // returns false if the message is corrupted and could not be decompressed
   bool Uncompress(Source* compressed, Sink* uncompressed);
- 
+
   // This routine uncompresses as much of the "compressed" as possible
   // into sink.  It returns the number of valid bytes added to sink
   // (extra invalid bytes may have been added due to errors; the caller
@@ -104,45 +104,45 @@ namespace snappy {
   // encountered.
   size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed);
 
-  // ------------------------------------------------------------------------ 
-  // Lower-level character array based routines.  May be useful for 
-  // efficiency reasons in certain circumstances. 
-  // ------------------------------------------------------------------------ 
- 
-  // REQUIRES: "compressed" must point to an area of memory that is at 
-  // least "MaxCompressedLength(input_length)" bytes in length. 
-  // 
-  // Takes the data stored in "input[0..input_length]" and stores 
-  // it in the array pointed to by "compressed". 
-  // 
-  // "*compressed_length" is set to the length of the compressed output. 
-  // 
-  // Example: 
-  //    char* output = new char[snappy::MaxCompressedLength(input_length)]; 
-  //    size_t output_length; 
-  //    RawCompress(input, input_length, output, &output_length); 
-  //    ... Process(output, output_length) ... 
-  //    delete [] output; 
-  void RawCompress(const char* input, 
-                   size_t input_length, 
-                   char* compressed, 
-                   size_t* compressed_length); 
- 
-  // Given data in "compressed[0..compressed_length-1]" generated by 
-  // calling the Snappy::Compress routine, this routine 
-  // stores the uncompressed data to 
-  //    uncompressed[0..GetUncompressedLength(compressed)-1] 
-  // returns false if the message is corrupted and could not be decrypted 
-  bool RawUncompress(const char* compressed, size_t compressed_length, 
-                     char* uncompressed); 
- 
-  // Given data from the byte source 'compressed' generated by calling 
-  // the Snappy::Compress routine, this routine stores the uncompressed 
-  // data to 
-  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1] 
-  // returns false if the message is corrupted and could not be decrypted 
-  bool RawUncompress(Source* compressed, char* uncompressed); 
- 
+  // ------------------------------------------------------------------------
+  // Lower-level character array based routines.  May be useful for
+  // efficiency reasons in certain circumstances.
+  // ------------------------------------------------------------------------
+
+  // REQUIRES: "compressed" must point to an area of memory that is at
+  // least "MaxCompressedLength(input_length)" bytes in length.
+  //
+  // Takes the data stored in "input[0..input_length]" and stores
+  // it in the array pointed to by "compressed".
+  //
+  // "*compressed_length" is set to the length of the compressed output.
+  //
+  // Example:
+  //    char* output = new char[snappy::MaxCompressedLength(input_length)];
+  //    size_t output_length;
+  //    RawCompress(input, input_length, output, &output_length);
+  //    ... Process(output, output_length) ...
+  //    delete [] output;
+  void RawCompress(const char* input,
+                   size_t input_length,
+                   char* compressed,
+                   size_t* compressed_length);
+
+  // Given data in "compressed[0..compressed_length-1]" generated by
+  // calling the Snappy::Compress routine, this routine
+  // stores the uncompressed data to
+  //    uncompressed[0..GetUncompressedLength(compressed)-1]
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompress(const char* compressed, size_t compressed_length,
+                     char* uncompressed);
+
+  // Given data from the byte source 'compressed' generated by calling
+  // the Snappy::Compress routine, this routine stores the uncompressed
+  // data to
+  //    uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1]
+  // returns false if the message is corrupted and could not be decrypted
+  bool RawUncompress(Source* compressed, char* uncompressed);
+
   // Given data in "compressed[0..compressed_length-1]" generated by
   // calling the Snappy::Compress routine, this routine
   // stores the uncompressed data to the iovec "iov". The number of physical
@@ -165,24 +165,24 @@ namespace snappy {
   bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov,
                             size_t iov_cnt);
 
-  // Returns the maximal size of the compressed representation of 
-  // input data that is "source_bytes" bytes in length; 
-  size_t MaxCompressedLength(size_t source_bytes); 
- 
-  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress() 
-  // Returns true and stores the length of the uncompressed data in 
-  // *result normally.  Returns false on parsing error. 
-  // This operation takes O(1) time. 
-  bool GetUncompressedLength(const char* compressed, size_t compressed_length, 
-                             size_t* result); 
- 
-  // Returns true iff the contents of "compressed[]" can be uncompressed 
-  // successfully.  Does not return the uncompressed data.  Takes 
-  // time proportional to compressed_length, but is usually at least 
-  // a factor of four faster than actual decompression. 
-  bool IsValidCompressedBuffer(const char* compressed, 
-                               size_t compressed_length); 
- 
+  // Returns the maximal size of the compressed representation of
+  // input data that is "source_bytes" bytes in length;
+  size_t MaxCompressedLength(size_t source_bytes);
+
+  // REQUIRES: "compressed[]" was produced by RawCompress() or Compress()
+  // Returns true and stores the length of the uncompressed data in
+  // *result normally.  Returns false on parsing error.
+  // This operation takes O(1) time.
+  bool GetUncompressedLength(const char* compressed, size_t compressed_length,
+                             size_t* result);
+
+  // Returns true iff the contents of "compressed[]" can be uncompressed
+  // successfully.  Does not return the uncompressed data.  Takes
+  // time proportional to compressed_length, but is usually at least
+  // a factor of four faster than actual decompression.
+  bool IsValidCompressedBuffer(const char* compressed,
+                               size_t compressed_length);
+
   // Returns true iff the contents of "compressed" can be uncompressed
   // successfully.  Does not return the uncompressed data.  Takes
   // time proportional to *compressed length, but is usually at least
@@ -196,18 +196,18 @@ namespace snappy {
   // can only store 16-bit offsets, and EmitCopy() also assumes the offset
   // is 65535 bytes or less. Note also that if you change this, it will
   // affect the framing format (see framing_format.txt).
-  // 
+  //
   // Note that there might be older data around that is compressed with larger
   // block sizes, so the decompression code should not rely on the
   // non-existence of long backreferences.
   static constexpr int kBlockLog = 16;
   static constexpr size_t kBlockSize = 1 << kBlockLog;
- 
+
   static constexpr int kMinHashTableBits = 8;
   static constexpr size_t kMinHashTableSize = 1 << kMinHashTableBits;
- 
+
   static constexpr int kMaxHashTableBits = 14;
   static constexpr size_t kMaxHashTableSize = 1 << kMaxHashTableBits;
-}  // end namespace snappy 
- 
+}  // end namespace snappy
+
 #endif  // THIRD_PARTY_SNAPPY_SNAPPY_H__
diff --git a/contrib/libs/snappy/ya.make b/contrib/libs/snappy/ya.make
index 4fb0aef69c..472daa0c80 100644
--- a/contrib/libs/snappy/ya.make
+++ b/contrib/libs/snappy/ya.make
@@ -1,6 +1,6 @@
 # Generated by devtools/yamaker from nixpkgs 92c884dfd7140a6c3e6c717cf8990f7a78524331.
 
-LIBRARY() 
+LIBRARY()
 
 OWNER(g:cpp-contrib)
 
@@ -11,7 +11,7 @@ ORIGINAL_SOURCE(https://github.com/google/snappy/archive/1.1.8.tar.gz)
 LICENSE(BSD-3-Clause)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
- 
+
 ADDINCL(
     GLOBAL contrib/libs/snappy/include
 )
@@ -21,12 +21,12 @@ NO_COMPILER_WARNINGS()
 CFLAGS(
     -DHAVE_CONFIG_H
 )
- 
-SRCS( 
-    snappy-c.cc 
+
+SRCS(
+    snappy-c.cc
     snappy-sinksource.cc
-    snappy-stubs-internal.cc 
+    snappy-stubs-internal.cc
     snappy.cc
-) 
- 
-END() 
+)
+
+END()