Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 2 of 2.

3 files changed, 137 insertions, 137 deletions

diff --git a/util/digest/multi_ut.pyx b/util/digest/multi_ut.pyx
index 6b032f5f86..26faa0069b 100644
--- a/util/digest/multi_ut.pyx
+++ b/util/digest/multi_ut.pyx
@@ -8,11 +8,11 @@ import unittest
 class TestMultiHash(unittest.TestCase):
 
     def test_str_int(self):
-        value = MultiHash(TString(b"1234567"), 123) 
+        value = MultiHash(TString(b"1234567"), 123)
         self.assertEquals(value, 17038203285960021630)
 
     def test_int_str(self):
-        value = MultiHash(123, TString(b"1234567")) 
+        value = MultiHash(123, TString(b"1234567"))
         self.assertEquals(value, 9973288649881090712)
 
     def test_collision(self):
diff --git a/util/digest/murmur.cpp b/util/digest/murmur.cpp
index 84df22304d..b041d3e5f2 100644
--- a/util/digest/murmur.cpp
+++ b/util/digest/murmur.cpp
@@ -2,130 +2,130 @@
 
 #include <util/system/unaligned_mem.h>
 
-namespace NMurmurPrivate { 
-    //----------------------------------------------------------------------------- 
-    // MurmurHash2, by Austin Appleby 
- 
-    // Note - This code makes a few assumptions about how your machine behaves - 
- 
-    // 1. We can read a 4-byte value from any address without crashing 
-    // 2. sizeof(int) == 4 
- 
-    // And it has a few limitations - 
- 
-    // 1. It will not work incrementally. 
-    // 2. It will not produce the same results on little-endian and big-endian 
-    //    machines. 
- 
-    Y_NO_INLINE ui32 MurmurHash32(const void* key, size_t len, ui32 seed) noexcept { 
-        const ui32 m = 0x5bd1e995; 
-        const int r = 24; 
-        ui32 h = ui32(seed ^ len); 
- 
-        TUnalignedMemoryIterator<ui32> iter(key, len); 
- 
-        while (!iter.AtEnd()) { 
-            ui32 k = iter.Next(); 
- 
-            k *= m; 
-            k ^= k >> r; 
-            k *= m; 
- 
-            h *= m; 
-            h ^= k; 
-        } 
- 
-        const unsigned char* data = iter.Last(); 
- 
-        switch (iter.Left()) { 
-            case 3: 
-                h ^= data[2] << 16; 
+namespace NMurmurPrivate {
+    //-----------------------------------------------------------------------------
+    // MurmurHash2, by Austin Appleby
+
+    // Note - This code makes a few assumptions about how your machine behaves -
+
+    // 1. We can read a 4-byte value from any address without crashing
+    // 2. sizeof(int) == 4
+
+    // And it has a few limitations -
+
+    // 1. It will not work incrementally.
+    // 2. It will not produce the same results on little-endian and big-endian
+    //    machines.
+
+    Y_NO_INLINE ui32 MurmurHash32(const void* key, size_t len, ui32 seed) noexcept {
+        const ui32 m = 0x5bd1e995;
+        const int r = 24;
+        ui32 h = ui32(seed ^ len);
+
+        TUnalignedMemoryIterator<ui32> iter(key, len);
+
+        while (!iter.AtEnd()) {
+            ui32 k = iter.Next();
+
+            k *= m;
+            k ^= k >> r;
+            k *= m;
+
+            h *= m;
+            h ^= k;
+        }
+
+        const unsigned char* data = iter.Last();
+
+        switch (iter.Left()) {
+            case 3:
+                h ^= data[2] << 16;
                 [[fallthrough]];
- 
-            case 2: 
-                h ^= data[1] << 8; 
+
+            case 2:
+                h ^= data[1] << 8;
                 [[fallthrough]];
- 
-            case 1: 
-                h ^= data[0]; 
-                h *= m; 
+
+            case 1:
+                h ^= data[0];
+                h *= m;
                 break;
-        }; 
- 
-        h ^= h >> 13; 
-        h *= m; 
-        h ^= h >> 15; 
- 
-        return h; 
-    } 
- 
-    //----------------------------------------------------------------------------- 
-    // MurmurHash2, 64-bit versions, by Austin Appleby 
- 
-    // The same caveats as 32-bit MurmurHash2 apply here - beware of alignment 
-    // and endian-ness issues if used across multiple platforms. 
- 
-    // 64-bit hash for 64-bit platforms 
- 
-    Y_NO_INLINE ui64 MurmurHash64(const void* key, size_t len, ui64 seed) noexcept { 
-        const ui64 m = ULL(0xc6a4a7935bd1e995); 
-        const int r = 47; 
- 
-        ui64 h = seed ^ (len * m); 
-        TUnalignedMemoryIterator<ui64> iter(key, len); 
- 
-        while (!iter.AtEnd()) { 
-            ui64 k = iter.Next(); 
- 
-            k *= m; 
-            k ^= k >> r; 
-            k *= m; 
- 
-            h ^= k; 
-            h *= m; 
-        } 
- 
-        const unsigned char* data2 = iter.Last(); 
- 
-        switch (iter.Left()) { 
-            case 7: 
-                h ^= ui64(data2[6]) << 48; 
+        };
+
+        h ^= h >> 13;
+        h *= m;
+        h ^= h >> 15;
+
+        return h;
+    }
+
+    //-----------------------------------------------------------------------------
+    // MurmurHash2, 64-bit versions, by Austin Appleby
+
+    // The same caveats as 32-bit MurmurHash2 apply here - beware of alignment
+    // and endian-ness issues if used across multiple platforms.
+
+    // 64-bit hash for 64-bit platforms
+
+    Y_NO_INLINE ui64 MurmurHash64(const void* key, size_t len, ui64 seed) noexcept {
+        const ui64 m = ULL(0xc6a4a7935bd1e995);
+        const int r = 47;
+
+        ui64 h = seed ^ (len * m);
+        TUnalignedMemoryIterator<ui64> iter(key, len);
+
+        while (!iter.AtEnd()) {
+            ui64 k = iter.Next();
+
+            k *= m;
+            k ^= k >> r;
+            k *= m;
+
+            h ^= k;
+            h *= m;
+        }
+
+        const unsigned char* data2 = iter.Last();
+
+        switch (iter.Left()) {
+            case 7:
+                h ^= ui64(data2[6]) << 48;
                 [[fallthrough]];
- 
-            case 6: 
-                h ^= ui64(data2[5]) << 40; 
+
+            case 6:
+                h ^= ui64(data2[5]) << 40;
                 [[fallthrough]];
- 
-            case 5: 
-                h ^= ui64(data2[4]) << 32; 
+
+            case 5:
+                h ^= ui64(data2[4]) << 32;
                 [[fallthrough]];
- 
-            case 4: 
-                h ^= ui64(data2[3]) << 24; 
+
+            case 4:
+                h ^= ui64(data2[3]) << 24;
                 [[fallthrough]];
- 
-            case 3: 
-                h ^= ui64(data2[2]) << 16; 
+
+            case 3:
+                h ^= ui64(data2[2]) << 16;
                 [[fallthrough]];
- 
-            case 2: 
-                h ^= ui64(data2[1]) << 8; 
+
+            case 2:
+                h ^= ui64(data2[1]) << 8;
                 [[fallthrough]];
- 
-            case 1: 
-                h ^= ui64(data2[0]); 
-                h *= m; 
+
+            case 1:
+                h ^= ui64(data2[0]);
+                h *= m;
                 break;
-        } 
- 
-        h ^= h >> r; 
-        h *= m; 
-        h ^= h >> r; 
- 
-        return h; 
-    } 
-} 
- 
+        }
+
+        h ^= h >> r;
+        h *= m;
+        h ^= h >> r;
+
+        return h;
+    }
+}
+
 size_t MurmurHashSizeT(const char* buf, size_t len) noexcept {
     return MurmurHash<size_t>(buf, len);
 }
diff --git a/util/digest/murmur.h b/util/digest/murmur.h
index eec9bcc171..6b519b430a 100644
--- a/util/digest/murmur.h
+++ b/util/digest/murmur.h
@@ -3,35 +3,35 @@
 #include <util/system/defaults.h>
 #include <util/generic/array_ref.h>
 
-/* 
- * murmur2 from http://murmurhash.googlepages.com/ 
- * 
+/*
+ * murmur2 from http://murmurhash.googlepages.com/
+ *
  */
-namespace NMurmurPrivate { 
+namespace NMurmurPrivate {
     Y_PURE_FUNCTION ui32 MurmurHash32(const void* key, size_t len, ui32 seed) noexcept;
 
     Y_PURE_FUNCTION ui64 MurmurHash64(const void* key, size_t len, ui64 seed) noexcept;
 
-    template <unsigned N> 
-    struct TMurHelper; 
-
-#define DEF_MUR(t)                                                                         \ 
-    template <>                                                                            \ 
-    struct TMurHelper<t> {                                                                 \ 
-        static inline ui##t MurmurHash(const void* buf, size_t len, ui##t init) noexcept { \ 
-            return MurmurHash##t(buf, len, init);                                          \ 
-        }                                                                                  \ 
-    }; 
- 
-    DEF_MUR(32) 
-    DEF_MUR(64) 
- 
-#undef DEF_MUR 
+    template <unsigned N>
+    struct TMurHelper;
+
+#define DEF_MUR(t)                                                                         \
+    template <>                                                                            \
+    struct TMurHelper<t> {                                                                 \
+        static inline ui##t MurmurHash(const void* buf, size_t len, ui##t init) noexcept { \
+            return MurmurHash##t(buf, len, init);                                          \
+        }                                                                                  \
+    };
+
+    DEF_MUR(32)
+    DEF_MUR(64)
+
+#undef DEF_MUR
 }
 
 template <class T>
-static inline T MurmurHash(const void* buf, size_t len, T init) noexcept { 
-    return (T)NMurmurPrivate::TMurHelper<8 * sizeof(T)>::MurmurHash(buf, len, init); 
+static inline T MurmurHash(const void* buf, size_t len, T init) noexcept {
+    return (T)NMurmurPrivate::TMurHelper<8 * sizeof(T)>::MurmurHash(buf, len, init);
 }
 
 template <class T>