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

25 files changed, 1027 insertions, 1027 deletions

diff --git a/util/generic/algorithm.h b/util/generic/algorithm.h
index badfb88993..821ba709d0 100644
--- a/util/generic/algorithm.h
+++ b/util/generic/algorithm.h
@@ -73,16 +73,16 @@ static inline void StableSort(T f, T l, C c) {
     std::stable_sort(f, l, c);
 }
 
-template <class TContainer>
-static inline void StableSort(TContainer& container) {
-    StableSort(container.begin(), container.end());
-}
-
-template <class TContainer, typename TCompare>
-static inline void StableSort(TContainer& container, TCompare compare) {
-    StableSort(container.begin(), container.end(), compare);
-}
-
+template <class TContainer> 
+static inline void StableSort(TContainer& container) { 
+    StableSort(container.begin(), container.end()); 
+} 
+ 
+template <class TContainer, typename TCompare> 
+static inline void StableSort(TContainer& container, TCompare compare) { 
+    StableSort(container.begin(), container.end(), compare); 
+} 
+ 
 template <class TIterator, typename TGetKey>
 static inline void StableSortBy(TIterator begin, TIterator end, const TGetKey& getKey) {
     StableSort(begin, end, [&](auto&& left, auto&& right) { return getKey(left) < getKey(right); });
@@ -278,11 +278,11 @@ static inline I LowerBound(I f, I l, const T& v, C c) {
     return std::lower_bound(f, l, v, c);
 }
 
-template <class I, class T, class TGetKey>
-static inline I LowerBoundBy(I f, I l, const T& v, const TGetKey& getKey) {
-    return std::lower_bound(f, l, v, [&](auto&& left, auto&& right) { return getKey(left) < right; });
-}
-
+template <class I, class T, class TGetKey> 
+static inline I LowerBoundBy(I f, I l, const T& v, const TGetKey& getKey) { 
+    return std::lower_bound(f, l, v, [&](auto&& left, auto&& right) { return getKey(left) < right; }); 
+} 
+ 
 template <class I, class T>
 static inline I UpperBound(I f, I l, const T& v) {
     return std::upper_bound(f, l, v);
@@ -293,11 +293,11 @@ static inline I UpperBound(I f, I l, const T& v, C c) {
     return std::upper_bound(f, l, v, c);
 }
 
-template <class I, class T, class TGetKey>
-static inline I UpperBoundBy(I f, I l, const T& v, const TGetKey& getKey) {
-    return std::upper_bound(f, l, v, [&](auto&& left, auto&& right) { return left < getKey(right); });
-}
-
+template <class I, class T, class TGetKey> 
+static inline I UpperBoundBy(I f, I l, const T& v, const TGetKey& getKey) { 
+    return std::upper_bound(f, l, v, [&](auto&& left, auto&& right) { return left < getKey(right); }); 
+} 
+ 
 template <class T>
 static inline T Unique(T f, T l) {
     return std::unique(f, l);
diff --git a/util/generic/algorithm_ut.cpp b/util/generic/algorithm_ut.cpp
index 8d732fcc0c..58a3b56956 100644
--- a/util/generic/algorithm_ut.cpp
+++ b/util/generic/algorithm_ut.cpp
@@ -446,61 +446,61 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
     }
 
     Y_UNIT_TEST(SortTestTwoIterators) {
-        TVector<int> collection = {10, 2, 7};
-        Sort(collection.begin(), collection.end());
-        TVector<int> expected = {2, 7, 10};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        Sort(collection.begin(), collection.end()); 
+        TVector<int> expected = {2, 7, 10}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(SortTestTwoIteratorsAndComparator) {
-        TVector<int> collection = {10, 2, 7};
-        Sort(collection.begin(), collection.end(), [](int l, int r) { return l > r; });
-        TVector<int> expected = {10, 7, 2};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        Sort(collection.begin(), collection.end(), [](int l, int r) { return l > r; }); 
+        TVector<int> expected = {10, 7, 2}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(SortTestContainer) {
-        TVector<int> collection = {10, 2, 7};
-        Sort(collection);
-        TVector<int> expected = {2, 7, 10};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        Sort(collection); 
+        TVector<int> expected = {2, 7, 10}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(SortTestContainerAndComparator) {
-        TVector<int> collection = {10, 2, 7};
-        Sort(collection, [](int l, int r) { return l > r; });
-        TVector<int> expected = {10, 7, 2};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        Sort(collection, [](int l, int r) { return l > r; }); 
+        TVector<int> expected = {10, 7, 2}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(StableSortTestTwoIterators) {
-        TVector<int> collection = {10, 2, 7};
-        StableSort(collection.begin(), collection.end());
-        TVector<int> expected = {2, 7, 10};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        StableSort(collection.begin(), collection.end()); 
+        TVector<int> expected = {2, 7, 10}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(StableSortTestTwoIteratorsAndComparator) {
-        TVector<int> collection = {404, 101, 106, 203, 102, 205, 401};
-        StableSort(collection.begin(), collection.end(), [](int l, int r) { return (l / 100) < (r / 100); });
-        TVector<int> expected = {101, 106, 102, 203, 205, 404, 401};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {404, 101, 106, 203, 102, 205, 401}; 
+        StableSort(collection.begin(), collection.end(), [](int l, int r) { return (l / 100) < (r / 100); }); 
+        TVector<int> expected = {101, 106, 102, 203, 205, 404, 401}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(StableSortTestContainer) {
-        TVector<int> collection = {10, 2, 7};
-        StableSort(collection);
-        TVector<int> expected = {2, 7, 10};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {10, 2, 7}; 
+        StableSort(collection); 
+        TVector<int> expected = {2, 7, 10}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(StableSortTestContainerAndComparator) {
-        TVector<int> collection = {404, 101, 106, 203, 102, 205, 401};
-        StableSort(collection, [](int l, int r) { return (l / 100) < (r / 100); });
-        TVector<int> expected = {101, 106, 102, 203, 205, 404, 401};
-        UNIT_ASSERT_VALUES_EQUAL(collection, expected);
-    }
-
+        TVector<int> collection = {404, 101, 106, 203, 102, 205, 401}; 
+        StableSort(collection, [](int l, int r) { return (l / 100) < (r / 100); }); 
+        TVector<int> expected = {101, 106, 102, 203, 205, 404, 401}; 
+        UNIT_ASSERT_VALUES_EQUAL(collection, expected); 
+    } 
+ 
     Y_UNIT_TEST(SortByTest) {
         TVector<int> collection = {10, 2, 7};
         SortBy(collection, [](int x) { return -x; });
@@ -796,45 +796,45 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         auto i = FindIf(range, [](auto) { return false; });
         Y_UNUSED(i);
     }
-
+ 
     Y_UNIT_TEST(TestLowerBoundBy) {
         using TIntPairs = TVector<std::pair<i32, i32>>;
-
-        auto data = TIntPairs{{1, 5}, {3, 2}, {3, 4}, {8, 0}, {5, 4}};
-        auto getKey = [](const auto& x) { return x.second; };
-
-        StableSortBy(data, getKey);
-
-        auto it = LowerBoundBy(data.begin(), data.end(), 4, getKey);
-        UNIT_ASSERT(it != data.end());
-        UNIT_ASSERT_EQUAL(it->second, 4);
-        UNIT_ASSERT_EQUAL(it->first, 3);
-
-        UNIT_ASSERT(it > data.begin());
-        UNIT_ASSERT_EQUAL((it - 1)->second, 2);
-
-        UNIT_ASSERT((it + 1) < data.end());
-        UNIT_ASSERT_EQUAL((it + 1)->second, 4);
-    }
-
+ 
+        auto data = TIntPairs{{1, 5}, {3, 2}, {3, 4}, {8, 0}, {5, 4}}; 
+        auto getKey = [](const auto& x) { return x.second; }; 
+ 
+        StableSortBy(data, getKey); 
+ 
+        auto it = LowerBoundBy(data.begin(), data.end(), 4, getKey); 
+        UNIT_ASSERT(it != data.end()); 
+        UNIT_ASSERT_EQUAL(it->second, 4); 
+        UNIT_ASSERT_EQUAL(it->first, 3); 
+ 
+        UNIT_ASSERT(it > data.begin()); 
+        UNIT_ASSERT_EQUAL((it - 1)->second, 2); 
+ 
+        UNIT_ASSERT((it + 1) < data.end()); 
+        UNIT_ASSERT_EQUAL((it + 1)->second, 4); 
+    } 
+ 
     Y_UNIT_TEST(TestUpperBoundBy) {
         using TIntPairs = TVector<std::pair<i32, i32>>;
-
-        auto data = TIntPairs{{1, 5}, {3, 2}, {3, 4}, {8, 0}, {5, 4}};
-        auto getKey = [](const auto& x) { return x.second; };
-
-        StableSortBy(data, getKey);
-
-        auto it = UpperBoundBy(data.begin(), data.end(), 4, getKey);
-        UNIT_ASSERT(it != data.end());
-        UNIT_ASSERT_EQUAL(it->second, 5);
-        UNIT_ASSERT_EQUAL(it->first, 1);
-
-        UNIT_ASSERT(it > data.begin());
-        UNIT_ASSERT_EQUAL((it - 1)->second, 4);
-
-        UNIT_ASSERT((it + 1) == data.end());
-    }
+ 
+        auto data = TIntPairs{{1, 5}, {3, 2}, {3, 4}, {8, 0}, {5, 4}}; 
+        auto getKey = [](const auto& x) { return x.second; }; 
+ 
+        StableSortBy(data, getKey); 
+ 
+        auto it = UpperBoundBy(data.begin(), data.end(), 4, getKey); 
+        UNIT_ASSERT(it != data.end()); 
+        UNIT_ASSERT_EQUAL(it->second, 5); 
+        UNIT_ASSERT_EQUAL(it->first, 1); 
+ 
+        UNIT_ASSERT(it > data.begin()); 
+        UNIT_ASSERT_EQUAL((it - 1)->second, 4); 
+ 
+        UNIT_ASSERT((it + 1) == data.end()); 
+    } 
 
     Y_UNIT_TEST(TestFindInContainer) {
         std::vector<int> v = {1, 2, 1000, 15, 100};
diff --git a/util/generic/benchmark/fastclp2/metrics/main.py b/util/generic/benchmark/fastclp2/metrics/main.py
index 5573c6a5d7..9e260653e2 100644
--- a/util/generic/benchmark/fastclp2/metrics/main.py
+++ b/util/generic/benchmark/fastclp2/metrics/main.py
@@ -2,4 +2,4 @@ import yatest.common as yc
 
 
 def test_export_metrics(metrics):
-    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/fastclp2/fastclp2', threads=8))
+    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/fastclp2/fastclp2', threads=8)) 
diff --git a/util/generic/benchmark/log2/metrics/main.py b/util/generic/benchmark/log2/metrics/main.py
index 26f6b57812..3ce98f91d0 100644
--- a/util/generic/benchmark/log2/metrics/main.py
+++ b/util/generic/benchmark/log2/metrics/main.py
@@ -2,4 +2,4 @@ import yatest.common as yc
 
 
 def test_export_metrics(metrics):
-    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/log2/log2', threads=8))
+    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/log2/log2', threads=8)) 
diff --git a/util/generic/benchmark/rotate_bits/metrics/main.py b/util/generic/benchmark/rotate_bits/metrics/main.py
index b30555775f..599825423a 100644
--- a/util/generic/benchmark/rotate_bits/metrics/main.py
+++ b/util/generic/benchmark/rotate_bits/metrics/main.py
@@ -2,4 +2,4 @@ import yatest.common as yc
 
 
 def test_export_metrics(metrics):
-    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/rotate_bits/rotate_bits', threads=8))
+    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/rotate_bits/rotate_bits', threads=8)) 
diff --git a/util/generic/benchmark/string/benchmarks.h b/util/generic/benchmark/string/benchmarks.h
index e347d7ff47..8bd6ec9e7f 100644
--- a/util/generic/benchmark/string/benchmarks.h
+++ b/util/generic/benchmark/string/benchmarks.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 // Define BENCHMARK_PREFIX and BENCHMARKED_CLASS before including this file.
 
 #include <util/generic/xrange.h>
diff --git a/util/generic/benchmark/vector_count_ctor/metrics/main.py b/util/generic/benchmark/vector_count_ctor/metrics/main.py
index 835b44fe5f..d84e229110 100644
--- a/util/generic/benchmark/vector_count_ctor/metrics/main.py
+++ b/util/generic/benchmark/vector_count_ctor/metrics/main.py
@@ -2,4 +2,4 @@ import yatest.common as yc
 
 
 def test_export_metrics(metrics):
-    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/vector_count_ctor/vector_count_ctor', threads=8))
+    metrics.set_benchmark(yc.execute_benchmark('util/generic/benchmark/vector_count_ctor/vector_count_ctor', threads=8)) 
diff --git a/util/generic/flags.h b/util/generic/flags.h
index a1f5921d42..5898195d7c 100644
--- a/util/generic/flags.h
+++ b/util/generic/flags.h
@@ -59,10 +59,10 @@ public:
         return Value_;
     }
 
-    constexpr static TFlags FromBaseType(TInt value) {
+    constexpr static TFlags FromBaseType(TInt value) { 
         return TFlags(TFlag(value));
-    }
-
+    } 
+ 
     constexpr friend TFlags operator|(TFlags l, TFlags r) {
         return TFlags(TFlag(l.Value_ | r.Value_));
     }
diff --git a/util/generic/flags_ut.cpp b/util/generic/flags_ut.cpp
index 5377c6a058..ff11d07f31 100644
--- a/util/generic/flags_ut.cpp
+++ b/util/generic/flags_ut.cpp
@@ -100,18 +100,18 @@ Y_UNIT_TEST_SUITE(TFlagsTest) {
         UNIT_ASSERT_VALUES_EQUAL(hash[value0], 0);
         UNIT_ASSERT_VALUES_EQUAL(hash[value1], 1);
     }
-
+ 
     Y_UNIT_TEST(TestBaseType) {
-        ui16 goodValue = 7;
-        auto goodFlags = ETest1::FromBaseType(goodValue);
+        ui16 goodValue = 7; 
+        auto goodFlags = ETest1::FromBaseType(goodValue); 
         UNIT_ASSERT(goodFlags& ETestFlag1::Test1);
         UNIT_ASSERT(goodFlags& ETestFlag1::Test2);
         UNIT_ASSERT(goodFlags& ETestFlag1::Test4);
-        UNIT_ASSERT_VALUES_EQUAL(goodValue, goodFlags.ToBaseType());
-
-        // Passed value is not checked, but preserved as is
-        ui16 badValue = 1024;
-        auto badFlags = ETest1::FromBaseType(badValue);
-        UNIT_ASSERT_VALUES_EQUAL(badValue, badFlags.ToBaseType());
-    }
+        UNIT_ASSERT_VALUES_EQUAL(goodValue, goodFlags.ToBaseType()); 
+ 
+        // Passed value is not checked, but preserved as is 
+        ui16 badValue = 1024; 
+        auto badFlags = ETest1::FromBaseType(badValue); 
+        UNIT_ASSERT_VALUES_EQUAL(badValue, badFlags.ToBaseType()); 
+    } 
 }
diff --git a/util/generic/hash_ut.pyx b/util/generic/hash_ut.pyx
index ecf6dac2e6..172b5d1252 100644
--- a/util/generic/hash_ut.pyx
+++ b/util/generic/hash_ut.pyx
@@ -11,9 +11,9 @@ from cython.operator cimport dereference as deref
 
 
 def _check_convert(THashMap[TString, int] x):
-    return x
-
-
+    return x 
+ 
+ 
 class TestHash(unittest.TestCase):
 
     def test_constructors_and_assignments(self):
@@ -75,10 +75,10 @@ class TestHash(unittest.TestCase):
         self.assertTrue(it != tmp.end())
         self.assertEqual(deref(it).second, 1)
 
-    def test_convert(self):
-        src = {'foo': 1, 'bar': 42}
-        self.assertEqual(_check_convert(src), src)
-
-        bad_src = {'foo': 1, 'bar': 'baz'}
-        with self.assertRaises(TypeError):
-            _check_convert(bad_src)
+    def test_convert(self): 
+        src = {'foo': 1, 'bar': 42} 
+        self.assertEqual(_check_convert(src), src) 
+ 
+        bad_src = {'foo': 1, 'bar': 'baz'} 
+        with self.assertRaises(TypeError): 
+            _check_convert(bad_src) 
diff --git a/util/generic/iterator.h b/util/generic/iterator.h
index 19e9d20976..b34be9c28c 100644
--- a/util/generic/iterator.h
+++ b/util/generic/iterator.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <iterator>
-#include <utility>
-
+#include <utility> 
+ 
 namespace NStlIterator {
     template <class T>
     class TProxy {
@@ -68,31 +68,31 @@ class TInputRangeAdaptor {
 public: // TODO: private
     class TIterator {
     public:
-        static constexpr bool IsNoexceptNext = noexcept(std::declval<TSlave>().Next());
-
+        static constexpr bool IsNoexceptNext = noexcept(std::declval<TSlave>().Next()); 
+ 
         using difference_type = std::ptrdiff_t;
         using pointer = decltype(std::declval<TSlave>().Next());
         using reference = decltype(*std::declval<TSlave>().Next());
         using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
         using iterator_category = std::input_iterator_tag;
 
-        inline TIterator() noexcept
+        inline TIterator() noexcept 
             : Slave_(nullptr)
             , Cur_()
         {
         }
 
-        inline TIterator(TSlave* slave) noexcept(IsNoexceptNext)
+        inline TIterator(TSlave* slave) noexcept(IsNoexceptNext) 
             : Slave_(slave)
             , Cur_(Slave_->Next())
         {
         }
 
-        inline bool operator==(const TIterator& it) const noexcept {
+        inline bool operator==(const TIterator& it) const noexcept { 
             return Cur_ == it.Cur_;
         }
 
-        inline bool operator!=(const TIterator& it) const noexcept {
+        inline bool operator!=(const TIterator& it) const noexcept { 
             return !(*this == it);
         }
 
@@ -104,7 +104,7 @@ public: // TODO: private
             return *Cur_;
         }
 
-        inline TIterator& operator++() noexcept(IsNoexceptNext) {
+        inline TIterator& operator++() noexcept(IsNoexceptNext) { 
             Cur_ = Slave_->Next();
 
             return *this;
diff --git a/util/generic/list_ut.pyx b/util/generic/list_ut.pyx
index 129e5bc9b6..9ae44c5ffd 100644
--- a/util/generic/list_ut.pyx
+++ b/util/generic/list_ut.pyx
@@ -1,158 +1,158 @@
 from util.generic.list cimport TList
-
-import unittest
+ 
+import unittest 
 from cython.operator cimport preincrement
-
-
+ 
+ 
 class TestList(unittest.TestCase):
-
-    def test_ctor1(self):
+ 
+    def test_ctor1(self): 
         cdef TList[int] tmp = TList[int]()
-        self.assertEqual(tmp.size(), 0)
-
-    def test_ctor2(self):
+        self.assertEqual(tmp.size(), 0) 
+ 
+    def test_ctor2(self): 
         cdef TList[int] tmp = TList[int](10, 42)
-        self.assertEqual(tmp.size(), 10)
+        self.assertEqual(tmp.size(), 10) 
         self.assertEqual(tmp.front(), 42)
-
-    def test_ctor3(self):
+ 
+    def test_ctor3(self): 
         cdef TList[int] tmp = TList[int](10, 42)
         cdef TList[int] tmp2 = TList[int](tmp)
-        self.assertEqual(tmp2.size(), 10)
+        self.assertEqual(tmp2.size(), 10) 
         self.assertEqual(tmp2.front(), 42)
-
-    def test_operator_assign(self):
+ 
+    def test_operator_assign(self): 
         cdef TList[int] tmp2
-        tmp2.push_back(1)
-        tmp2.push_back(2)
-
+        tmp2.push_back(1) 
+        tmp2.push_back(2) 
+ 
         cdef TList[int] tmp3
-        tmp3.push_back(1)
-        tmp3.push_back(3)
-
-        tmp3 = tmp2
-
-    def test_compare(self):
+        tmp3.push_back(1) 
+        tmp3.push_back(3) 
+ 
+        tmp3 = tmp2 
+ 
+    def test_compare(self): 
         cdef TList[int] tmp1
-        tmp1.push_back(1)
-        tmp1.push_back(2)
-
+        tmp1.push_back(1) 
+        tmp1.push_back(2) 
+ 
         cdef TList[int] tmp2
-        tmp2.push_back(1)
-        tmp2.push_back(2)
-
+        tmp2.push_back(1) 
+        tmp2.push_back(2) 
+ 
         cdef TList[int] tmp3
-        tmp3.push_back(1)
-        tmp3.push_back(3)
-
-        self.assertTrue(tmp1 == tmp2)
-        self.assertTrue(tmp1 != tmp3)
-
-        self.assertTrue(tmp1 < tmp3)
-        self.assertTrue(tmp1 <= tmp3)
-
-        self.assertTrue(tmp3 > tmp1)
-        self.assertTrue(tmp3 >= tmp1)
-
-    def test_push_pop_back(self):
+        tmp3.push_back(1) 
+        tmp3.push_back(3) 
+ 
+        self.assertTrue(tmp1 == tmp2) 
+        self.assertTrue(tmp1 != tmp3) 
+ 
+        self.assertTrue(tmp1 < tmp3) 
+        self.assertTrue(tmp1 <= tmp3) 
+ 
+        self.assertTrue(tmp3 > tmp1) 
+        self.assertTrue(tmp3 >= tmp1) 
+ 
+    def test_push_pop_back(self): 
         cdef TList[int] tmp
-        self.assertEqual(tmp.size(), 0)
-
-        tmp.push_back(42)
-        self.assertEqual(tmp.size(), 1)
-        self.assertEqual(tmp.back(), 42)
-
-        tmp.push_back(77)
-        self.assertEqual(tmp.size(), 2)
-        self.assertEqual(tmp.back(), 77)
-
-        tmp.pop_back()
-        self.assertEqual(tmp.size(), 1)
-        self.assertEqual(tmp.back(), 42)
-
-        tmp.pop_back()
-        self.assertEqual(tmp.size(), 0)
-
-    def test_front(self):
+        self.assertEqual(tmp.size(), 0) 
+ 
+        tmp.push_back(42) 
+        self.assertEqual(tmp.size(), 1) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+        tmp.push_back(77) 
+        self.assertEqual(tmp.size(), 2) 
+        self.assertEqual(tmp.back(), 77) 
+ 
+        tmp.pop_back() 
+        self.assertEqual(tmp.size(), 1) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+        tmp.pop_back() 
+        self.assertEqual(tmp.size(), 0) 
+ 
+    def test_front(self): 
         cdef TList[int] tmp
-        tmp.push_back(42)
-        self.assertEqual(tmp.front(), 42)
-
-    def test_empty(self):
+        tmp.push_back(42) 
+        self.assertEqual(tmp.front(), 42) 
+ 
+    def test_empty(self): 
         cdef TList[int] tmp
-        self.assertTrue(tmp.empty())
-        tmp.push_back(42)
-        self.assertFalse(tmp.empty())
-
-    def test_max_size(self):
+        self.assertTrue(tmp.empty()) 
+        tmp.push_back(42) 
+        self.assertFalse(tmp.empty()) 
+ 
+    def test_max_size(self): 
         cdef TList[int] tmp
-        self.assertTrue(tmp.max_size() > 0)
-
+        self.assertTrue(tmp.max_size() > 0) 
+ 
     def test_resize(self):
         cdef TList[int] tmp
-
-        tmp.resize(100, 42)
-        self.assertEqual(tmp.size(), 100)
-        self.assertEqual(tmp.front(), 42)
-        self.assertEqual(tmp.back(), 42)
-
-    def test_iter(self):
+ 
+        tmp.resize(100, 42) 
+        self.assertEqual(tmp.size(), 100) 
+        self.assertEqual(tmp.front(), 42) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+    def test_iter(self): 
         cdef TList[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(20)
-        tmp.push_back(300)
-
-        self.assertEqual([i for i in tmp], [1, 20, 300])
-
-    def test_iterator(self):
+        tmp.push_back(1) 
+        tmp.push_back(20) 
+        tmp.push_back(300) 
+ 
+        self.assertEqual([i for i in tmp], [1, 20, 300]) 
+ 
+    def test_iterator(self): 
         cdef TList[int] tmp
-
-        self.assertTrue(tmp.begin() == tmp.end())
-        self.assertTrue(tmp.rbegin() == tmp.rend())
-        self.assertTrue(tmp.const_begin() == tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() == tmp.const_rend())
-
-        tmp.push_back(1)
-
-        self.assertTrue(tmp.begin() != tmp.end())
-        self.assertTrue(tmp.rbegin() != tmp.rend())
-        self.assertTrue(tmp.const_begin() != tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() != tmp.const_rend())
-
+ 
+        self.assertTrue(tmp.begin() == tmp.end()) 
+        self.assertTrue(tmp.rbegin() == tmp.rend()) 
+        self.assertTrue(tmp.const_begin() == tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() == tmp.const_rend()) 
+ 
+        tmp.push_back(1) 
+ 
+        self.assertTrue(tmp.begin() != tmp.end()) 
+        self.assertTrue(tmp.rbegin() != tmp.rend()) 
+        self.assertTrue(tmp.const_begin() != tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() != tmp.const_rend()) 
+ 
         self.assertTrue(preincrement(tmp.begin()) == tmp.end())
         self.assertTrue(preincrement(tmp.rbegin()) == tmp.rend())
         self.assertTrue(preincrement(tmp.const_begin()) == tmp.const_end())
         self.assertTrue(preincrement(tmp.const_rbegin()) == tmp.const_rend())
-
-    def test_assign(self):
+ 
+    def test_assign(self): 
         cdef TList[int] tmp
-
-        tmp.assign(10, 42)
-        self.assertEqual(tmp.size(), 10)
-        self.assertEqual(tmp.front(), 42)
-        self.assertEqual(tmp.back(), 42)
-
-    def test_insert(self):
+ 
+        tmp.assign(10, 42) 
+        self.assertEqual(tmp.size(), 10) 
+        self.assertEqual(tmp.front(), 42) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+    def test_insert(self): 
         cdef TList[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(2)
-        tmp.push_back(3)
-
-        tmp.insert(tmp.begin(), 8)
-        self.assertEqual([i for i in tmp], [8, 1, 2, 3])
-
-        tmp.insert(tmp.begin(), 2, 6)
-        self.assertEqual([i for i in tmp], [6, 6, 8, 1, 2, 3])
-
-    def test_erase(self):
+        tmp.push_back(1) 
+        tmp.push_back(2) 
+        tmp.push_back(3) 
+ 
+        tmp.insert(tmp.begin(), 8) 
+        self.assertEqual([i for i in tmp], [8, 1, 2, 3]) 
+ 
+        tmp.insert(tmp.begin(), 2, 6) 
+        self.assertEqual([i for i in tmp], [6, 6, 8, 1, 2, 3]) 
+ 
+    def test_erase(self): 
         cdef TList[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(2)
-        tmp.push_back(3)
-        tmp.push_back(4)
-
+        tmp.push_back(1) 
+        tmp.push_back(2) 
+        tmp.push_back(3) 
+        tmp.push_back(4) 
+ 
         tmp.erase(preincrement(tmp.begin()))
-        self.assertEqual([i for i in tmp], [1, 3, 4])
-
+        self.assertEqual([i for i in tmp], [1, 3, 4]) 
+ 
         tmp.erase(tmp.begin(), preincrement(preincrement(tmp.begin())))
-        self.assertEqual([i for i in tmp], [4])
+        self.assertEqual([i for i in tmp], [4]) 
diff --git a/util/generic/maybe.pxd b/util/generic/maybe.pxd
index 15161dd204..736f44c5e6 100644
--- a/util/generic/maybe.pxd
+++ b/util/generic/maybe.pxd
@@ -1,35 +1,35 @@
-cdef extern from "<util/generic/maybe.h>" nogil:
-    cdef cppclass TNothing:
-        pass
-
-    cdef TNothing Nothing()
-
-    cdef cppclass TMaybe[T]:
-        TMaybe(...) except +
-
-        TMaybe& operator=(...) except +
-
-        void ConstructInPlace(...) except +
-        void Clear() except +
-
-        bint Defined()
-        bint Empty()
-
-        void CheckDefined() except +
-
-        T* Get() except +
-        T& GetRef() except +
-
-        T GetOrElse(T&) except +
-        TMaybe OrElse(TMaybe&) except +
-
-        TMaybe[U] Cast[U]() except +
-
-        void Swap(TMaybe& other) except +
-
-        bint operator ==[U](U&) except +
-        bint operator !=[U](U&) except +
-        bint operator <[U](U&) except +
-        bint operator >[U](U&) except +
-        bint operator <=[U](U&) except +
-        bint operator >=[U](U&) except +
+cdef extern from "<util/generic/maybe.h>" nogil: 
+    cdef cppclass TNothing: 
+        pass 
+ 
+    cdef TNothing Nothing() 
+ 
+    cdef cppclass TMaybe[T]: 
+        TMaybe(...) except + 
+ 
+        TMaybe& operator=(...) except + 
+ 
+        void ConstructInPlace(...) except + 
+        void Clear() except + 
+ 
+        bint Defined() 
+        bint Empty() 
+ 
+        void CheckDefined() except + 
+ 
+        T* Get() except + 
+        T& GetRef() except + 
+ 
+        T GetOrElse(T&) except + 
+        TMaybe OrElse(TMaybe&) except + 
+ 
+        TMaybe[U] Cast[U]() except + 
+ 
+        void Swap(TMaybe& other) except + 
+ 
+        bint operator ==[U](U&) except + 
+        bint operator !=[U](U&) except + 
+        bint operator <[U](U&) except + 
+        bint operator >[U](U&) except + 
+        bint operator <=[U](U&) except + 
+        bint operator >=[U](U&) except + 
diff --git a/util/generic/maybe_ut.pyx b/util/generic/maybe_ut.pyx
index 2de185c807..c983f11053 100644
--- a/util/generic/maybe_ut.pyx
+++ b/util/generic/maybe_ut.pyx
@@ -1,185 +1,185 @@
-from util.generic.maybe cimport TMaybe, Nothing
-
-import pytest
-import unittest
-
-
-def _check_from_py(TMaybe[int] x):
-    return x.Defined()
-
-
-def _check_to_py_value():
-    cdef TMaybe[int] tmp = TMaybe[int](42)
-    return tmp
-
-
-def _check_to_py_nothing():
-    cdef TMaybe[int] tmp = Nothing()
-    return tmp
-
-
-class TestMaybe(unittest.TestCase):
-
-    def test_ctor1(self):
-        cdef TMaybe[int] tmp = TMaybe[int]()
-        self.assertFalse(tmp.Defined())
-
-    def test_ctor2(self):
-        cdef TMaybe[int] tmp = TMaybe[int](42)
-        self.assertTrue(tmp.Defined())
-        self.assertEquals(tmp.GetRef(), 42)
-
-    def test_ctor3(self):
-        cdef TMaybe[int] tmp = Nothing()
-        self.assertFalse(tmp.Defined())
-
-    def test_operator_assign(self):
-        cdef TMaybe[int] tmp
-        tmp = 42
-        self.assertTrue(tmp.Defined())
-        self.assertEquals(tmp.GetRef(), 42)
-
-    def test_compare(self):
-        cdef TMaybe[int] tmp1 = 17
-        cdef TMaybe[int] tmp2 = 42
-        cdef TMaybe[int] nothing
-
-        # ==
-        self.assertTrue(tmp1 == 17)
-        self.assertTrue(tmp1 == tmp1)
-        self.assertTrue(nothing == nothing)
-
-        self.assertFalse(tmp1 == 16)
-        self.assertFalse(tmp1 == tmp2)
-        self.assertFalse(tmp1 == nothing)
-
-        # !=
-        self.assertTrue(tmp1 != 16)
-        self.assertTrue(tmp1 != tmp2)
-        self.assertTrue(tmp1 != nothing)
-
-        self.assertFalse(tmp1 != 17)
-        self.assertFalse(tmp1 != tmp1)
-        self.assertFalse(nothing != nothing)
-
-        # <
-        self.assertTrue(nothing < tmp1)
-        self.assertTrue(nothing < tmp2)
-        self.assertTrue(tmp1 < tmp2)
-        self.assertTrue(nothing < 0)
-        self.assertTrue(tmp1 < 18)
-
-        self.assertFalse(nothing < nothing)
-        self.assertFalse(tmp1 < tmp1)
-        self.assertFalse(tmp2 < tmp1)
-        self.assertFalse(tmp1 < 16)
-
-        # <=
-        self.assertTrue(nothing <= nothing)
-        self.assertTrue(nothing <= tmp1)
-        self.assertTrue(nothing <= tmp2)
-        self.assertTrue(tmp1 <= tmp1)
-        self.assertTrue(tmp1 <= tmp2)
-        self.assertTrue(nothing <= 0)
-        self.assertTrue(tmp1 <= 18)
-
-        self.assertFalse(tmp2 <= tmp1)
-        self.assertFalse(tmp1 <= 16)
-
-        # >
-        self.assertTrue(tmp1 > nothing)
-        self.assertTrue(tmp2 > nothing)
-        self.assertTrue(tmp2 > tmp1)
-        self.assertTrue(tmp1 > 16)
-
-        self.assertFalse(nothing > nothing)
-        self.assertFalse(nothing > 0)
-        self.assertFalse(tmp1 > tmp1)
-        self.assertFalse(tmp1 > tmp2)
-        self.assertFalse(tmp1 > 18)
-
-        # >=
-        self.assertTrue(nothing >= nothing)
-        self.assertTrue(tmp1 >= nothing)
-        self.assertTrue(tmp2 >= nothing)
-        self.assertTrue(tmp2 >= tmp1)
-        self.assertTrue(tmp1 >= tmp1)
-        self.assertTrue(tmp1 >= 16)
-
-        self.assertFalse(nothing >= 0)
-        self.assertFalse(tmp1 >= tmp2)
-        self.assertFalse(tmp1 >= 18)
-
-    def test_construct_in_place(self):
-        cdef TMaybe[int] tmp
-        tmp.ConstructInPlace(42)
-        self.assertTrue(tmp.Defined())
-        self.assertEquals(tmp.GetRef(), 42)
-
-    def test_clear(self):
-        cdef TMaybe[int] tmp = 42
-        tmp.Clear()
-        self.assertFalse(tmp.Defined())
-
-    def test_defined(self):
-        cdef TMaybe[int] tmp
-        self.assertFalse(tmp.Defined())
-        self.assertTrue(tmp.Empty())
-        tmp = 42
-        self.assertTrue(tmp.Defined())
-        self.assertFalse(tmp.Empty())
-
-    def test_check_defined(self):
-        cdef TMaybe[int] tmp
-        with pytest.raises(RuntimeError):
-            tmp.CheckDefined()
-        tmp = 42
-        tmp.CheckDefined()
-
-    def test_get(self):
-        cdef TMaybe[int] tmp = 42
-        cdef int* p = tmp.Get()
-        self.assertTrue(p != NULL)
-        self.assertEquals(p[0], 42)
-
-    def test_get_ref(self):
-        cdef TMaybe[int] tmp = 42
-        self.assertTrue(tmp.Defined())
-        self.assertEquals(tmp.GetRef(), 42)
-
-    def test_get_or_else(self):
-        cdef TMaybe[int] tmp = 42
-        self.assertEquals(tmp.GetOrElse(13), 42)
-        tmp.Clear()
-        self.assertEquals(tmp.GetOrElse(13), 13)
-
-    def test_or_else(self):
-        cdef TMaybe[int] tmp = 42
-        cdef TMaybe[int] nothing
-        self.assertFalse(nothing.OrElse(nothing).Defined())
-        self.assertEquals(tmp.OrElse(nothing).GetRef(), 42)
-        self.assertEquals(nothing.OrElse(tmp).GetRef(), 42)
-        self.assertEquals(tmp.OrElse(tmp).GetRef(), 42)
-
-    def test_cast(self):
-        cdef TMaybe[int] tmp = 42
-        cdef TMaybe[char] tmp2 = tmp.Cast[char]()
-        self.assertEquals(tmp2.GetRef(), 42)
-
-    def test_swap(self):
-        cdef TMaybe[int] tmp1 = 42
-        cdef TMaybe[int] tmp2
-        tmp2.Swap(tmp1)
-        self.assertFalse(tmp1.Defined())
-        self.assertEquals(tmp2.GetRef(), 42)
-
-    def test_from_py(self):
-        self.assertTrue(_check_from_py(42))
-        self.assertFalse(_check_from_py(None))
-
-        with self.assertRaises(TypeError):
-            _check_from_py("ttt")
-
-    def test_to_py(self):
-        self.assertEquals(_check_to_py_value(), 42)
-        self.assertEquals(_check_to_py_nothing(), None)
+from util.generic.maybe cimport TMaybe, Nothing 
+ 
+import pytest 
+import unittest 
+ 
+ 
+def _check_from_py(TMaybe[int] x): 
+    return x.Defined() 
+ 
+ 
+def _check_to_py_value(): 
+    cdef TMaybe[int] tmp = TMaybe[int](42) 
+    return tmp 
+ 
+ 
+def _check_to_py_nothing(): 
+    cdef TMaybe[int] tmp = Nothing() 
+    return tmp 
+ 
+ 
+class TestMaybe(unittest.TestCase): 
+ 
+    def test_ctor1(self): 
+        cdef TMaybe[int] tmp = TMaybe[int]() 
+        self.assertFalse(tmp.Defined()) 
+ 
+    def test_ctor2(self): 
+        cdef TMaybe[int] tmp = TMaybe[int](42) 
+        self.assertTrue(tmp.Defined()) 
+        self.assertEquals(tmp.GetRef(), 42) 
+ 
+    def test_ctor3(self): 
+        cdef TMaybe[int] tmp = Nothing() 
+        self.assertFalse(tmp.Defined()) 
+ 
+    def test_operator_assign(self): 
+        cdef TMaybe[int] tmp 
+        tmp = 42 
+        self.assertTrue(tmp.Defined()) 
+        self.assertEquals(tmp.GetRef(), 42) 
+ 
+    def test_compare(self): 
+        cdef TMaybe[int] tmp1 = 17 
+        cdef TMaybe[int] tmp2 = 42 
+        cdef TMaybe[int] nothing 
+ 
+        # == 
+        self.assertTrue(tmp1 == 17) 
+        self.assertTrue(tmp1 == tmp1) 
+        self.assertTrue(nothing == nothing) 
+ 
+        self.assertFalse(tmp1 == 16) 
+        self.assertFalse(tmp1 == tmp2) 
+        self.assertFalse(tmp1 == nothing) 
+ 
+        # != 
+        self.assertTrue(tmp1 != 16) 
+        self.assertTrue(tmp1 != tmp2) 
+        self.assertTrue(tmp1 != nothing) 
+ 
+        self.assertFalse(tmp1 != 17) 
+        self.assertFalse(tmp1 != tmp1) 
+        self.assertFalse(nothing != nothing) 
+ 
+        # < 
+        self.assertTrue(nothing < tmp1) 
+        self.assertTrue(nothing < tmp2) 
+        self.assertTrue(tmp1 < tmp2) 
+        self.assertTrue(nothing < 0) 
+        self.assertTrue(tmp1 < 18) 
+ 
+        self.assertFalse(nothing < nothing) 
+        self.assertFalse(tmp1 < tmp1) 
+        self.assertFalse(tmp2 < tmp1) 
+        self.assertFalse(tmp1 < 16) 
+ 
+        # <= 
+        self.assertTrue(nothing <= nothing) 
+        self.assertTrue(nothing <= tmp1) 
+        self.assertTrue(nothing <= tmp2) 
+        self.assertTrue(tmp1 <= tmp1) 
+        self.assertTrue(tmp1 <= tmp2) 
+        self.assertTrue(nothing <= 0) 
+        self.assertTrue(tmp1 <= 18) 
+ 
+        self.assertFalse(tmp2 <= tmp1) 
+        self.assertFalse(tmp1 <= 16) 
+ 
+        # > 
+        self.assertTrue(tmp1 > nothing) 
+        self.assertTrue(tmp2 > nothing) 
+        self.assertTrue(tmp2 > tmp1) 
+        self.assertTrue(tmp1 > 16) 
+ 
+        self.assertFalse(nothing > nothing) 
+        self.assertFalse(nothing > 0) 
+        self.assertFalse(tmp1 > tmp1) 
+        self.assertFalse(tmp1 > tmp2) 
+        self.assertFalse(tmp1 > 18) 
+ 
+        # >= 
+        self.assertTrue(nothing >= nothing) 
+        self.assertTrue(tmp1 >= nothing) 
+        self.assertTrue(tmp2 >= nothing) 
+        self.assertTrue(tmp2 >= tmp1) 
+        self.assertTrue(tmp1 >= tmp1) 
+        self.assertTrue(tmp1 >= 16) 
+ 
+        self.assertFalse(nothing >= 0) 
+        self.assertFalse(tmp1 >= tmp2) 
+        self.assertFalse(tmp1 >= 18) 
+ 
+    def test_construct_in_place(self): 
+        cdef TMaybe[int] tmp 
+        tmp.ConstructInPlace(42) 
+        self.assertTrue(tmp.Defined()) 
+        self.assertEquals(tmp.GetRef(), 42) 
+ 
+    def test_clear(self): 
+        cdef TMaybe[int] tmp = 42 
+        tmp.Clear() 
+        self.assertFalse(tmp.Defined()) 
+ 
+    def test_defined(self): 
+        cdef TMaybe[int] tmp 
+        self.assertFalse(tmp.Defined()) 
+        self.assertTrue(tmp.Empty()) 
+        tmp = 42 
+        self.assertTrue(tmp.Defined()) 
+        self.assertFalse(tmp.Empty()) 
+ 
+    def test_check_defined(self): 
+        cdef TMaybe[int] tmp 
+        with pytest.raises(RuntimeError): 
+            tmp.CheckDefined() 
+        tmp = 42 
+        tmp.CheckDefined() 
+ 
+    def test_get(self): 
+        cdef TMaybe[int] tmp = 42 
+        cdef int* p = tmp.Get() 
+        self.assertTrue(p != NULL) 
+        self.assertEquals(p[0], 42) 
+ 
+    def test_get_ref(self): 
+        cdef TMaybe[int] tmp = 42 
+        self.assertTrue(tmp.Defined()) 
+        self.assertEquals(tmp.GetRef(), 42) 
+ 
+    def test_get_or_else(self): 
+        cdef TMaybe[int] tmp = 42 
+        self.assertEquals(tmp.GetOrElse(13), 42) 
+        tmp.Clear() 
+        self.assertEquals(tmp.GetOrElse(13), 13) 
+ 
+    def test_or_else(self): 
+        cdef TMaybe[int] tmp = 42 
+        cdef TMaybe[int] nothing 
+        self.assertFalse(nothing.OrElse(nothing).Defined()) 
+        self.assertEquals(tmp.OrElse(nothing).GetRef(), 42) 
+        self.assertEquals(nothing.OrElse(tmp).GetRef(), 42) 
+        self.assertEquals(tmp.OrElse(tmp).GetRef(), 42) 
+ 
+    def test_cast(self): 
+        cdef TMaybe[int] tmp = 42 
+        cdef TMaybe[char] tmp2 = tmp.Cast[char]() 
+        self.assertEquals(tmp2.GetRef(), 42) 
+ 
+    def test_swap(self): 
+        cdef TMaybe[int] tmp1 = 42 
+        cdef TMaybe[int] tmp2 
+        tmp2.Swap(tmp1) 
+        self.assertFalse(tmp1.Defined()) 
+        self.assertEquals(tmp2.GetRef(), 42) 
+ 
+    def test_from_py(self): 
+        self.assertTrue(_check_from_py(42)) 
+        self.assertFalse(_check_from_py(None)) 
+ 
+        with self.assertRaises(TypeError): 
+            _check_from_py("ttt") 
+ 
+    def test_to_py(self): 
+        self.assertEquals(_check_to_py_value(), 42) 
+        self.assertEquals(_check_to_py_nothing(), None) 
diff --git a/util/generic/overloaded.h b/util/generic/overloaded.h
index 96a97e44bc..eb9b58cad4 100644
--- a/util/generic/overloaded.h
+++ b/util/generic/overloaded.h
@@ -1,52 +1,52 @@
 #pragma once
 
-/**
+/** 
  * Construct an ad-hoc object with an overloaded `operator()`.
- *
+ * 
  * Typically used with lambdas to construct type-matching visitors for e.g. std::variant:
- * ```
+ * ``` 
  * std::variant<int, void*, TString> var;
- * Visit(TOverloaded{
- *     [](int val) { Cerr << "int: " << val; },
- *     [](void* val) { Cerr << "ptr: " << val; },
- *     [](const TString& val) { Cerr << "str: " << val; },
- * }, var);
- * ```
- *
- * *** IMPORTANT NOTE (IMPLICIT ARGUMENT CONVERSIONS) ***
- *
- * Since the resulting objects use regular overloaded method resolution rules,
- * methods may be called by inexact matches (causing implicit casts), hence this
- * implementation does not guarantee exhaustiveness of cases.
- *
- * For example, the following code will compile and run by casting all values to
- * double:
- * ```
+ * Visit(TOverloaded{ 
+ *     [](int val) { Cerr << "int: " << val; }, 
+ *     [](void* val) { Cerr << "ptr: " << val; }, 
+ *     [](const TString& val) { Cerr << "str: " << val; }, 
+ * }, var); 
+ * ``` 
+ * 
+ * *** IMPORTANT NOTE (IMPLICIT ARGUMENT CONVERSIONS) *** 
+ * 
+ * Since the resulting objects use regular overloaded method resolution rules, 
+ * methods may be called by inexact matches (causing implicit casts), hence this 
+ * implementation does not guarantee exhaustiveness of cases. 
+ * 
+ * For example, the following code will compile and run by casting all values to 
+ * double: 
+ * ``` 
  * std::variant<int, double, char> var;
- * Visit(TOverloaded{
- *     [](double val) { Cerr << "dbl: " << val; },
- * }, var);
- * ```
- *
- * If cases may be ambigous or specific type-matching logic is required,
- * a verbose `if constexpr`-based version would be preferred:
- * ```
+ * Visit(TOverloaded{ 
+ *     [](double val) { Cerr << "dbl: " << val; }, 
+ * }, var); 
+ * ``` 
+ * 
+ * If cases may be ambigous or specific type-matching logic is required, 
+ * a verbose `if constexpr`-based version would be preferred: 
+ * ``` 
  * std::variant<int, double, char> var;
- * Visit([](auto&& val) {
- *     using T = std::decay_t<decltype(val)>;
- *     if constexpr (std::is_same_v<T, int>) {
- *         Cerr << "int: " << val;
- *     } else if constexpr (std::is_same_v<T, double>) {
- *         Cerr << "dbl: " << val;
- *     } else if constexpr (std::is_same_v<T, char>) {
- *         Cerr << "chr: " << val;
- *     } else {
- *         static_assert(TDependentFalse<T>, "unexpected type");
- *     }
- * }, var);
- * ```
- */
-
+ * Visit([](auto&& val) { 
+ *     using T = std::decay_t<decltype(val)>; 
+ *     if constexpr (std::is_same_v<T, int>) { 
+ *         Cerr << "int: " << val; 
+ *     } else if constexpr (std::is_same_v<T, double>) { 
+ *         Cerr << "dbl: " << val; 
+ *     } else if constexpr (std::is_same_v<T, char>) { 
+ *         Cerr << "chr: " << val; 
+ *     } else { 
+ *         static_assert(TDependentFalse<T>, "unexpected type"); 
+ *     } 
+ * }, var); 
+ * ``` 
+ */ 
+ 
 template <class... Fs>
 struct TOverloaded: Fs... {
     using Fs::operator()...;
diff --git a/util/generic/overloaded_ut.cpp b/util/generic/overloaded_ut.cpp
index f3d73895ad..bf32daf475 100644
--- a/util/generic/overloaded_ut.cpp
+++ b/util/generic/overloaded_ut.cpp
@@ -1,4 +1,4 @@
-#include <util/generic/overloaded.h>
+#include <util/generic/overloaded.h> 
 
 #include <library/cpp/testing/unittest/registar.h>
 
@@ -35,7 +35,7 @@ Y_UNIT_TEST_SUITE(TOverloadedTest) {
                        [&](double) { res = -1; },
                        [&](TType1) { res = -1; }},
                    v);
-        UNIT_ASSERT_VALUES_EQUAL(res, 5);
+        UNIT_ASSERT_VALUES_EQUAL(res, 5); 
     }
 
     Y_UNIT_TEST(TupleTest) {
@@ -48,35 +48,35 @@ Y_UNIT_TEST_SUITE(TOverloadedTest) {
                        [&](bool val) { res += "(bool) " + ToString(val) + ' '; },
                    });
 
-        UNIT_ASSERT_VALUES_EQUAL(res, "(int) 5 (double) 3.14 (bool) 1 (int) 20 ");
+        UNIT_ASSERT_VALUES_EQUAL(res, "(int) 5 (double) 3.14 (bool) 1 (int) 20 "); 
     }
-
-    Y_UNIT_TEST(ImplicitConversionsTest) {
+ 
+    Y_UNIT_TEST(ImplicitConversionsTest) { 
         using TTestVariant = std::variant<int, double, char>;
-
-        // Purposefully exhibit inexact overload matched with implicit type
-        // conversions
-
-        // All cases implicitly cast to int
-        auto matchAsInt = [](TTestVariant var) {
+ 
+        // Purposefully exhibit inexact overload matched with implicit type 
+        // conversions 
+ 
+        // All cases implicitly cast to int 
+        auto matchAsInt = [](TTestVariant var) { 
             return std::visit(TOverloaded{
                                   [](int val) { return val; },
                               }, var);
-        };
-
-        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{17.77}), 17);
-        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{12345}), 12345);
-        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{'X'}), 88);
-
-        // All cases implicitly cast to double
-        auto matchAsDouble = [](TTestVariant var) {
+        }; 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{17.77}), 17); 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{12345}), 12345); 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{'X'}), 88); 
+ 
+        // All cases implicitly cast to double 
+        auto matchAsDouble = [](TTestVariant var) { 
             return std::visit(TOverloaded{
                                   [](double val) { return val; },
                               }, var);
-        };
-
-        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{17.77}), 17.77);
-        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{12345}), 12345.0);
-        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{'X'}), 88.0);
-    }
+        }; 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{17.77}), 17.77); 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{12345}), 12345.0); 
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{'X'}), 88.0); 
+    } 
 }
diff --git a/util/generic/ptr.h b/util/generic/ptr.h
index 19db0e3ec5..2ef6a9ad72 100644
--- a/util/generic/ptr.h
+++ b/util/generic/ptr.h
@@ -411,37 +411,37 @@ private:
     C Counter_;
 };
 
-/**
- * Atomically reference-counted base with a virtual destructor.
- *
- * @note Plays well with inheritance, should be used for refcounted base classes.
- */
+/** 
+ * Atomically reference-counted base with a virtual destructor. 
+ * 
+ * @note Plays well with inheritance, should be used for refcounted base classes. 
+ */ 
 struct TThrRefBase: public TRefCounted<TThrRefBase, TAtomicCounter> {
     virtual ~TThrRefBase();
 };
 
-/**
- * Atomically reference-counted base.
- *
- * Deletes refcounted object as type T.
- *
- * @warning Additional care should be taken with regard to inheritance.  If used
- * as a base class, @p T should either declare a virtual destructor, or be
+/** 
+ * Atomically reference-counted base. 
+ * 
+ * Deletes refcounted object as type T. 
+ * 
+ * @warning Additional care should be taken with regard to inheritance.  If used 
+ * as a base class, @p T should either declare a virtual destructor, or be 
  * derived from @p TThrRefBase instead. Otherwise, only destructor of class @p T
- * would be called, potentially slicing the object and creating memory leaks.
- *
- * @note To avoid accidental inheritance when it is not originally intended,
- * class @p T should be marked as final.
- */
+ * would be called, potentially slicing the object and creating memory leaks. 
+ * 
+ * @note To avoid accidental inheritance when it is not originally intended, 
+ * class @p T should be marked as final. 
+ */ 
 template <class T, class D = TDelete>
 using TAtomicRefCount = TRefCounted<T, TAtomicCounter, D>;
 
-/**
- * Non-atomically reference-counted base.
- *
- * @warning Not thread-safe. Use with great care. If in doubt, use @p ThrRefBase
- * or @p TAtomicRefCount instead.
- */
+/** 
+ * Non-atomically reference-counted base. 
+ * 
+ * @warning Not thread-safe. Use with great care. If in doubt, use @p ThrRefBase 
+ * or @p TAtomicRefCount instead. 
+ */ 
 template <class T, class D = TDelete>
 using TSimpleRefCount = TRefCounted<T, TSimpleCounter, D>;
 
diff --git a/util/generic/strbuf_ut.cpp b/util/generic/strbuf_ut.cpp
index 69cde785af..245bc3175e 100644
--- a/util/generic/strbuf_ut.cpp
+++ b/util/generic/strbuf_ut.cpp
@@ -28,15 +28,15 @@ Y_UNIT_TEST_SUITE(TStrBufTest) {
     }
 
     Y_UNIT_TEST(TestConstExpr) {
-        static constexpr TStringBuf str1("qwe\0rty", 7);
+        static constexpr TStringBuf str1("qwe\0rty", 7); 
         static constexpr TStringBuf str2(str1.data(), str1.size());
         static constexpr TStringBuf str3 = "qwe\0rty"sv;
-
+ 
         UNIT_ASSERT_VALUES_EQUAL(str1.size(), 7);
-
-        UNIT_ASSERT_VALUES_EQUAL(str1, str2);
-        UNIT_ASSERT_VALUES_EQUAL(str2, str3);
-        UNIT_ASSERT_VALUES_EQUAL(str1, str3);
+ 
+        UNIT_ASSERT_VALUES_EQUAL(str1, str2); 
+        UNIT_ASSERT_VALUES_EQUAL(str2, str3); 
+        UNIT_ASSERT_VALUES_EQUAL(str1, str3); 
 
         static constexpr std::string_view view1(str1);
         UNIT_ASSERT_VALUES_EQUAL(str1, view1);
@@ -47,8 +47,8 @@ Y_UNIT_TEST_SUITE(TStrBufTest) {
         UNIT_ASSERT_VALUES_EQUAL(str1, str4);
         static_assert(str1.data() == str4.data());
         static_assert(str1.size() == str4.size());
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestAfter) {
         TStringBuf str("qwerty");
 
diff --git a/util/generic/string.h b/util/generic/string.h
index 8cd8aa6917..de41fa7c0c 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -79,11 +79,11 @@ struct TStdString: public TRefCountHolder, public B {
     }
 
     static TStdString* NullStr() noexcept {
-    #ifdef _LIBCPP_VERSION
+    #ifdef _LIBCPP_VERSION 
         return (TStdString*)NULL_STRING_REPR;
-    #else
+    #else 
         return Singleton<TStdString>();
-    #endif
+    #endif 
     }
 
 private:
diff --git a/util/generic/string.pxd b/util/generic/string.pxd
index c25f7392a1..917c4e5a2a 100644
--- a/util/generic/string.pxd
+++ b/util/generic/string.pxd
@@ -1,8 +1,8 @@
-from libcpp.string cimport string as _std_string
+from libcpp.string cimport string as _std_string 
 
-cdef extern from "<util/generic/strbuf.h>" nogil:
-
-    cdef cppclass TStringBuf:
+cdef extern from "<util/generic/strbuf.h>" nogil: 
+ 
+    cdef cppclass TStringBuf: 
         TStringBuf() except +
         TStringBuf(const char*) except +
         TStringBuf(const char*, size_t) except +
@@ -10,14 +10,14 @@ cdef extern from "<util/generic/strbuf.h>" nogil:
         char* Data()
         size_t size()
         size_t Size()
-
-
+ 
+ 
 cdef extern from "<util/generic/string.h>" nogil:
 
     size_t npos "TString::npos"
 
-    # Inheritance is bogus, but it's safe to assume TString is-a TStringBuf via implicit cast
-    cdef cppclass TString(TStringBuf):
+    # Inheritance is bogus, but it's safe to assume TString is-a TStringBuf via implicit cast 
+    cdef cppclass TString(TStringBuf): 
         TString() except +
         TString(TString&) except +
         TString(_std_string&) except +
@@ -28,34 +28,34 @@ cdef extern from "<util/generic/string.h>" nogil:
         # as a TString formed by a repetition of character c, n times.
         TString(size_t, char) except +
         TString(char*, char*) except +
-        TString(TStringBuf&) except +
-        TString(TStringBuf&, TStringBuf&) except +
-        TString(TStringBuf&, TStringBuf&, TStringBuf&) except +
+        TString(TStringBuf&) except + 
+        TString(TStringBuf&, TStringBuf&) except + 
+        TString(TStringBuf&, TStringBuf&, TStringBuf&) except + 
 
         const char* c_str()
         size_t max_size()
         size_t length()
-        void resize(size_t) except +
-        void resize(size_t, char c) except +
+        void resize(size_t) except + 
+        void resize(size_t, char c) except + 
         size_t capacity()
-        void reserve(size_t) except +
-        void clear() except +
+        void reserve(size_t) except + 
+        void clear() except + 
         bint empty()
 
         char& at(size_t)
         char& operator[](size_t)
-        int compare(TStringBuf&)
+        int compare(TStringBuf&) 
 
-        TString& append(TStringBuf&) except +
-        TString& append(TStringBuf&, size_t, size_t) except +
+        TString& append(TStringBuf&) except + 
+        TString& append(TStringBuf&, size_t, size_t) except + 
         TString& append(char *) except +
         TString& append(char *, size_t) except +
         TString& append(size_t, char) except +
 
-        void push_back(char c) except +
+        void push_back(char c) except + 
 
-        TString& assign(TStringBuf&) except +
-        TString& assign(TStringBuf&, size_t, size_t) except +
+        TString& assign(TStringBuf&) except + 
+        TString& assign(TStringBuf&, size_t, size_t) except + 
         TString& assign(char *) except +
         TString& assign(char *, size_t) except +
 
@@ -65,54 +65,54 @@ cdef extern from "<util/generic/string.h>" nogil:
         TString& insert(size_t, char* s, size_t) except +
         TString& insert(size_t, size_t, char c) except +
 
-        size_t copy(char *, size_t) except +
-        size_t copy(char *, size_t, size_t) except +
+        size_t copy(char *, size_t) except + 
+        size_t copy(char *, size_t, size_t) except + 
 
-        size_t find(TStringBuf&)
-        size_t find(TStringBuf&, size_t pos)
-        size_t find(char)
+        size_t find(TStringBuf&) 
+        size_t find(TStringBuf&, size_t pos) 
+        size_t find(char) 
         size_t find(char, size_t pos)
 
-        size_t rfind(TStringBuf&)
-        size_t rfind(TStringBuf&, size_t pos)
-        size_t rfind(char)
-        size_t rfind(char, size_t pos)
+        size_t rfind(TStringBuf&) 
+        size_t rfind(TStringBuf&, size_t pos) 
+        size_t rfind(char) 
+        size_t rfind(char, size_t pos) 
 
         size_t find_first_of(char c)
-        size_t find_first_of(char c, size_t pos)
-        size_t find_first_of(TStringBuf& set)
-        size_t find_first_of(TStringBuf& set, size_t pos)
+        size_t find_first_of(char c, size_t pos) 
+        size_t find_first_of(TStringBuf& set) 
+        size_t find_first_of(TStringBuf& set, size_t pos) 
 
         size_t find_first_not_of(char c)
-        size_t find_first_not_of(char c, size_t pos)
-        size_t find_first_not_of(TStringBuf& set)
-        size_t find_first_not_of(TStringBuf& set, size_t pos)
+        size_t find_first_not_of(char c, size_t pos) 
+        size_t find_first_not_of(TStringBuf& set) 
+        size_t find_first_not_of(TStringBuf& set, size_t pos) 
 
         size_t find_last_of(char c)
-        size_t find_last_of(char c, size_t pos)
-        size_t find_last_of(TStringBuf& set)
-        size_t find_last_of(TStringBuf& set, size_t pos)
+        size_t find_last_of(char c, size_t pos) 
+        size_t find_last_of(TStringBuf& set) 
+        size_t find_last_of(TStringBuf& set, size_t pos) 
 
         TString substr(size_t pos) except +
         TString substr(size_t pos, size_t n) except +
 
-        TString operator+(TStringBuf& rhs) except +
+        TString operator+(TStringBuf& rhs) except + 
         TString operator+(char* rhs) except +
 
-        bint operator==(TStringBuf&)
+        bint operator==(TStringBuf&) 
         bint operator==(char*)
 
-        bint operator!=(TStringBuf&)
-        bint operator!=(char*)
+        bint operator!=(TStringBuf&) 
+        bint operator!=(char*) 
 
-        bint operator<(TStringBuf&)
-        bint operator<(char*)
+        bint operator<(TStringBuf&) 
+        bint operator<(char*) 
 
-        bint operator>(TStringBuf&)
-        bint operator>(char*)
+        bint operator>(TStringBuf&) 
+        bint operator>(char*) 
 
-        bint operator<=(TStringBuf&)
-        bint operator<=(char*)
+        bint operator<=(TStringBuf&) 
+        bint operator<=(char*) 
 
-        bint operator>=(TStringBuf&)
-        bint operator>=(char*)
+        bint operator>=(TStringBuf&) 
+        bint operator>=(char*) 
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index ac82e9091d..0d47f2d022 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -107,7 +107,7 @@ protected:
         // Non-shared behaviour - never shrink
 
         s.reserve(256);
-    #ifndef TSTRING_IS_STD_STRING
+    #ifndef TSTRING_IS_STD_STRING 
         const auto* data = s.data();
 
         UNIT_ASSERT(s.capacity() >= 256);
@@ -115,18 +115,18 @@ protected:
         s.reserve(128);
 
         UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
-    #endif
+    #endif 
 
         s.resize(64, 'x');
         s.reserve(10);
 
-    #ifdef TSTRING_IS_STD_STRING
+    #ifdef TSTRING_IS_STD_STRING 
         UNIT_ASSERT(s.capacity() >= 64);
-    #else
+    #else 
         UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
-    #endif
+    #endif 
 
-    #ifndef TSTRING_IS_STD_STRING
+    #ifndef TSTRING_IS_STD_STRING 
         // Shared behaviour - always reallocate, just as much as requisted
 
         TStringType holder = s;
@@ -146,7 +146,7 @@ protected:
 
         UNIT_ASSERT(s.capacity() >= 64 && s.capacity() < 128 && s.data() != data);
         UNIT_ASSERT(s.IsDetached());
-    #endif
+    #endif 
 #endif
     }
 
diff --git a/util/generic/string_ut.pyx b/util/generic/string_ut.pyx
index 5407f5b4c1..0aafffd1d1 100644
--- a/util/generic/string_ut.pyx
+++ b/util/generic/string_ut.pyx
@@ -1,225 +1,225 @@
 # cython: c_string_type=str, c_string_encoding=utf8
 
-from libcpp.string cimport string as std_string
+from libcpp.string cimport string as std_string 
 from util.generic.string cimport TString, npos
-
-import pytest
-import unittest
-
+ 
+import pytest 
+import unittest 
+ 
 import sys
+ 
 
-
-class TestStroka(unittest.TestCase):
+class TestStroka(unittest.TestCase): 
     def test_unicode(self):
         cdef TString x = "привет"
         self.assertEquals(x, "привет")
+ 
 
-
-    def test_ctor1(self):
+    def test_ctor1(self): 
         cdef TString tmp = TString()
         cdef TString tmp2 = TString(tmp)
         self.assertEquals(tmp2, "")
-
-    def test_ctor2(self):
-        cdef std_string tmp = b"hello"
+ 
+    def test_ctor2(self): 
+        cdef std_string tmp = b"hello" 
         cdef TString tmp2 = TString(tmp)
         self.assertEquals(tmp2, "hello")
-
-    def test_ctor3(self):
-        cdef TString tmp = b"hello"
+ 
+    def test_ctor3(self): 
+        cdef TString tmp = b"hello" 
         cdef TString tmp2 = TString(tmp, 0, 4)
         self.assertEquals(tmp2, "hell")
-
-    def test_ctor4(self):
+ 
+    def test_ctor4(self): 
         cdef TString tmp = TString(<char*>b"hello")
         self.assertEquals(tmp, "hello")
-
-    def test_ctor5(self):
+ 
+    def test_ctor5(self): 
         cdef TString tmp = TString(<char*>b"hello", 4)
         self.assertEquals(tmp, "hell")
-
-    def test_ctor6(self):
+ 
+    def test_ctor6(self): 
         cdef TString tmp = TString(<char*>b"hello", 1, 3)
         self.assertEquals(tmp, "ell")
-
-    def test_ctor7(self):
+ 
+    def test_ctor7(self): 
         cdef TString tmp = TString(3, <char>'x')
         self.assertEquals(tmp, "xxx")
-
-    def test_ctor8(self):
-        cdef bytes tmp = b"hello"
+ 
+    def test_ctor8(self): 
+        cdef bytes tmp = b"hello" 
         cdef TString tmp2 = TString(<char*>tmp, <char*>tmp + 4)
         self.assertEquals(tmp2, "hell")
-
-    def test_compare(self):
-        cdef TString tmp1 = b"abacab"
-        cdef TString tmp2 = b"abacab"
-        cdef TString tmp3 = b"abacac"
-
-        self.assertTrue(tmp1.compare(tmp2) == 0)
-        self.assertTrue(tmp1.compare(tmp3) < 0)
-        self.assertTrue(tmp3.compare(tmp1) > 0)
-
-        self.assertTrue(tmp1 == tmp2)
-        self.assertTrue(tmp1 != tmp3)
-
-        self.assertTrue(tmp1 < tmp3)
-        self.assertTrue(tmp1 <= tmp3)
-
-        self.assertTrue(tmp3 > tmp1)
-        self.assertTrue(tmp3 >= tmp1)
-
-    def test_operator_assign(self):
-        cdef TString tmp = b"hello"
+ 
+    def test_compare(self): 
+        cdef TString tmp1 = b"abacab" 
+        cdef TString tmp2 = b"abacab" 
+        cdef TString tmp3 = b"abacac" 
+ 
+        self.assertTrue(tmp1.compare(tmp2) == 0) 
+        self.assertTrue(tmp1.compare(tmp3) < 0) 
+        self.assertTrue(tmp3.compare(tmp1) > 0) 
+ 
+        self.assertTrue(tmp1 == tmp2) 
+        self.assertTrue(tmp1 != tmp3) 
+ 
+        self.assertTrue(tmp1 < tmp3) 
+        self.assertTrue(tmp1 <= tmp3) 
+ 
+        self.assertTrue(tmp3 > tmp1) 
+        self.assertTrue(tmp3 >= tmp1) 
+ 
+    def test_operator_assign(self): 
+        cdef TString tmp = b"hello" 
         cdef TString tmp2 = tmp
         self.assertEquals(tmp2, "hello")
-
-    def test_operator_plus(self):
-        cdef TString tmp = TString(b"hello ") + TString(b"world")
+ 
+    def test_operator_plus(self): 
+        cdef TString tmp = TString(b"hello ") + TString(b"world") 
         self.assertEquals(tmp, "hello world")
-
-    def test_c_str(self):
-        cdef TString tmp = b"hello"
+ 
+    def test_c_str(self): 
+        cdef TString tmp = b"hello" 
         if sys.version_info.major == 2:
             self.assertEquals(bytes(tmp.c_str()), b"hello")
         else:
             self.assertEquals(bytes(tmp.c_str(), 'utf8'), b"hello")
-
-    def test_length(self):
-        cdef TString tmp = b"hello"
-        self.assertEquals(tmp.size(), tmp.length())
-
-    def test_index(self):
-        cdef TString tmp = b"hello"
-
-        self.assertEquals(<bytes>tmp[0], b'h')
-        self.assertEquals(<bytes>tmp.at(0), b'h')
-
-        self.assertEquals(<bytes>tmp[4], b'o')
-        self.assertEquals(<bytes>tmp.at(4), b'o')
-
+ 
+    def test_length(self): 
+        cdef TString tmp = b"hello" 
+        self.assertEquals(tmp.size(), tmp.length()) 
+ 
+    def test_index(self): 
+        cdef TString tmp = b"hello" 
+ 
+        self.assertEquals(<bytes>tmp[0], b'h') 
+        self.assertEquals(<bytes>tmp.at(0), b'h') 
+ 
+        self.assertEquals(<bytes>tmp[4], b'o') 
+        self.assertEquals(<bytes>tmp.at(4), b'o') 
+ 
         # Actually, TString::at() is noexcept
-        # with pytest.raises(IndexError):
-        #     tmp.at(100)
-
-    def test_append(self):
+        # with pytest.raises(IndexError): 
+        #     tmp.at(100) 
+ 
+    def test_append(self): 
         cdef TString tmp
-        cdef TString tmp2 = b"fuu"
-
-        tmp.append(tmp2)
+        cdef TString tmp2 = b"fuu" 
+ 
+        tmp.append(tmp2) 
         self.assertEquals(tmp, "fuu")
-
-        tmp.append(tmp2, 1, 2)
+ 
+        tmp.append(tmp2, 1, 2) 
         self.assertEquals(tmp, "fuuuu")
-
-        tmp.append(<char*>"ll ")
+ 
+        tmp.append(<char*>"ll ") 
         self.assertEquals(tmp, "fuuuull ")
-
-        tmp.append(<char*>"of greatness", 4)
+ 
+        tmp.append(<char*>"of greatness", 4) 
         self.assertEquals(tmp, "fuuuull of g")
-
-        tmp.append(2, <char>b'o')
+ 
+        tmp.append(2, <char>b'o') 
         self.assertEquals(tmp, "fuuuull of goo")
-
-        tmp.push_back(b'z')
+ 
+        tmp.push_back(b'z') 
         self.assertEquals(tmp, "fuuuull of gooz")
-
-    def test_assign(self):
+ 
+    def test_assign(self): 
         cdef TString tmp
-
-        tmp.assign(b"one")
+ 
+        tmp.assign(b"one") 
         self.assertEquals(tmp, "one")
-
-        tmp.assign(b"two hundred", 0, 3)
+ 
+        tmp.assign(b"two hundred", 0, 3) 
         self.assertEquals(tmp, "two")
-
-        tmp.assign(<char*>b"three")
+ 
+        tmp.assign(<char*>b"three") 
         self.assertEquals(tmp, "three")
-
-        tmp.assign(<char*>b"three fiddy", 5)
+ 
+        tmp.assign(<char*>b"three fiddy", 5) 
         self.assertEquals(tmp, "three")
-
-    def test_insert(self):
+ 
+    def test_insert(self): 
         cdef TString tmp
-
-        tmp = b"xx"
-        tmp.insert(1, b"foo")
+ 
+        tmp = b"xx" 
+        tmp.insert(1, b"foo") 
         self.assertEquals(tmp, "xfoox")
-
-        tmp = b"xx"
-        tmp.insert(1, b"haxor", 1, 3)
+ 
+        tmp = b"xx" 
+        tmp.insert(1, b"haxor", 1, 3) 
         self.assertEquals(tmp, "xaxox")
-
-        tmp = b"xx"
-        tmp.insert(1, <char*>b"foo")
+ 
+        tmp = b"xx" 
+        tmp.insert(1, <char*>b"foo") 
         self.assertEquals(tmp, "xfoox")
-
-        tmp = b"xx"
-        tmp.insert(1, <char*>b"foozzy", 3)
+ 
+        tmp = b"xx" 
+        tmp.insert(1, <char*>b"foozzy", 3) 
         self.assertEquals(tmp, "xfoox")
-
-        tmp = b"xx"
-        tmp.insert(1, 2, <char>b'u')
+ 
+        tmp = b"xx" 
+        tmp.insert(1, 2, <char>b'u') 
         self.assertEquals(tmp, "xuux")
-
-    def test_copy(self):
-        cdef char buf[16]
-        cdef TString tmp = b"hello"
-        tmp.copy(buf, 5, 0)
+ 
+    def test_copy(self): 
+        cdef char buf[16] 
+        cdef TString tmp = b"hello" 
+        tmp.copy(buf, 5, 0) 
         self.assertEquals(buf[:5], "hello")
-
-    def test_find(self):
-        cdef TString haystack = b"whole lotta bytes"
+ 
+    def test_find(self): 
+        cdef TString haystack = b"whole lotta bytes" 
         cdef TString needle = "hole"
-
-        self.assertEquals(haystack.find(needle), 1)
-        self.assertEquals(haystack.find(needle, 3), npos)
-
-        self.assertEquals(haystack.find(<char>b'h'), 1)
-        self.assertEquals(haystack.find(<char>b'h', 3), npos)
-
-    def test_rfind(self):
-        cdef TString haystack = b"whole lotta bytes"
-        cdef TString needle = b"hole"
-
-        self.assertEquals(haystack.rfind(needle), 1)
-        self.assertEquals(haystack.rfind(needle, 0), npos)
-
-        self.assertEquals(haystack.rfind(<char>b'h'), 1)
-        self.assertEquals(haystack.rfind(<char>b'h', 0), npos)
-
-    def test_find_first_of(self):
-        cdef TString haystack = b"whole lotta bytes"
-        cdef TString cset = b"hxz"
-
-        self.assertEquals(haystack.find_first_of(<char>b'h'), 1)
-        self.assertEquals(haystack.find_first_of(<char>b'h', 3), npos)
-
-        self.assertEquals(haystack.find_first_of(cset), 1)
-        self.assertEquals(haystack.find_first_of(cset, 3), npos)
-
-    def test_first_not_of(self):
-        cdef TString haystack = b"whole lotta bytes"
-        cdef TString cset = b"wxz"
-
-        self.assertEquals(haystack.find_first_not_of(<char>b'w'), 1)
-        self.assertEquals(haystack.find_first_not_of(<char>b'w', 3), 3)
-
-        self.assertEquals(haystack.find_first_not_of(cset), 1)
-        self.assertEquals(haystack.find_first_not_of(cset, 3), 3)
-
-    def test_find_last_of(self):
-        cdef TString haystack = b"whole lotta bytes"
-        cdef TString cset = b"hxz"
-
-        self.assertEquals(haystack.find_last_of(<char>b'h'), 1)
-        self.assertEquals(haystack.find_last_of(<char>b'h', 0), npos)
-
-        self.assertEquals(haystack.find_last_of(cset), 1)
-        self.assertEquals(haystack.find_last_of(cset, 0), npos)
-
-    def test_substr(self):
-        cdef TString tmp = b"foobar"
-
+ 
+        self.assertEquals(haystack.find(needle), 1) 
+        self.assertEquals(haystack.find(needle, 3), npos) 
+ 
+        self.assertEquals(haystack.find(<char>b'h'), 1) 
+        self.assertEquals(haystack.find(<char>b'h', 3), npos) 
+ 
+    def test_rfind(self): 
+        cdef TString haystack = b"whole lotta bytes" 
+        cdef TString needle = b"hole" 
+ 
+        self.assertEquals(haystack.rfind(needle), 1) 
+        self.assertEquals(haystack.rfind(needle, 0), npos) 
+ 
+        self.assertEquals(haystack.rfind(<char>b'h'), 1) 
+        self.assertEquals(haystack.rfind(<char>b'h', 0), npos) 
+ 
+    def test_find_first_of(self): 
+        cdef TString haystack = b"whole lotta bytes" 
+        cdef TString cset = b"hxz" 
+ 
+        self.assertEquals(haystack.find_first_of(<char>b'h'), 1) 
+        self.assertEquals(haystack.find_first_of(<char>b'h', 3), npos) 
+ 
+        self.assertEquals(haystack.find_first_of(cset), 1) 
+        self.assertEquals(haystack.find_first_of(cset, 3), npos) 
+ 
+    def test_first_not_of(self): 
+        cdef TString haystack = b"whole lotta bytes" 
+        cdef TString cset = b"wxz" 
+ 
+        self.assertEquals(haystack.find_first_not_of(<char>b'w'), 1) 
+        self.assertEquals(haystack.find_first_not_of(<char>b'w', 3), 3) 
+ 
+        self.assertEquals(haystack.find_first_not_of(cset), 1) 
+        self.assertEquals(haystack.find_first_not_of(cset, 3), 3) 
+ 
+    def test_find_last_of(self): 
+        cdef TString haystack = b"whole lotta bytes" 
+        cdef TString cset = b"hxz" 
+ 
+        self.assertEquals(haystack.find_last_of(<char>b'h'), 1) 
+        self.assertEquals(haystack.find_last_of(<char>b'h', 0), npos) 
+ 
+        self.assertEquals(haystack.find_last_of(cset), 1) 
+        self.assertEquals(haystack.find_last_of(cset, 0), npos) 
+ 
+    def test_substr(self): 
+        cdef TString tmp = b"foobar" 
+ 
         self.assertEquals(tmp.substr(1), "oobar")
         self.assertEquals(tmp.substr(1, 4), "ooba")
diff --git a/util/generic/ut/ya.make b/util/generic/ut/ya.make
index 6eaf24cc5f..61f5ed02a7 100644
--- a/util/generic/ut/ya.make
+++ b/util/generic/ut/ya.make
@@ -32,7 +32,7 @@ SRCS(
     generic/maybe_ut.cpp
     generic/mem_copy_ut.cpp
     generic/objects_counter_ut.cpp
-    generic/overloaded_ut.cpp
+    generic/overloaded_ut.cpp 
     generic/ptr_ut.cpp
     generic/queue_ut.cpp
     generic/serialized_enum_ut.cpp
diff --git a/util/generic/vector.pxd b/util/generic/vector.pxd
index 99dde95d48..1675abb609 100644
--- a/util/generic/vector.pxd
+++ b/util/generic/vector.pxd
@@ -1,4 +1,4 @@
-cdef extern from "<util/generic/vector.h>" nogil:
+cdef extern from "<util/generic/vector.h>" nogil: 
     cdef cppclass TVector[T]:
         cppclass iterator:
             T& operator*()
@@ -12,67 +12,67 @@ cdef extern from "<util/generic/vector.h>" nogil:
             bint operator>(iterator)
             bint operator<=(iterator)
             bint operator>=(iterator)
-
+ 
         cppclass reverse_iterator:
             T& operator*()
-            reverse_iterator operator++()
-            reverse_iterator operator--()
-            reverse_iterator operator+(size_t)
-            reverse_iterator operator-(size_t)
+            reverse_iterator operator++() 
+            reverse_iterator operator--() 
+            reverse_iterator operator+(size_t) 
+            reverse_iterator operator-(size_t) 
             bint operator==(reverse_iterator)
             bint operator!=(reverse_iterator)
             bint operator<(reverse_iterator)
             bint operator>(reverse_iterator)
             bint operator<=(reverse_iterator)
             bint operator>=(reverse_iterator)
-
+ 
         cppclass const_iterator(iterator):
             pass
-
+ 
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-
+ 
         TVector() except +
         TVector(TVector&) except +
         TVector(size_t) except +
         TVector(size_t, T&) except +
-
+ 
         bint operator==(TVector&)
         bint operator!=(TVector&)
         bint operator<(TVector&)
         bint operator>(TVector&)
         bint operator<=(TVector&)
         bint operator>=(TVector&)
-
-        void assign(size_t, const T&) except +
+ 
+        void assign(size_t, const T&) except + 
         void assign[input_iterator](input_iterator, input_iterator) except +
-
+ 
         T& at(size_t) except +
-        T& operator[](size_t)
-
+        T& operator[](size_t) 
+ 
         T& back()
         iterator begin()
         const_iterator const_begin "begin"()
         size_t capacity()
-        void clear() except +
+        void clear() except + 
         bint empty()
         iterator end()
         const_iterator const_end "end"()
-        iterator erase(iterator) except +
-        iterator erase(iterator, iterator) except +
+        iterator erase(iterator) except + 
+        iterator erase(iterator, iterator) except + 
         T& front()
         iterator insert(iterator, const T&) except +
         void insert(iterator, size_t, const T&) except +
         void insert[Iter](iterator, Iter, Iter) except +
         size_t max_size()
-        void pop_back() except +
+        void pop_back() except + 
         void push_back(T&) except +
         void emplace_back(...) except +
         reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
         reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        void reserve(size_t) except +
+        void reserve(size_t) except + 
         void resize(size_t) except +
         void resize(size_t, T&) except +
         size_t size()
@@ -80,4 +80,4 @@ cdef extern from "<util/generic/vector.h>" nogil:
 
         # C++11 methods
         T* data()
-        void shrink_to_fit() except +
+        void shrink_to_fit() except + 
diff --git a/util/generic/vector_ut.pyx b/util/generic/vector_ut.pyx
index 904e67733b..1aa7af2427 100644
--- a/util/generic/vector_ut.pyx
+++ b/util/generic/vector_ut.pyx
@@ -1,221 +1,221 @@
 # cython: c_string_type=str, c_string_encoding=utf8
 
 from util.generic.vector cimport TVector
-from util.generic.string cimport TString
-
-import pytest
-import unittest
-
-
+from util.generic.string cimport TString 
+ 
+import pytest 
+import unittest 
+ 
+ 
 def _check_convert(TVector[TString] x):
-    return x
-
-
-class TestVector(unittest.TestCase):
-
-    def test_ctor1(self):
+    return x 
+ 
+ 
+class TestVector(unittest.TestCase): 
+ 
+    def test_ctor1(self): 
         cdef TVector[int] tmp = TVector[int]()
-        self.assertEqual(tmp.size(), 0)
-
-    def test_ctor2(self):
+        self.assertEqual(tmp.size(), 0) 
+ 
+    def test_ctor2(self): 
         cdef TVector[int] tmp = TVector[int](10)
-        self.assertEqual(tmp.size(), 10)
-        self.assertEqual(tmp[0], 0)
-
-    def test_ctor3(self):
+        self.assertEqual(tmp.size(), 10) 
+        self.assertEqual(tmp[0], 0) 
+ 
+    def test_ctor3(self): 
         cdef TVector[int] tmp = TVector[int](10, 42)
-        self.assertEqual(tmp.size(), 10)
-        self.assertEqual(tmp[0], 42)
-
-    def test_ctor4(self):
+        self.assertEqual(tmp.size(), 10) 
+        self.assertEqual(tmp[0], 42) 
+ 
+    def test_ctor4(self): 
         cdef TVector[int] tmp = TVector[int](10, 42)
         cdef TVector[int] tmp2 = TVector[int](tmp)
-        self.assertEqual(tmp2.size(), 10)
-        self.assertEqual(tmp2[0], 42)
-
-    def test_operator_assign(self):
+        self.assertEqual(tmp2.size(), 10) 
+        self.assertEqual(tmp2[0], 42) 
+ 
+    def test_operator_assign(self): 
         cdef TVector[int] tmp2
-        tmp2.push_back(1)
-        tmp2.push_back(2)
-
+        tmp2.push_back(1) 
+        tmp2.push_back(2) 
+ 
         cdef TVector[int] tmp3
-        tmp3.push_back(1)
-        tmp3.push_back(3)
-
+        tmp3.push_back(1) 
+        tmp3.push_back(3) 
+ 
         self.assertEqual(tmp2[1], 2)
         self.assertEqual(tmp3[1], 3)
 
-        tmp3 = tmp2
-
+        tmp3 = tmp2 
+ 
         self.assertEqual(tmp2[1], 2)
         self.assertEqual(tmp3[1], 2)
 
-    def test_compare(self):
+    def test_compare(self): 
         cdef TVector[int] tmp1
-        tmp1.push_back(1)
-        tmp1.push_back(2)
-
+        tmp1.push_back(1) 
+        tmp1.push_back(2) 
+ 
         cdef TVector[int] tmp2
-        tmp2.push_back(1)
-        tmp2.push_back(2)
-
+        tmp2.push_back(1) 
+        tmp2.push_back(2) 
+ 
         cdef TVector[int] tmp3
-        tmp3.push_back(1)
-        tmp3.push_back(3)
-
-        self.assertTrue(tmp1 == tmp2)
-        self.assertTrue(tmp1 != tmp3)
-
-        self.assertTrue(tmp1 < tmp3)
-        self.assertTrue(tmp1 <= tmp3)
-
-        self.assertTrue(tmp3 > tmp1)
-        self.assertTrue(tmp3 >= tmp1)
-
-    def test_index(self):
+        tmp3.push_back(1) 
+        tmp3.push_back(3) 
+ 
+        self.assertTrue(tmp1 == tmp2) 
+        self.assertTrue(tmp1 != tmp3) 
+ 
+        self.assertTrue(tmp1 < tmp3) 
+        self.assertTrue(tmp1 <= tmp3) 
+ 
+        self.assertTrue(tmp3 > tmp1) 
+        self.assertTrue(tmp3 >= tmp1) 
+ 
+    def test_index(self): 
         cdef TVector[int] tmp = TVector[int](10, 42)
-
-        self.assertEqual(tmp[0], 42)
-        self.assertEqual(tmp[5], 42)
-
-        self.assertEqual(tmp.data()[0], 42)
-        self.assertEqual(tmp.data()[5], 42)
-
-        self.assertEqual(tmp.at(0), 42)
-        self.assertEqual(tmp.at(5), 42)
-
-        with pytest.raises(IndexError):
-            tmp.at(100)
-
-    def test_push_pop_back(self):
+ 
+        self.assertEqual(tmp[0], 42) 
+        self.assertEqual(tmp[5], 42) 
+ 
+        self.assertEqual(tmp.data()[0], 42) 
+        self.assertEqual(tmp.data()[5], 42) 
+ 
+        self.assertEqual(tmp.at(0), 42) 
+        self.assertEqual(tmp.at(5), 42) 
+ 
+        with pytest.raises(IndexError): 
+            tmp.at(100) 
+ 
+    def test_push_pop_back(self): 
         cdef TVector[int] tmp
-        self.assertEqual(tmp.size(), 0)
-
-        tmp.push_back(42)
-        self.assertEqual(tmp.size(), 1)
-        self.assertEqual(tmp.back(), 42)
-
-        tmp.push_back(77)
-        self.assertEqual(tmp.size(), 2)
-        self.assertEqual(tmp.back(), 77)
-
-        tmp.pop_back()
-        self.assertEqual(tmp.size(), 1)
-        self.assertEqual(tmp.back(), 42)
-
-        tmp.pop_back()
-        self.assertEqual(tmp.size(), 0)
-
-    def test_front(self):
+        self.assertEqual(tmp.size(), 0) 
+ 
+        tmp.push_back(42) 
+        self.assertEqual(tmp.size(), 1) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+        tmp.push_back(77) 
+        self.assertEqual(tmp.size(), 2) 
+        self.assertEqual(tmp.back(), 77) 
+ 
+        tmp.pop_back() 
+        self.assertEqual(tmp.size(), 1) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+        tmp.pop_back() 
+        self.assertEqual(tmp.size(), 0) 
+ 
+    def test_front(self): 
         cdef TVector[int] tmp
-        tmp.push_back(42)
-        self.assertEqual(tmp.front(), 42)
-
-    def test_empty(self):
+        tmp.push_back(42) 
+        self.assertEqual(tmp.front(), 42) 
+ 
+    def test_empty(self): 
         cdef TVector[int] tmp
-        self.assertTrue(tmp.empty())
-        tmp.push_back(42)
-        self.assertFalse(tmp.empty())
-
-    def test_max_size(self):
+        self.assertTrue(tmp.empty()) 
+        tmp.push_back(42) 
+        self.assertFalse(tmp.empty()) 
+ 
+    def test_max_size(self): 
         cdef TVector[int] tmp
-        self.assertTrue(tmp.max_size() > 0)
-
-    def test_reserve_resize(self):
+        self.assertTrue(tmp.max_size() > 0) 
+ 
+    def test_reserve_resize(self): 
         cdef TVector[int] tmp
-        tmp.reserve(1000)
-        self.assertEqual(tmp.capacity(), 1000)
-
-        tmp.resize(100)
-        self.assertEqual(tmp.size(), 100)
-        self.assertEqual(tmp.front(), 0)
-        self.assertEqual(tmp.back(), 0)
-
-        tmp.shrink_to_fit()
-        tmp.clear()
-
-        tmp.resize(100, 42)
-        self.assertEqual(tmp.size(), 100)
-        self.assertEqual(tmp.front(), 42)
-        self.assertEqual(tmp.back(), 42)
-
-    def test_iter(self):
+        tmp.reserve(1000) 
+        self.assertEqual(tmp.capacity(), 1000) 
+ 
+        tmp.resize(100) 
+        self.assertEqual(tmp.size(), 100) 
+        self.assertEqual(tmp.front(), 0) 
+        self.assertEqual(tmp.back(), 0) 
+ 
+        tmp.shrink_to_fit() 
+        tmp.clear() 
+ 
+        tmp.resize(100, 42) 
+        self.assertEqual(tmp.size(), 100) 
+        self.assertEqual(tmp.front(), 42) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+    def test_iter(self): 
         cdef TVector[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(20)
-        tmp.push_back(300)
-
-        self.assertEqual([i for i in tmp], [1, 20, 300])
-
-    def test_iterator(self):
+        tmp.push_back(1) 
+        tmp.push_back(20) 
+        tmp.push_back(300) 
+ 
+        self.assertEqual([i for i in tmp], [1, 20, 300]) 
+ 
+    def test_iterator(self): 
         cdef TVector[int] tmp
-
-        self.assertTrue(tmp.begin() == tmp.end())
-        self.assertTrue(tmp.rbegin() == tmp.rend())
-        self.assertTrue(tmp.const_begin() == tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() == tmp.const_rend())
-
-        tmp.push_back(1)
-
-        self.assertTrue(tmp.begin() != tmp.end())
-        self.assertTrue(tmp.rbegin() != tmp.rend())
-        self.assertTrue(tmp.const_begin() != tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() != tmp.const_rend())
-
-        self.assertTrue(tmp.begin() < tmp.end())
-        self.assertTrue(tmp.rbegin() < tmp.rend())
-        self.assertTrue(tmp.const_begin() < tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() < tmp.const_rend())
-
-        self.assertTrue(tmp.begin() + 1 == tmp.end())
-        self.assertTrue(tmp.rbegin() + 1 == tmp.rend())
-        self.assertTrue(tmp.const_begin() + 1 == tmp.const_end())
-        self.assertTrue(tmp.const_rbegin() + 1 == tmp.const_rend())
-
-    def test_assign(self):
+ 
+        self.assertTrue(tmp.begin() == tmp.end()) 
+        self.assertTrue(tmp.rbegin() == tmp.rend()) 
+        self.assertTrue(tmp.const_begin() == tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() == tmp.const_rend()) 
+ 
+        tmp.push_back(1) 
+ 
+        self.assertTrue(tmp.begin() != tmp.end()) 
+        self.assertTrue(tmp.rbegin() != tmp.rend()) 
+        self.assertTrue(tmp.const_begin() != tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() != tmp.const_rend()) 
+ 
+        self.assertTrue(tmp.begin() < tmp.end()) 
+        self.assertTrue(tmp.rbegin() < tmp.rend()) 
+        self.assertTrue(tmp.const_begin() < tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() < tmp.const_rend()) 
+ 
+        self.assertTrue(tmp.begin() + 1 == tmp.end()) 
+        self.assertTrue(tmp.rbegin() + 1 == tmp.rend()) 
+        self.assertTrue(tmp.const_begin() + 1 == tmp.const_end()) 
+        self.assertTrue(tmp.const_rbegin() + 1 == tmp.const_rend()) 
+ 
+    def test_assign(self): 
         cdef TVector[int] tmp
-
-        tmp.assign(10, 42)
-        self.assertEqual(tmp.size(), 10)
-        self.assertEqual(tmp.front(), 42)
-        self.assertEqual(tmp.back(), 42)
-
-    def test_insert(self):
+ 
+        tmp.assign(10, 42) 
+        self.assertEqual(tmp.size(), 10) 
+        self.assertEqual(tmp.front(), 42) 
+        self.assertEqual(tmp.back(), 42) 
+ 
+    def test_insert(self): 
         cdef TVector[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(2)
-        tmp.push_back(3)
-
+        tmp.push_back(1) 
+        tmp.push_back(2) 
+        tmp.push_back(3) 
+ 
         cdef TVector[int] tmp2
-        tmp2.push_back(7)
-        tmp2.push_back(9)
-
-        tmp.insert(tmp.begin(), 8)
-        self.assertEqual([i for i in tmp], [8, 1, 2, 3])
-
-        tmp.insert(tmp.begin(), 2, 6)
-        self.assertEqual([i for i in tmp], [6, 6, 8, 1, 2, 3])
-
-        tmp.insert(tmp.begin(), tmp2.begin(), tmp2.end())
-        self.assertEqual([i for i in tmp], [7, 9, 6, 6, 8, 1, 2, 3])
-
-    def test_erase(self):
+        tmp2.push_back(7) 
+        tmp2.push_back(9) 
+ 
+        tmp.insert(tmp.begin(), 8) 
+        self.assertEqual([i for i in tmp], [8, 1, 2, 3]) 
+ 
+        tmp.insert(tmp.begin(), 2, 6) 
+        self.assertEqual([i for i in tmp], [6, 6, 8, 1, 2, 3]) 
+ 
+        tmp.insert(tmp.begin(), tmp2.begin(), tmp2.end()) 
+        self.assertEqual([i for i in tmp], [7, 9, 6, 6, 8, 1, 2, 3]) 
+ 
+    def test_erase(self): 
         cdef TVector[int] tmp
-        tmp.push_back(1)
-        tmp.push_back(2)
-        tmp.push_back(3)
-        tmp.push_back(4)
-
-        tmp.erase(tmp.begin() + 1)
-        self.assertEqual([i for i in tmp], [1, 3, 4])
-
-        tmp.erase(tmp.begin(), tmp.begin() + 2)
-        self.assertEqual([i for i in tmp], [4])
-
-    def test_convert(self):
-        src = ['foo', 'bar', 'baz']
-        self.assertEqual(_check_convert(src), src)
-
-        bad_src = ['foo', 42]
-        with self.assertRaises(TypeError):
-            _check_convert(bad_src)
+        tmp.push_back(1) 
+        tmp.push_back(2) 
+        tmp.push_back(3) 
+        tmp.push_back(4) 
+ 
+        tmp.erase(tmp.begin() + 1) 
+        self.assertEqual([i for i in tmp], [1, 3, 4]) 
+ 
+        tmp.erase(tmp.begin(), tmp.begin() + 2) 
+        self.assertEqual([i for i in tmp], [4]) 
+ 
+    def test_convert(self): 
+        src = ['foo', 'bar', 'baz'] 
+        self.assertEqual(_check_convert(src), src) 
+ 
+        bad_src = ['foo', 42] 
+        with self.assertRaises(TypeError): 
+            _check_convert(bad_src)