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

1 files changed, 386 insertions, 386 deletions

diff --git a/util/generic/bitmap_ut.cpp b/util/generic/bitmap_ut.cpp
index 67156303a04..087d34a8dcc 100644
--- a/util/generic/bitmap_ut.cpp
+++ b/util/generic/bitmap_ut.cpp
@@ -3,10 +3,10 @@
 #include <library/cpp/testing/unittest/registar.h>
 
 #define INIT_BITMAP(bitmap, bits)                                \
-    for (size_t i = 0; i < sizeof(bits) / sizeof(size_t); ++i) { \ 
+    for (size_t i = 0; i < sizeof(bits) / sizeof(size_t); ++i) { \
         bitmap.Set(bits[i]);                                     \
-    } 
- 
+    }
+
 #define CHECK_BITMAP(bitmap, bits)                                      \
     {                                                                   \
         size_t cur = 0, end = sizeof(bits) / sizeof(size_t);            \
@@ -15,11 +15,11 @@
                 UNIT_ASSERT_EQUAL_C(bitmap.Get(i), true, "pos=" << i);  \
                 ++cur;                                                  \
             } else {                                                    \
-                UNIT_ASSERT_EQUAL_C(bitmap.Get(i), false, "pos=" << i); \ 
+                UNIT_ASSERT_EQUAL_C(bitmap.Get(i), false, "pos=" << i); \
             }                                                           \
         }                                                               \
-    } 
- 
+    }
+
 #define CHECK_BITMAP_WITH_TAIL(bitmap, bits)                                \
     {                                                                       \
         size_t cur = 0, end = sizeof(bits) / sizeof(size_t);                \
@@ -29,14 +29,14 @@
                     UNIT_ASSERT_EQUAL_C(bitmap.Get(i), true, "pos=" << i);  \
                     ++cur;                                                  \
                 } else {                                                    \
-                    UNIT_ASSERT_EQUAL_C(bitmap.Get(i), false, "pos=" << i); \ 
+                    UNIT_ASSERT_EQUAL_C(bitmap.Get(i), false, "pos=" << i); \
                 }                                                           \
             } else {                                                        \
                 UNIT_ASSERT_EQUAL_C(bitmap.Get(i), true, "pos=" << i);      \
             }                                                               \
         }                                                                   \
-    } 
- 
+    }
+
 Y_UNIT_TEST_SUITE(TBitMapTest) {
     Y_UNIT_TEST(TestBitMap) {
         TBitMap<101> bitmap;
@@ -45,47 +45,47 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
         UNIT_ASSERT_EQUAL(bitmap.Count(), 0);
         UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 101);
 
-        size_t initBits[] = {0, 50, 100, 45}; 
-        INIT_BITMAP(bitmap, initBits); 
+        size_t initBits[] = {0, 50, 100, 45};
+        INIT_BITMAP(bitmap, initBits);
         bitmap.Reset(45);
 
         UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 0);
-        size_t setBits[] = {0, 50, 100}; 
-        CHECK_BITMAP(bitmap, setBits); 
+        size_t setBits[] = {0, 50, 100};
+        CHECK_BITMAP(bitmap, setBits);
 
         for (size_t i = 0; i < bitmap.Size(); ++i) {
-            UNIT_ASSERT_EQUAL(bitmap.Get(i), bitmap.Test(i)); 
+            UNIT_ASSERT_EQUAL(bitmap.Get(i), bitmap.Test(i));
         }
 
-        UNIT_ASSERT_EQUAL(bitmap.Count(), 3); 
- 
-        bitmap.Reset(0); 
- 
-        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 50); 
- 
-        bitmap.Clear(); 
- 
-        UNIT_ASSERT_EQUAL(bitmap.Count(), 0); 
-        UNIT_ASSERT_EQUAL(bitmap.Empty(), true); 
-    } 
- 
+        UNIT_ASSERT_EQUAL(bitmap.Count(), 3);
+
+        bitmap.Reset(0);
+
+        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 50);
+
+        bitmap.Clear();
+
+        UNIT_ASSERT_EQUAL(bitmap.Count(), 0);
+        UNIT_ASSERT_EQUAL(bitmap.Empty(), true);
+    }
+
     Y_UNIT_TEST(TestDynBitMap) {
-        TDynBitMap bitmap; 
- 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 64); // Initial capacity 
-        UNIT_ASSERT_EQUAL(bitmap.Count(), 0); 
-        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 64); 
- 
-        size_t initBits[] = {0, 50, 100, 45}; 
-        INIT_BITMAP(bitmap, initBits); 
-        bitmap.Reset(45); 
- 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 128); 
- 
-        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 0); 
-        size_t setBits[] = {0, 50, 100}; 
-        CHECK_BITMAP(bitmap, setBits); 
- 
+        TDynBitMap bitmap;
+
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 64); // Initial capacity
+        UNIT_ASSERT_EQUAL(bitmap.Count(), 0);
+        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 64);
+
+        size_t initBits[] = {0, 50, 100, 45};
+        INIT_BITMAP(bitmap, initBits);
+        bitmap.Reset(45);
+
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 128);
+
+        UNIT_ASSERT_EQUAL(bitmap.FirstNonZeroBit(), 0);
+        size_t setBits[] = {0, 50, 100};
+        CHECK_BITMAP(bitmap, setBits);
+
         for (size_t i = 0; i < bitmap.Size(); ++i) {
             UNIT_ASSERT_EQUAL(bitmap.Get(i), bitmap.Test(i));
         }
@@ -99,171 +99,171 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
         bitmap.Clear();
 
         UNIT_ASSERT_EQUAL(bitmap.Count(), 0);
-        UNIT_ASSERT_EQUAL(bitmap.Empty(), true); 
+        UNIT_ASSERT_EQUAL(bitmap.Empty(), true);
     }
 
-    template <class TBitMapImpl> 
-    void TestAndImpl() { 
-        TBitMapImpl bitmap1; 
-        TBitMapImpl bitmap2; 
-
-        size_t initBits1[] = {10, 20, 50, 100}; 
-        size_t initBits2[] = {10, 11, 22, 50}; 
- 
-        INIT_BITMAP(bitmap1, initBits1); 
-        INIT_BITMAP(bitmap2, initBits2); 
- 
+    template <class TBitMapImpl>
+    void TestAndImpl() {
+        TBitMapImpl bitmap1;
+        TBitMapImpl bitmap2;
+
+        size_t initBits1[] = {10, 20, 50, 100};
+        size_t initBits2[] = {10, 11, 22, 50};
+
+        INIT_BITMAP(bitmap1, initBits1);
+        INIT_BITMAP(bitmap2, initBits2);
+
         bitmap1.And(bitmap2);
 
         UNIT_ASSERT_EQUAL(bitmap1.Count(), 2);
         UNIT_ASSERT_EQUAL(bitmap2.Count(), 4);
 
-        size_t resBits[] = {10, 50}; 
+        size_t resBits[] = {10, 50};
 
-        CHECK_BITMAP(bitmap1, resBits); 
-        CHECK_BITMAP(bitmap2, initBits2); 
+        CHECK_BITMAP(bitmap1, resBits);
+        CHECK_BITMAP(bitmap2, initBits2);
     }
 
     Y_UNIT_TEST(TestAndFixed) {
         TestAndImpl<TBitMap<101>>();
-    } 
+    }
 
     Y_UNIT_TEST(TestAndDyn) {
-        TestAndImpl<TDynBitMap>(); 
-    } 
-
-    template <class TBitMapImpl> 
-    void TestOrImpl() { 
-        TBitMapImpl bitmap1; 
-        TBitMapImpl bitmap2; 
- 
-        size_t initBits1[] = {0, 10, 11, 76}; 
-        size_t initBits2[] = {1, 11, 22, 50}; 
- 
-        INIT_BITMAP(bitmap1, initBits1); 
-        INIT_BITMAP(bitmap2, initBits2); 
- 
+        TestAndImpl<TDynBitMap>();
+    }
+
+    template <class TBitMapImpl>
+    void TestOrImpl() {
+        TBitMapImpl bitmap1;
+        TBitMapImpl bitmap2;
+
+        size_t initBits1[] = {0, 10, 11, 76};
+        size_t initBits2[] = {1, 11, 22, 50};
+
+        INIT_BITMAP(bitmap1, initBits1);
+        INIT_BITMAP(bitmap2, initBits2);
+
         bitmap1.Or(bitmap2);
 
         UNIT_ASSERT_EQUAL(bitmap1.Count(), 7);
         UNIT_ASSERT_EQUAL(bitmap2.Count(), 4);
 
-        size_t resBits[] = {0, 1, 10, 11, 22, 50, 76}; 
-
-        CHECK_BITMAP(bitmap1, resBits); 
-        CHECK_BITMAP(bitmap2, initBits2); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits1); 
- 
-        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 3), TBitMapImpl(bitmap1).Or(bitmap2, 3)); 
-        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 64), TBitMapImpl(bitmap1).Or(bitmap2, 64)); 
-        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 66), TBitMapImpl(bitmap1).Or(bitmap2, 66)); 
- 
-        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 3), TBitMapImpl(bitmap2).Or(bitmap1, 3)); 
-        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 64), TBitMapImpl(bitmap2).Or(bitmap1, 64)); 
-        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 66), TBitMapImpl(bitmap2).Or(bitmap1, 66)); 
-    } 
- 
+        size_t resBits[] = {0, 1, 10, 11, 22, 50, 76};
+
+        CHECK_BITMAP(bitmap1, resBits);
+        CHECK_BITMAP(bitmap2, initBits2);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits1);
+
+        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 3), TBitMapImpl(bitmap1).Or(bitmap2, 3));
+        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 64), TBitMapImpl(bitmap1).Or(bitmap2, 64));
+        UNIT_ASSERT_EQUAL(bitmap1 | (bitmap2 << 66), TBitMapImpl(bitmap1).Or(bitmap2, 66));
+
+        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 3), TBitMapImpl(bitmap2).Or(bitmap1, 3));
+        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 64), TBitMapImpl(bitmap2).Or(bitmap1, 64));
+        UNIT_ASSERT_EQUAL(bitmap2 | (bitmap1 << 66), TBitMapImpl(bitmap2).Or(bitmap1, 66));
+    }
+
     Y_UNIT_TEST(TestOrFixed) {
         TestOrImpl<TBitMap<145>>();
-    } 
- 
+    }
+
     Y_UNIT_TEST(TestOrDyn) {
-        TestOrImpl<TDynBitMap>(); 
-    } 
- 
+        TestOrImpl<TDynBitMap>();
+    }
+
     Y_UNIT_TEST(TestCopy) {
-        TBitMap<101> bitmap1; 
-        size_t initBits[] = {0, 10, 11, 76, 100}; 
- 
-        INIT_BITMAP(bitmap1, initBits); 
- 
-        TDynBitMap bitmap2(bitmap1); 
-        CHECK_BITMAP(bitmap2, initBits); 
- 
-        TBitMap<101> bitmap3(bitmap1); 
-        CHECK_BITMAP(bitmap3, initBits); 
- 
-        TBitMap<127> bitmap4(bitmap1); 
-        CHECK_BITMAP(bitmap4, initBits); 
- 
-        TDynBitMap bitmap5; 
-        bitmap5 = bitmap1; 
-        CHECK_BITMAP(bitmap5, initBits); 
- 
-        TBitMap<101> bitmap6; 
-        bitmap6 = bitmap1; 
-        CHECK_BITMAP(bitmap6, initBits); 
- 
-        TBitMap<127> bitmap7; 
-        bitmap7 = bitmap1; 
-        CHECK_BITMAP(bitmap7, initBits); 
- 
-        TBitMap<101> bitmap8; 
-        DoSwap(bitmap8, bitmap6); 
-        CHECK_BITMAP(bitmap8, initBits); 
-        UNIT_ASSERT_EQUAL(bitmap6.Empty(), true); 
- 
-        TDynBitMap bitmap9; 
-        DoSwap(bitmap9, bitmap5); 
-        CHECK_BITMAP(bitmap9, initBits); 
-        UNIT_ASSERT_EQUAL(bitmap5.Empty(), true); 
- 
-        // 64->32 
-        TBitMap<160, ui32> bitmap10(bitmap1); 
-        CHECK_BITMAP(bitmap10, initBits); 
- 
-        // 64->16 
-        TBitMap<160, ui16> bitmap11(bitmap1); 
-        CHECK_BITMAP(bitmap11, initBits); 
- 
-        // 64->8 
-        TBitMap<160, ui8> bitmap12(bitmap1); 
-        CHECK_BITMAP(bitmap12, initBits); 
- 
-        // 32->16 
-        TBitMap<160, ui16> bitmap13(bitmap10); 
-        CHECK_BITMAP(bitmap13, initBits); 
- 
-        // 32->64 
-        TBitMap<160, ui64> bitmap14(bitmap10); 
-        CHECK_BITMAP(bitmap14, initBits); 
- 
-        // 16->64 
-        TBitMap<160, ui64> bitmap15(bitmap11); 
-        CHECK_BITMAP(bitmap15, initBits); 
- 
-        // 8->64 
-        TBitMap<160, ui64> bitmap16(bitmap12); 
-        CHECK_BITMAP(bitmap16, initBits); 
-    } 
- 
+        TBitMap<101> bitmap1;
+        size_t initBits[] = {0, 10, 11, 76, 100};
+
+        INIT_BITMAP(bitmap1, initBits);
+
+        TDynBitMap bitmap2(bitmap1);
+        CHECK_BITMAP(bitmap2, initBits);
+
+        TBitMap<101> bitmap3(bitmap1);
+        CHECK_BITMAP(bitmap3, initBits);
+
+        TBitMap<127> bitmap4(bitmap1);
+        CHECK_BITMAP(bitmap4, initBits);
+
+        TDynBitMap bitmap5;
+        bitmap5 = bitmap1;
+        CHECK_BITMAP(bitmap5, initBits);
+
+        TBitMap<101> bitmap6;
+        bitmap6 = bitmap1;
+        CHECK_BITMAP(bitmap6, initBits);
+
+        TBitMap<127> bitmap7;
+        bitmap7 = bitmap1;
+        CHECK_BITMAP(bitmap7, initBits);
+
+        TBitMap<101> bitmap8;
+        DoSwap(bitmap8, bitmap6);
+        CHECK_BITMAP(bitmap8, initBits);
+        UNIT_ASSERT_EQUAL(bitmap6.Empty(), true);
+
+        TDynBitMap bitmap9;
+        DoSwap(bitmap9, bitmap5);
+        CHECK_BITMAP(bitmap9, initBits);
+        UNIT_ASSERT_EQUAL(bitmap5.Empty(), true);
+
+        // 64->32
+        TBitMap<160, ui32> bitmap10(bitmap1);
+        CHECK_BITMAP(bitmap10, initBits);
+
+        // 64->16
+        TBitMap<160, ui16> bitmap11(bitmap1);
+        CHECK_BITMAP(bitmap11, initBits);
+
+        // 64->8
+        TBitMap<160, ui8> bitmap12(bitmap1);
+        CHECK_BITMAP(bitmap12, initBits);
+
+        // 32->16
+        TBitMap<160, ui16> bitmap13(bitmap10);
+        CHECK_BITMAP(bitmap13, initBits);
+
+        // 32->64
+        TBitMap<160, ui64> bitmap14(bitmap10);
+        CHECK_BITMAP(bitmap14, initBits);
+
+        // 16->64
+        TBitMap<160, ui64> bitmap15(bitmap11);
+        CHECK_BITMAP(bitmap15, initBits);
+
+        // 8->64
+        TBitMap<160, ui64> bitmap16(bitmap12);
+        CHECK_BITMAP(bitmap16, initBits);
+    }
+
     Y_UNIT_TEST(TestOps) {
-        TBitMap<16> bitmap1; 
-        TBitMap<12> bitmap2; 
-        size_t initBits1[] = {0, 3, 7, 11}; 
-        size_t initBits2[] = {1, 3, 6, 7, 11}; 
-        INIT_BITMAP(bitmap1, initBits1); 
-        INIT_BITMAP(bitmap2, initBits2); 
- 
-        bitmap1.Or(3).And(bitmap2).Flip(); 
- 
-        size_t resBits[] = {0, 2, 4, 5, 6, 8, 9, 10, 12}; 
-        CHECK_BITMAP_WITH_TAIL(bitmap1, resBits); 
- 
-        TDynBitMap bitmap3; 
-        INIT_BITMAP(bitmap3, initBits1); 
- 
-        bitmap3.Or(3).And(bitmap2).Flip(); 
- 
-        CHECK_BITMAP_WITH_TAIL(bitmap3, resBits); 
- 
-        bitmap3.Clear(); 
-        INIT_BITMAP(bitmap3, initBits1); 
- 
+        TBitMap<16> bitmap1;
+        TBitMap<12> bitmap2;
+        size_t initBits1[] = {0, 3, 7, 11};
+        size_t initBits2[] = {1, 3, 6, 7, 11};
+        INIT_BITMAP(bitmap1, initBits1);
+        INIT_BITMAP(bitmap2, initBits2);
+
+        bitmap1.Or(3).And(bitmap2).Flip();
+
+        size_t resBits[] = {0, 2, 4, 5, 6, 8, 9, 10, 12};
+        CHECK_BITMAP_WITH_TAIL(bitmap1, resBits);
+
+        TDynBitMap bitmap3;
+        INIT_BITMAP(bitmap3, initBits1);
+
+        bitmap3.Or(3).And(bitmap2).Flip();
+
+        CHECK_BITMAP_WITH_TAIL(bitmap3, resBits);
+
+        bitmap3.Clear();
+        INIT_BITMAP(bitmap3, initBits1);
+
         TDynBitMap bitmap4 = ~((bitmap3 | 3) & bitmap2);
-        CHECK_BITMAP_WITH_TAIL(bitmap4, resBits); 
+        CHECK_BITMAP_WITH_TAIL(bitmap4, resBits);
 
         TBitMap<128, ui32> expmap;
         expmap.Set(47);
@@ -284,196 +284,196 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
         UNIT_ASSERT_EQUAL(tst2, (1 << 14));
         expmap.Export(33, tst3);
         UNIT_ASSERT_EQUAL(tst3, (1 << 14));
-    } 
- 
+    }
+
     Y_UNIT_TEST(TestShiftFixed) {
-        size_t initBits[] = {0, 3, 7, 11}; 
- 
-        TBitMap<128> bitmap1; 
- 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 62; 
-        size_t resBits1[] = {62, 65, 69, 73}; 
-        CHECK_BITMAP(bitmap1, resBits1); 
-        bitmap1 >>= 62; 
-        CHECK_BITMAP(bitmap1, initBits); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 120; 
-        size_t resBits2[] = {120, 123, 127}; 
-        CHECK_BITMAP(bitmap1, resBits2); 
-        bitmap1 >>= 120; 
-        size_t resBits3[] = {0, 3, 7}; 
-        CHECK_BITMAP(bitmap1, resBits3); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 128; 
-        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 120; 
-        bitmap1 >>= 128; 
-        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 140; 
-        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 62; 
-        bitmap1 >>= 140; 
-        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true); 
-    } 
- 
+        size_t initBits[] = {0, 3, 7, 11};
+
+        TBitMap<128> bitmap1;
+
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 62;
+        size_t resBits1[] = {62, 65, 69, 73};
+        CHECK_BITMAP(bitmap1, resBits1);
+        bitmap1 >>= 62;
+        CHECK_BITMAP(bitmap1, initBits);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 120;
+        size_t resBits2[] = {120, 123, 127};
+        CHECK_BITMAP(bitmap1, resBits2);
+        bitmap1 >>= 120;
+        size_t resBits3[] = {0, 3, 7};
+        CHECK_BITMAP(bitmap1, resBits3);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 128;
+        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 120;
+        bitmap1 >>= 128;
+        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 140;
+        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 62;
+        bitmap1 >>= 140;
+        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true);
+    }
+
     Y_UNIT_TEST(TestShiftDyn) {
-        size_t initBits[] = {0, 3, 7, 11}; 
- 
-        TDynBitMap bitmap1; 
- 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 62; 
-        size_t resBits1[] = {62, 65, 69, 73}; 
-        CHECK_BITMAP(bitmap1, resBits1); 
-        bitmap1 >>= 62; 
-        CHECK_BITMAP(bitmap1, initBits); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 120; 
-        size_t resBits2[] = {120, 123, 127, 131}; 
-        CHECK_BITMAP(bitmap1, resBits2); 
-        bitmap1 >>= 120; 
-        CHECK_BITMAP(bitmap1, initBits); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 128; 
-        size_t resBits3[] = {128, 131, 135, 139}; 
-        CHECK_BITMAP(bitmap1, resBits3); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 120; 
-        bitmap1 >>= 128; 
-        size_t resBits4[] = {3}; 
-        CHECK_BITMAP(bitmap1, resBits4); 
- 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits); 
-        bitmap1 <<= 62; 
-        bitmap1 >>= 140; 
-        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true); 
-    } 
- 
-    // Test that we don't expand bitmap in LShift when high-order bits are zero 
+        size_t initBits[] = {0, 3, 7, 11};
+
+        TDynBitMap bitmap1;
+
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 62;
+        size_t resBits1[] = {62, 65, 69, 73};
+        CHECK_BITMAP(bitmap1, resBits1);
+        bitmap1 >>= 62;
+        CHECK_BITMAP(bitmap1, initBits);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 120;
+        size_t resBits2[] = {120, 123, 127, 131};
+        CHECK_BITMAP(bitmap1, resBits2);
+        bitmap1 >>= 120;
+        CHECK_BITMAP(bitmap1, initBits);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 128;
+        size_t resBits3[] = {128, 131, 135, 139};
+        CHECK_BITMAP(bitmap1, resBits3);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 120;
+        bitmap1 >>= 128;
+        size_t resBits4[] = {3};
+        CHECK_BITMAP(bitmap1, resBits4);
+
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits);
+        bitmap1 <<= 62;
+        bitmap1 >>= 140;
+        UNIT_ASSERT_EQUAL(bitmap1.Empty(), true);
+    }
+
+    // Test that we don't expand bitmap in LShift when high-order bits are zero
     Y_UNIT_TEST(TestShiftExpansion) {
-        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(1).Size(), 64); 
-        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(65).Size(), 64); 
-        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(128).Size(), 64); 
- 
-        TDynBitMap bitmap; 
-        bitmap.Set(62).LShift(1); 
-        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(63)); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 64); 
- 
-        // Expand explicitly 
-        bitmap.Set(65); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 128); 
- 
-        bitmap.Clear().Set(0).LShift(1); 
-        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(1)); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 128); 
- 
-        bitmap.Clear().Set(63).LShift(1); 
-        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(64)); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 128); 
- 
-        bitmap.Clear().Set(63).LShift(64); 
-        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(127)); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 128); 
- 
-        bitmap.Clear().Set(62).LShift(129); 
-        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(191)); 
-        UNIT_ASSERT_EQUAL(bitmap.Size(), 256); 
-    } 
- 
+        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(1).Size(), 64);
+        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(65).Size(), 64);
+        UNIT_ASSERT_EQUAL(TDynBitMap().LShift(128).Size(), 64);
+
+        TDynBitMap bitmap;
+        bitmap.Set(62).LShift(1);
+        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(63));
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 64);
+
+        // Expand explicitly
+        bitmap.Set(65);
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 128);
+
+        bitmap.Clear().Set(0).LShift(1);
+        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(1));
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 128);
+
+        bitmap.Clear().Set(63).LShift(1);
+        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(64));
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 128);
+
+        bitmap.Clear().Set(63).LShift(64);
+        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(127));
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 128);
+
+        bitmap.Clear().Set(62).LShift(129);
+        UNIT_ASSERT_EQUAL(bitmap, TDynBitMap().Set(191));
+        UNIT_ASSERT_EQUAL(bitmap.Size(), 256);
+    }
+
     Y_UNIT_TEST(TestFixedSanity) {
-        // test extra-bit cleanup 
-        UNIT_ASSERT_EQUAL(TBitMap<33>().Set(0).LShift(34).RShift(34).Empty(), true); 
-        UNIT_ASSERT_EQUAL(TBitMap<88>().Set(0).Set(1).Set(2).LShift(90).RShift(90).Empty(), true); 
-        UNIT_ASSERT_EQUAL(TBitMap<88>().Flip().RShift(88).Empty(), true); 
-        UNIT_ASSERT_EQUAL(TBitMap<64>().Flip().LShift(2).RShift(2).Count(), 62); 
-        UNIT_ASSERT_EQUAL(TBitMap<67>().Flip().LShift(2).RShift(2).Count(), 65); 
-        UNIT_ASSERT_EQUAL(TBitMap<128>().Flip().LShift(2).RShift(2).Count(), 126); 
-        UNIT_ASSERT_EQUAL(TBitMap<130>().Flip().LShift(2).RShift(2).Count(), 128); 
-        UNIT_ASSERT_EQUAL(TBitMap<130>(TDynBitMap().Set(131)).Empty(), true); 
-        UNIT_ASSERT_EQUAL(TBitMap<33>().Or(TBitMap<40>().Set(39)).Empty(), true); 
-        UNIT_ASSERT_EQUAL(TBitMap<33>().Xor(TBitMap<40>().Set(39)).Empty(), true); 
-    } 
- 
+        // test extra-bit cleanup
+        UNIT_ASSERT_EQUAL(TBitMap<33>().Set(0).LShift(34).RShift(34).Empty(), true);
+        UNIT_ASSERT_EQUAL(TBitMap<88>().Set(0).Set(1).Set(2).LShift(90).RShift(90).Empty(), true);
+        UNIT_ASSERT_EQUAL(TBitMap<88>().Flip().RShift(88).Empty(), true);
+        UNIT_ASSERT_EQUAL(TBitMap<64>().Flip().LShift(2).RShift(2).Count(), 62);
+        UNIT_ASSERT_EQUAL(TBitMap<67>().Flip().LShift(2).RShift(2).Count(), 65);
+        UNIT_ASSERT_EQUAL(TBitMap<128>().Flip().LShift(2).RShift(2).Count(), 126);
+        UNIT_ASSERT_EQUAL(TBitMap<130>().Flip().LShift(2).RShift(2).Count(), 128);
+        UNIT_ASSERT_EQUAL(TBitMap<130>(TDynBitMap().Set(131)).Empty(), true);
+        UNIT_ASSERT_EQUAL(TBitMap<33>().Or(TBitMap<40>().Set(39)).Empty(), true);
+        UNIT_ASSERT_EQUAL(TBitMap<33>().Xor(TBitMap<40>().Set(39)).Empty(), true);
+    }
+
     Y_UNIT_TEST(TestIterate) {
-        TDynBitMap bitmap1; 
-        TDynBitMap bitmap2; 
- 
-        size_t initBits1[] = {0, 3, 7, 8, 11, 33, 34, 35, 36, 62, 63, 100, 127}; 
-        INIT_BITMAP(bitmap1, initBits1); 
-        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) { 
-            bitmap2.Set(i); 
-        } 
-        CHECK_BITMAP(bitmap2, initBits1); 
-        UNIT_ASSERT_EQUAL(bitmap1, bitmap2); 
- 
-        size_t initBits2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 33, 34, 35, 36, 62}; 
-        bitmap1.Clear(); 
-        bitmap2.Clear(); 
-        INIT_BITMAP(bitmap1, initBits2); 
-        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) { 
-            bitmap2.Set(i); 
-        } 
-        CHECK_BITMAP(bitmap2, initBits2); 
-        UNIT_ASSERT_EQUAL(bitmap1, bitmap2); 
- 
-        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(63), bitmap1.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(64), bitmap1.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(65), bitmap1.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(127), bitmap1.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(533), bitmap1.Size()); 
- 
-        TBitMap<128, ui8> bitmap3; 
-        bitmap1.Clear(); 
-        INIT_BITMAP(bitmap1, initBits1); 
-        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) { 
-            bitmap3.Set(i); 
-        } 
-        CHECK_BITMAP(bitmap3, initBits1); 
-        UNIT_ASSERT_EQUAL(bitmap3, bitmap1); 
- 
-        TBitMap<18> bitmap4; 
-        bitmap4.Set(15); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(0), 15); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(15), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(63), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(64), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(65), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(127), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(533), bitmap4.Size()); 
- 
-        bitmap4.Clear().Flip(); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(0), 1); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(15), 16); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(17), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(18), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(63), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(64), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(65), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(127), bitmap4.Size()); 
-        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(533), bitmap4.Size()); 
-    } 
+        TDynBitMap bitmap1;
+        TDynBitMap bitmap2;
+
+        size_t initBits1[] = {0, 3, 7, 8, 11, 33, 34, 35, 36, 62, 63, 100, 127};
+        INIT_BITMAP(bitmap1, initBits1);
+        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) {
+            bitmap2.Set(i);
+        }
+        CHECK_BITMAP(bitmap2, initBits1);
+        UNIT_ASSERT_EQUAL(bitmap1, bitmap2);
+
+        size_t initBits2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 33, 34, 35, 36, 62};
+        bitmap1.Clear();
+        bitmap2.Clear();
+        INIT_BITMAP(bitmap1, initBits2);
+        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) {
+            bitmap2.Set(i);
+        }
+        CHECK_BITMAP(bitmap2, initBits2);
+        UNIT_ASSERT_EQUAL(bitmap1, bitmap2);
+
+        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(63), bitmap1.Size());
+        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(64), bitmap1.Size());
+        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(65), bitmap1.Size());
+        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(127), bitmap1.Size());
+        UNIT_ASSERT_EQUAL(bitmap1.NextNonZeroBit(533), bitmap1.Size());
+
+        TBitMap<128, ui8> bitmap3;
+        bitmap1.Clear();
+        INIT_BITMAP(bitmap1, initBits1);
+        for (size_t i = bitmap1.FirstNonZeroBit(); i != bitmap1.Size(); i = bitmap1.NextNonZeroBit(i)) {
+            bitmap3.Set(i);
+        }
+        CHECK_BITMAP(bitmap3, initBits1);
+        UNIT_ASSERT_EQUAL(bitmap3, bitmap1);
+
+        TBitMap<18> bitmap4;
+        bitmap4.Set(15);
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(0), 15);
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(15), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(63), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(64), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(65), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(127), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(533), bitmap4.Size());
+
+        bitmap4.Clear().Flip();
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(0), 1);
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(15), 16);
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(17), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(18), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(63), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(64), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(65), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(127), bitmap4.Size());
+        UNIT_ASSERT_EQUAL(bitmap4.NextNonZeroBit(533), bitmap4.Size());
+    }
 
     Y_UNIT_TEST(TestHashFixed) {
         TBitMap<32, ui8> bitmap32;
@@ -550,27 +550,27 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
     }
 
     Y_UNIT_TEST(TestSetResetRange) {
-        // Single chunk 
+        // Single chunk
         using TBitMap1Chunk = TBitMap<64>;
-        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(10, 50), TBitMap1Chunk().Set(0, 10).Set(50, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(0, 10), TBitMap1Chunk().Set(10, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(50, 64), TBitMap1Chunk().Set(0, 50)); 
-        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(0, 10).Reset(50, 64), TBitMap1Chunk().Set(10, 50)); 
- 
-        // Two chunks 
+        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(10, 50), TBitMap1Chunk().Set(0, 10).Set(50, 64));
+        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(0, 10), TBitMap1Chunk().Set(10, 64));
+        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(50, 64), TBitMap1Chunk().Set(0, 50));
+        UNIT_ASSERT_EQUAL(TBitMap1Chunk().Flip().Reset(0, 10).Reset(50, 64), TBitMap1Chunk().Set(10, 50));
+
+        // Two chunks
         using TBitMap2Chunks = TBitMap<64, ui32>;
-        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(10, 50), TBitMap2Chunks().Set(0, 10).Set(50, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(0, 10), TBitMap2Chunks().Set(10, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(50, 64), TBitMap2Chunks().Set(0, 50)); 
-        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(0, 10).Reset(50, 64), TBitMap2Chunks().Set(10, 50)); 
- 
-        // Many chunks 
+        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(10, 50), TBitMap2Chunks().Set(0, 10).Set(50, 64));
+        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(0, 10), TBitMap2Chunks().Set(10, 64));
+        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(50, 64), TBitMap2Chunks().Set(0, 50));
+        UNIT_ASSERT_EQUAL(TBitMap2Chunks().Flip().Reset(0, 10).Reset(50, 64), TBitMap2Chunks().Set(10, 50));
+
+        // Many chunks
         using TBitMap4Chunks = TBitMap<64, ui16>;
-        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(10, 50), TBitMap4Chunks().Set(0, 10).Set(50, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(0, 10), TBitMap4Chunks().Set(10, 64)); 
-        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(50, 64), TBitMap4Chunks().Set(0, 50)); 
-        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(0, 10).Reset(50, 64), TBitMap4Chunks().Set(10, 50)); 
-    } 
+        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(10, 50), TBitMap4Chunks().Set(0, 10).Set(50, 64));
+        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(0, 10), TBitMap4Chunks().Set(10, 64));
+        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(50, 64), TBitMap4Chunks().Set(0, 50));
+        UNIT_ASSERT_EQUAL(TBitMap4Chunks().Flip().Reset(0, 10).Reset(50, 64), TBitMap4Chunks().Set(10, 50));
+    }
 
     Y_UNIT_TEST(TestSetRangeDyn) {
         for (size_t start = 0; start < 192; ++start) {
@@ -594,4 +594,4 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
             UNIT_ASSERT_VALUES_EQUAL(bm.Get(k), k >= 1 && k < 2048 ? 0 : 1);
         }
     }
-} 
+}