Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 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 473a0b0978..0cb59c7296 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 32aa0c6b8b..826bccfded 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 1e1c307fef..28c179ee46 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 369a13215b..42651664bf 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 8afcdaaa2c..75aa872653 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 66ed2e9039..3e43a2124b 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 4854689d17..48b40bac98 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 357c4b2e4b..2a2931c4a4 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 9351b0f21e..27e491c043 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 9a3bc3fa64..a91ef2b4d5 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 472daa0c80..4fb0aef69c 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()