Restoring authorship annotation for <yazevnul@yandex-team.ru>. Commit 1 of 2.

38 files changed, 1195 insertions, 1195 deletions

diff --git a/util/string/ascii.h b/util/string/ascii.h
index 10344384d3..9c2c090df1 100644
--- a/util/string/ascii.h
+++ b/util/string/ascii.h
@@ -60,7 +60,7 @@ namespace NPrivate {
 #endif
 }
 
-constexpr bool IsAscii(const int c) noexcept {
+constexpr bool IsAscii(const int c) noexcept { 
     return !(c & ~0x7f);
 }
 
diff --git a/util/string/ascii_ut.cpp b/util/string/ascii_ut.cpp
index 89069fee50..94fea01a0e 100644
--- a/util/string/ascii_ut.cpp
+++ b/util/string/ascii_ut.cpp
@@ -3,8 +3,8 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-Y_UNIT_TEST_SUITE(TAsciiTest) {
-    Y_UNIT_TEST(TestAscii) {
+Y_UNIT_TEST_SUITE(TAsciiTest) { 
+    Y_UNIT_TEST(TestAscii) { 
         UNIT_ASSERT(IsAsciiDigit('3'));
         UNIT_ASSERT(!IsAsciiDigit('x'));
 
@@ -38,7 +38,7 @@ Y_UNIT_TEST_SUITE(TAsciiTest) {
         }
     }
 
-    Y_UNIT_TEST(Test1) {
+    Y_UNIT_TEST(Test1) { 
         for (int i = 128; i < 1000; ++i) {
             UNIT_ASSERT(!IsAsciiHex(i));
             UNIT_ASSERT(!IsAsciiSpace(i));
@@ -62,7 +62,7 @@ Y_UNIT_TEST_SUITE(TAsciiTest) {
         }
     }
 
-    Y_UNIT_TEST(CompareTest) {
+    Y_UNIT_TEST(CompareTest) { 
         UNIT_ASSERT(AsciiEqualsIgnoreCase("qqq", "qQq"));
         UNIT_ASSERT(AsciiEqualsIgnoreCase("qqq", TStringBuf("qQq")));
         TString qq = "qq";
diff --git a/util/string/benchmark/float_to_string/main.cpp b/util/string/benchmark/float_to_string/main.cpp
index 1c7c0684a3..c15b6009ad 100644
--- a/util/string/benchmark/float_to_string/main.cpp
+++ b/util/string/benchmark/float_to_string/main.cpp
@@ -1,253 +1,253 @@
 #include <library/cpp/testing/benchmark/bench.h>
-
-#include <util/generic/singleton.h>
-#include <util/generic/vector.h>
-#include <util/generic/xrange.h>
-#include <util/generic/ymath.h>
-#include <util/random/fast.h>
-#include <util/string/cast.h>
-#include <util/string/printf.h>
-
-#include <limits>
-
-#include <cmath>
-
-/* Please be careful before making any decisions based on this benchmark.
- *
- * Only `Sprintf("%.<decimals>f", x)` and `FloatToString(x, PREC_POINT_DIGITS, decimals` produce
- * equal results in general case. However, results for cases when x \in [0, 1) must be equal for
- * both `Sprintf` and `FloatToString`.
- *
- * Read more about formatting in STL [1, 2] and Yandex Util formatting [3]
- *
- * [1] http://www.cplusplus.com/reference/cstdio/printf/
- * [2] http://en.cppreference.com/w/c/io/fprintf
- * [3] https://a.yandex-team.ru/arc/trunk/arcadia/util/string/cast.h?rev=2432660#L29
- */
-
-namespace {
-    template <typename T>
-    struct TExample {
-        T Value{};
-        int DigitsCount{};
-    };
-
-    template <typename T, size_t N>
-    struct TExamplesHolder {
+ 
+#include <util/generic/singleton.h> 
+#include <util/generic/vector.h> 
+#include <util/generic/xrange.h> 
+#include <util/generic/ymath.h> 
+#include <util/random/fast.h> 
+#include <util/string/cast.h> 
+#include <util/string/printf.h> 
+ 
+#include <limits> 
+ 
+#include <cmath> 
+ 
+/* Please be careful before making any decisions based on this benchmark. 
+ * 
+ * Only `Sprintf("%.<decimals>f", x)` and `FloatToString(x, PREC_POINT_DIGITS, decimals` produce 
+ * equal results in general case. However, results for cases when x \in [0, 1) must be equal for 
+ * both `Sprintf` and `FloatToString`. 
+ * 
+ * Read more about formatting in STL [1, 2] and Yandex Util formatting [3] 
+ * 
+ * [1] http://www.cplusplus.com/reference/cstdio/printf/ 
+ * [2] http://en.cppreference.com/w/c/io/fprintf 
+ * [3] https://a.yandex-team.ru/arc/trunk/arcadia/util/string/cast.h?rev=2432660#L29 
+ */ 
+ 
+namespace { 
+    template <typename T> 
+    struct TExample { 
+        T Value{}; 
+        int DigitsCount{}; 
+    }; 
+ 
+    template <typename T, size_t N> 
+    struct TExamplesHolder { 
         TVector<TExample<T>> Examples;
-
-        TExamplesHolder()
+ 
+        TExamplesHolder() 
             : Examples(N)
         {
-            TFastRng<ui64> prng{N * sizeof(T) * 42};
-            for (auto& x : Examples) {
-                x.Value = prng.GenRandReal4() + prng.Uniform(Max<ui16>());
-                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
-            }
-        }
-    };
-
-    template <typename T, size_t N>
-    struct TNearZeroExamplesHolder {
+            TFastRng<ui64> prng{N * sizeof(T) * 42}; 
+            for (auto& x : Examples) { 
+                x.Value = prng.GenRandReal4() + prng.Uniform(Max<ui16>()); 
+                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1); 
+            } 
+        } 
+    }; 
+ 
+    template <typename T, size_t N> 
+    struct TNearZeroExamplesHolder { 
         TVector<TExample<T>> Examples;
-
-        TNearZeroExamplesHolder()
+ 
+        TNearZeroExamplesHolder() 
             : Examples(N)
         {
-            TFastRng<ui64> prng{N * sizeof(T) * 42};
-            for (auto& x : Examples) {
-                x.Value = prng.GenRandReal4();
-                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
-            }
-        }
-    };
-}
-
-static const char* FORMAT_FIXED[] = {
-    "%.0f",
-    "%.1f",
-    "%.2f",
-    "%.3f",
-    "%.4f",
-    "%.5f",
-    "%.6f",
-    "%.7f",
-    "%.8f",
-    "%.9f",
-    "%.10f",
-    "%.11f",
-    "%.12f",
-    "%.13f",
-    "%.14f",
-    "%.15f",
-    "%.16f",
-    "%.17f",
-};
-
-static const char* FORMAT_SIGNIFICANT[] = {
-    "%.0g",
-    "%.1g",
-    "%.2g",
-    "%.3g",
-    "%.4g",
-    "%.5g",
-    "%.6g",
-    "%.7g",
-    "%.8g",
-    "%.9g",
-    "%.10g",
-    "%.11g",
-    "%.12g",
-    "%.13g",
-    "%.14g",
-    "%.15g",
-    "%.16g",
-    "%.17g",
-};
-
-#define DEFINE_BENCHMARK(type, count)                                                                \
-    Y_CPU_BENCHMARK(SprintfAuto_##type##_##count, iface) {                                           \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
-                /* than FloatToString(e.Value) */                                                    \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(FloatToStringAuto_##type##_##count, iface) {                                     \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(SprintfFixed_##type##_##count, iface) {                                          \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(FloatToStringFixed_##type##_##count, iface) {                                    \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(SprintfSignificant_##type##_##count, iface) {                                    \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(FloatToStringSignificant_##type##_##count, iface) {                              \
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroSprintfAuto_##type##_##count, iface) {                                   \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
-                /* than FloatToString(e.Value) */                                                    \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroFloatToStringAuto_##type##_##count, iface) {                             \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroSprintfFixed_##type##_##count, iface) {                                  \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroFloatToStringFixed_##type##_##count, iface) {                            \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroSprintfSignificant_##type##_##count, iface) {                            \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
-                                                                                                     \
-    Y_CPU_BENCHMARK(NearZeroFloatToStringSignificant_##type##_##count, iface) {                      \
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
-        for (const auto i : xrange(iface.Iterations())) {                                            \
-            Y_UNUSED(i);                                                                             \
-            for (const auto e : examples) {                                                          \
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
-            }                                                                                        \
-        }                                                                                            \
-    }
-
-DEFINE_BENCHMARK(float, 1);
-DEFINE_BENCHMARK(float, 2);
-DEFINE_BENCHMARK(float, 4);
-DEFINE_BENCHMARK(float, 8);
-DEFINE_BENCHMARK(float, 16);
-DEFINE_BENCHMARK(float, 32);
-DEFINE_BENCHMARK(float, 64);
-DEFINE_BENCHMARK(float, 128);
-DEFINE_BENCHMARK(float, 256);
-
-DEFINE_BENCHMARK(double, 1);
-DEFINE_BENCHMARK(double, 2);
-DEFINE_BENCHMARK(double, 4);
-DEFINE_BENCHMARK(double, 8);
-DEFINE_BENCHMARK(double, 16);
-DEFINE_BENCHMARK(double, 32);
-DEFINE_BENCHMARK(double, 64);
-DEFINE_BENCHMARK(double, 128);
-DEFINE_BENCHMARK(double, 256);
-
-#undef DEFINE_BENCHMARK
+            TFastRng<ui64> prng{N * sizeof(T) * 42}; 
+            for (auto& x : Examples) { 
+                x.Value = prng.GenRandReal4(); 
+                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1); 
+            } 
+        } 
+    }; 
+} 
+ 
+static const char* FORMAT_FIXED[] = { 
+    "%.0f", 
+    "%.1f", 
+    "%.2f", 
+    "%.3f", 
+    "%.4f", 
+    "%.5f", 
+    "%.6f", 
+    "%.7f", 
+    "%.8f", 
+    "%.9f", 
+    "%.10f", 
+    "%.11f", 
+    "%.12f", 
+    "%.13f", 
+    "%.14f", 
+    "%.15f", 
+    "%.16f", 
+    "%.17f", 
+}; 
+ 
+static const char* FORMAT_SIGNIFICANT[] = { 
+    "%.0g", 
+    "%.1g", 
+    "%.2g", 
+    "%.3g", 
+    "%.4g", 
+    "%.5g", 
+    "%.6g", 
+    "%.7g", 
+    "%.8g", 
+    "%.9g", 
+    "%.10g", 
+    "%.11g", 
+    "%.12g", 
+    "%.13g", 
+    "%.14g", 
+    "%.15g", 
+    "%.16g", 
+    "%.17g", 
+}; 
+ 
+#define DEFINE_BENCHMARK(type, count)                                                                \ 
+    Y_CPU_BENCHMARK(SprintfAuto_##type##_##count, iface) {                                           \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \ 
+                /* than FloatToString(e.Value) */                                                    \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(FloatToStringAuto_##type##_##count, iface) {                                     \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(SprintfFixed_##type##_##count, iface) {                                          \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(FloatToStringFixed_##type##_##count, iface) {                                    \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(SprintfSignificant_##type##_##count, iface) {                                    \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(FloatToStringSignificant_##type##_##count, iface) {                              \ 
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroSprintfAuto_##type##_##count, iface) {                                   \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \ 
+                /* than FloatToString(e.Value) */                                                    \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroFloatToStringAuto_##type##_##count, iface) {                             \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroSprintfFixed_##type##_##count, iface) {                                  \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroFloatToStringFixed_##type##_##count, iface) {                            \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroSprintfSignificant_##type##_##count, iface) {                            \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    }                                                                                                \ 
+                                                                                                     \ 
+    Y_CPU_BENCHMARK(NearZeroFloatToStringSignificant_##type##_##count, iface) {                      \ 
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
+        for (const auto i : xrange(iface.Iterations())) {                                            \ 
+            Y_UNUSED(i);                                                                             \ 
+            for (const auto e : examples) {                                                          \ 
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \ 
+            }                                                                                        \ 
+        }                                                                                            \ 
+    } 
+ 
+DEFINE_BENCHMARK(float, 1); 
+DEFINE_BENCHMARK(float, 2); 
+DEFINE_BENCHMARK(float, 4); 
+DEFINE_BENCHMARK(float, 8); 
+DEFINE_BENCHMARK(float, 16); 
+DEFINE_BENCHMARK(float, 32); 
+DEFINE_BENCHMARK(float, 64); 
+DEFINE_BENCHMARK(float, 128); 
+DEFINE_BENCHMARK(float, 256); 
+ 
+DEFINE_BENCHMARK(double, 1); 
+DEFINE_BENCHMARK(double, 2); 
+DEFINE_BENCHMARK(double, 4); 
+DEFINE_BENCHMARK(double, 8); 
+DEFINE_BENCHMARK(double, 16); 
+DEFINE_BENCHMARK(double, 32); 
+DEFINE_BENCHMARK(double, 64); 
+DEFINE_BENCHMARK(double, 128); 
+DEFINE_BENCHMARK(double, 256); 
+ 
+#undef DEFINE_BENCHMARK 
diff --git a/util/string/benchmark/float_to_string/metrics/main.py b/util/string/benchmark/float_to_string/metrics/main.py
index e9d4b7ac1d..fdcfd71b0b 100644
--- a/util/string/benchmark/float_to_string/metrics/main.py
+++ b/util/string/benchmark/float_to_string/metrics/main.py
@@ -1,5 +1,5 @@
-import yatest.common as yc
-
-
-def test_export_metrics(metrics):
+import yatest.common as yc 
+ 
+ 
+def test_export_metrics(metrics): 
     metrics.set_benchmark(yc.execute_benchmark('util/string/benchmark/float_to_string/float_to_string', threads=8))
diff --git a/util/string/benchmark/float_to_string/metrics/ya.make b/util/string/benchmark/float_to_string/metrics/ya.make
index 4b8c4cc07d..3081301d1d 100644
--- a/util/string/benchmark/float_to_string/metrics/ya.make
+++ b/util/string/benchmark/float_to_string/metrics/ya.make
@@ -1,21 +1,21 @@
-OWNER(
-    yazevnul
+OWNER( 
+    yazevnul 
     g:util
-)
+) 
 SUBSCRIBER(g:util-subscribers)
-
+ 
 PY2TEST()
-
+ 
 SIZE(LARGE)
-
-TAG(
+ 
+TAG( 
     ya:force_sandbox
-    sb:intel_e5_2660v1
+    sb:intel_e5_2660v1 
     ya:fat
-)
-
+) 
+ 
 TEST_SRCS(main.py)
-
+ 
 DEPENDS(util/string/benchmark/float_to_string)
-
-END()
+ 
+END() 
diff --git a/util/string/benchmark/float_to_string/ya.make b/util/string/benchmark/float_to_string/ya.make
index 8136ad34f0..30955f3189 100644
--- a/util/string/benchmark/float_to_string/ya.make
+++ b/util/string/benchmark/float_to_string/ya.make
@@ -1,12 +1,12 @@
 OWNER(yazevnul)
-
+ 
 Y_BENCHMARK()
-
+ 
 # to minimize allocations overhead
 ALLOCATOR(B)
-
-SRCS(
-    main.cpp
-)
-
-END()
+ 
+SRCS( 
+    main.cpp 
+) 
+ 
+END() 
diff --git a/util/string/benchmark/subst_global/main.cpp b/util/string/benchmark/subst_global/main.cpp
index e0decfa042..c9b14a5211 100644
--- a/util/string/benchmark/subst_global/main.cpp
+++ b/util/string/benchmark/subst_global/main.cpp
@@ -1,203 +1,203 @@
 #include <library/cpp/testing/benchmark/bench.h>
-
-#include <util/generic/cast.h>
-#include <util/generic/singleton.h>
+ 
+#include <util/generic/cast.h> 
+#include <util/generic/singleton.h> 
 #include <util/generic/string.h>
-#include <util/generic/xrange.h>
-#include <util/random/fast.h>
-#include <util/string/cast.h>
-#include <util/string/subst.h>
-
-namespace {
-    template <size_t N, char What, char With>
-    struct TNoMatches {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+#include <util/generic/xrange.h> 
+#include <util/random/fast.h> 
+#include <util/string/cast.h> 
+#include <util/string/subst.h> 
+ 
+namespace { 
+    template <size_t N, char What, char With> 
+    struct TNoMatches { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TNoMatches() {
-            for (const auto dummy : xrange(N)) {
-                Y_UNUSED(dummy);
-                Str += WHAT + 1;
-            }
-        }
-    };
-
-    template <size_t N, char What, char With>
-    struct TOneMatchInTheBeginning {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TNoMatches() { 
+            for (const auto dummy : xrange(N)) { 
+                Y_UNUSED(dummy); 
+                Str += WHAT + 1; 
+            } 
+        } 
+    }; 
+ 
+    template <size_t N, char What, char With> 
+    struct TOneMatchInTheBeginning { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TOneMatchInTheBeginning() {
-            if (!N) {
-                return;
-            }
-
-            Str += WHAT;
-            if (N > 1) {
-                for (const auto dummy : xrange(N - 1)) {
-                    Y_UNUSED(dummy);
-                    Str += WHAT + 1;
-                }
-            }
-        }
-    };
-
-    template <size_t N, char What, char With>
-    struct TOneMatchInTheEnd {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TOneMatchInTheBeginning() { 
+            if (!N) { 
+                return; 
+            } 
+ 
+            Str += WHAT; 
+            if (N > 1) { 
+                for (const auto dummy : xrange(N - 1)) { 
+                    Y_UNUSED(dummy); 
+                    Str += WHAT + 1; 
+                } 
+            } 
+        } 
+    }; 
+ 
+    template <size_t N, char What, char With> 
+    struct TOneMatchInTheEnd { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TOneMatchInTheEnd() {
-            if (!N) {
-                return;
-            }
-
-            if (N > 1) {
-                for (const auto dummy : xrange(N - 1)) {
-                    Y_UNUSED(dummy);
-                    Str += WHAT + 1;
-                }
-            }
-            Str += WHAT;
-        }
-    };
-
-    template <size_t N, char What, char With>
-    struct TOneMatchInTheMiddle {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TOneMatchInTheEnd() { 
+            if (!N) { 
+                return; 
+            } 
+ 
+            if (N > 1) { 
+                for (const auto dummy : xrange(N - 1)) { 
+                    Y_UNUSED(dummy); 
+                    Str += WHAT + 1; 
+                } 
+            } 
+            Str += WHAT; 
+        } 
+    }; 
+ 
+    template <size_t N, char What, char With> 
+    struct TOneMatchInTheMiddle { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TOneMatchInTheMiddle() {
-            if (!N) {
-                return;
-            }
-
-            for (size_t i = 0; i < N / 2; ++i) {
-                Str += WHAT + 1;
-            }
-            Str += WHAT;
-            for (; Str.size() < N;) {
-                Str += WHAT + 1;
-            }
-        }
-    };
-
-    template <size_t N, char What, char With>
-    struct TFirstHalfMatches {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TOneMatchInTheMiddle() { 
+            if (!N) { 
+                return; 
+            } 
+ 
+            for (size_t i = 0; i < N / 2; ++i) { 
+                Str += WHAT + 1; 
+            } 
+            Str += WHAT; 
+            for (; Str.size() < N;) { 
+                Str += WHAT + 1; 
+            } 
+        } 
+    }; 
+ 
+    template <size_t N, char What, char With> 
+    struct TFirstHalfMatches { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TFirstHalfMatches() {
-            for (size_t i = 0; i < N / 2; ++i) {
-                Str += WHAT;
-            }
-            for (; Str.size() != N;) {
-                Str += WHAT + 1;
-            }
-        }
-    };
-
-    template <size_t N, char What, char With>
-    struct TSecondHalfMatches {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TFirstHalfMatches() { 
+            for (size_t i = 0; i < N / 2; ++i) { 
+                Str += WHAT; 
+            } 
+            for (; Str.size() != N;) { 
+                Str += WHAT + 1; 
+            } 
+        } 
+    }; 
+ 
+    template <size_t N, char What, char With> 
+    struct TSecondHalfMatches { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TSecondHalfMatches() {
-            for (size_t i = 0; i < N / 2; ++i) {
-                Str += WHAT + 1;
-            }
-            for (; Str.size() != N;) {
-                Str += WHAT;
-            }
-        }
-    };
-
-    template <size_t N, size_t K, char What, char With>
-    struct TEveryKth {
-        enum : char {
-            WHAT = What,
-            WITH = With
-        };
+ 
+        TSecondHalfMatches() { 
+            for (size_t i = 0; i < N / 2; ++i) { 
+                Str += WHAT + 1; 
+            } 
+            for (; Str.size() != N;) { 
+                Str += WHAT; 
+            } 
+        } 
+    }; 
+ 
+    template <size_t N, size_t K, char What, char With> 
+    struct TEveryKth { 
+        enum : char { 
+            WHAT = What, 
+            WITH = With 
+        }; 
         TString Str;
-
-        TEveryKth() {
-            TFastRng<ui64> prng{N * K * 101};
-            for (size_t i = 0; i < N; ++i) {
-                Str += (prng() % K) ? (WHAT + 1) : WHAT;
-            }
-        }
-    };
-}
-
-#define DEFINE_BENCHMARK(type, N)                                                                 \
-    Y_CPU_BENCHMARK(type##_##N, i) {                                                              \
-        using D = T##type<N, 'a', 'z'>;                                                           \
-        const auto& str = Default<D>().Str;                                                       \
-        for (const auto dummy : xrange(i.Iterations())) {                                         \
-            Y_UNUSED(dummy);                                                                      \
-            auto s = str;                                                                         \
+ 
+        TEveryKth() { 
+            TFastRng<ui64> prng{N * K * 101}; 
+            for (size_t i = 0; i < N; ++i) { 
+                Str += (prng() % K) ? (WHAT + 1) : WHAT; 
+            } 
+        } 
+    }; 
+} 
+ 
+#define DEFINE_BENCHMARK(type, N)                                                                 \ 
+    Y_CPU_BENCHMARK(type##_##N, i) {                                                              \ 
+        using D = T##type<N, 'a', 'z'>;                                                           \ 
+        const auto& str = Default<D>().Str;                                                       \ 
+        for (const auto dummy : xrange(i.Iterations())) {                                         \ 
+            Y_UNUSED(dummy);                                                                      \ 
+            auto s = str;                                                                         \ 
             NBench::Escape(s.data());                                                             \
-            Y_DO_NOT_OPTIMIZE_AWAY(SubstGlobal(s, ToUnderlying(D::WHAT), ToUnderlying(D::WITH))); \
-            NBench::Clobber();                                                                    \
-        }                                                                                         \
-    }
-
-#define DEFINE_RNG_BENCHMARK(N, K)                                                                \
-    Y_CPU_BENCHMARK(Random_##N##_##K, i) {                                                        \
-        using D = TEveryKth<N, K, 'a', 'z'>;                                                      \
-        const auto& str = Default<D>().Str;                                                       \
-        for (const auto dummy : xrange(i.Iterations())) {                                         \
-            Y_UNUSED(dummy);                                                                      \
-            auto s = str;                                                                         \
+            Y_DO_NOT_OPTIMIZE_AWAY(SubstGlobal(s, ToUnderlying(D::WHAT), ToUnderlying(D::WITH))); \ 
+            NBench::Clobber();                                                                    \ 
+        }                                                                                         \ 
+    } 
+ 
+#define DEFINE_RNG_BENCHMARK(N, K)                                                                \ 
+    Y_CPU_BENCHMARK(Random_##N##_##K, i) {                                                        \ 
+        using D = TEveryKth<N, K, 'a', 'z'>;                                                      \ 
+        const auto& str = Default<D>().Str;                                                       \ 
+        for (const auto dummy : xrange(i.Iterations())) {                                         \ 
+            Y_UNUSED(dummy);                                                                      \ 
+            auto s = str;                                                                         \ 
             NBench::Escape(s.data());                                                             \
-            Y_DO_NOT_OPTIMIZE_AWAY(SubstGlobal(s, ToUnderlying(D::WHAT), ToUnderlying(D::WITH))); \
-            NBench::Clobber();                                                                    \
-        }                                                                                         \
-    }
-
-DEFINE_BENCHMARK(NoMatches, 0)
-DEFINE_BENCHMARK(NoMatches, 1)
-DEFINE_BENCHMARK(NoMatches, 128)
-DEFINE_BENCHMARK(NoMatches, 4096)
-DEFINE_BENCHMARK(OneMatchInTheBeginning, 1)
-DEFINE_BENCHMARK(OneMatchInTheBeginning, 16)
-DEFINE_BENCHMARK(OneMatchInTheBeginning, 128)
-DEFINE_BENCHMARK(OneMatchInTheBeginning, 4096)
-DEFINE_BENCHMARK(OneMatchInTheEnd, 16)
-DEFINE_BENCHMARK(OneMatchInTheEnd, 128)
-DEFINE_BENCHMARK(OneMatchInTheEnd, 4096)
-DEFINE_BENCHMARK(OneMatchInTheMiddle, 16)
-DEFINE_BENCHMARK(OneMatchInTheMiddle, 128)
-DEFINE_BENCHMARK(OneMatchInTheMiddle, 4096)
-DEFINE_BENCHMARK(FirstHalfMatches, 16)
-DEFINE_BENCHMARK(FirstHalfMatches, 128)
-DEFINE_BENCHMARK(FirstHalfMatches, 4096)
-DEFINE_BENCHMARK(SecondHalfMatches, 16)
-DEFINE_BENCHMARK(SecondHalfMatches, 128)
-DEFINE_BENCHMARK(SecondHalfMatches, 4096)
-
-DEFINE_RNG_BENCHMARK(4096, 1)
-DEFINE_RNG_BENCHMARK(4096, 2)
-DEFINE_RNG_BENCHMARK(4096, 3)
-DEFINE_RNG_BENCHMARK(4096, 4)
-DEFINE_RNG_BENCHMARK(4096, 10)
-DEFINE_RNG_BENCHMARK(4096, 32)
-DEFINE_RNG_BENCHMARK(4096, 100)
+            Y_DO_NOT_OPTIMIZE_AWAY(SubstGlobal(s, ToUnderlying(D::WHAT), ToUnderlying(D::WITH))); \ 
+            NBench::Clobber();                                                                    \ 
+        }                                                                                         \ 
+    } 
+ 
+DEFINE_BENCHMARK(NoMatches, 0) 
+DEFINE_BENCHMARK(NoMatches, 1) 
+DEFINE_BENCHMARK(NoMatches, 128) 
+DEFINE_BENCHMARK(NoMatches, 4096) 
+DEFINE_BENCHMARK(OneMatchInTheBeginning, 1) 
+DEFINE_BENCHMARK(OneMatchInTheBeginning, 16) 
+DEFINE_BENCHMARK(OneMatchInTheBeginning, 128) 
+DEFINE_BENCHMARK(OneMatchInTheBeginning, 4096) 
+DEFINE_BENCHMARK(OneMatchInTheEnd, 16) 
+DEFINE_BENCHMARK(OneMatchInTheEnd, 128) 
+DEFINE_BENCHMARK(OneMatchInTheEnd, 4096) 
+DEFINE_BENCHMARK(OneMatchInTheMiddle, 16) 
+DEFINE_BENCHMARK(OneMatchInTheMiddle, 128) 
+DEFINE_BENCHMARK(OneMatchInTheMiddle, 4096) 
+DEFINE_BENCHMARK(FirstHalfMatches, 16) 
+DEFINE_BENCHMARK(FirstHalfMatches, 128) 
+DEFINE_BENCHMARK(FirstHalfMatches, 4096) 
+DEFINE_BENCHMARK(SecondHalfMatches, 16) 
+DEFINE_BENCHMARK(SecondHalfMatches, 128) 
+DEFINE_BENCHMARK(SecondHalfMatches, 4096) 
+ 
+DEFINE_RNG_BENCHMARK(4096, 1) 
+DEFINE_RNG_BENCHMARK(4096, 2) 
+DEFINE_RNG_BENCHMARK(4096, 3) 
+DEFINE_RNG_BENCHMARK(4096, 4) 
+DEFINE_RNG_BENCHMARK(4096, 10) 
+DEFINE_RNG_BENCHMARK(4096, 32) 
+DEFINE_RNG_BENCHMARK(4096, 100) 
diff --git a/util/string/benchmark/subst_global/metrics/main.py b/util/string/benchmark/subst_global/metrics/main.py
index 62f2f3d76d..8aa0501351 100644
--- a/util/string/benchmark/subst_global/metrics/main.py
+++ b/util/string/benchmark/subst_global/metrics/main.py
@@ -1,5 +1,5 @@
-import yatest.common as yc
-
-
-def test_export_metrics(metrics):
+import yatest.common as yc 
+ 
+ 
+def test_export_metrics(metrics): 
     metrics.set_benchmark(yc.execute_benchmark('util/string/benchmark/subst_global/subst_global', threads=8))
diff --git a/util/string/benchmark/subst_global/metrics/ya.make b/util/string/benchmark/subst_global/metrics/ya.make
index d8c30ad460..73757bebcb 100644
--- a/util/string/benchmark/subst_global/metrics/ya.make
+++ b/util/string/benchmark/subst_global/metrics/ya.make
@@ -1,21 +1,21 @@
-OWNER(
-    yazevnul
+OWNER( 
+    yazevnul 
     g:util
-)
+) 
 SUBSCRIBER(g:util-subscribers)
-
+ 
 PY2TEST()
-
+ 
 SIZE(LARGE)
-
-TAG(
+ 
+TAG( 
     ya:force_sandbox
-    sb:intel_e5_2660v1
+    sb:intel_e5_2660v1 
     ya:fat
-)
-
+) 
+ 
 TEST_SRCS(main.py)
-
+ 
 DEPENDS(util/string/benchmark/subst_global)
-
-END()
+ 
+END() 
diff --git a/util/string/benchmark/subst_global/ya.make b/util/string/benchmark/subst_global/ya.make
index 8136ad34f0..30955f3189 100644
--- a/util/string/benchmark/subst_global/ya.make
+++ b/util/string/benchmark/subst_global/ya.make
@@ -1,12 +1,12 @@
 OWNER(yazevnul)
-
+ 
 Y_BENCHMARK()
-
+ 
 # to minimize allocations overhead
 ALLOCATOR(B)
-
-SRCS(
-    main.cpp
-)
-
-END()
+ 
+SRCS( 
+    main.cpp 
+) 
+ 
+END() 
diff --git a/util/string/benchmark/ya.make b/util/string/benchmark/ya.make
index 266b53c7b3..09b112034d 100644
--- a/util/string/benchmark/ya.make
+++ b/util/string/benchmark/ya.make
@@ -1,16 +1,16 @@
-OWNER(
+OWNER( 
     g:util
-    yazevnul
-)
+    yazevnul 
+) 
 SUBSCRIBER(g:util-subscribers)
-
-RECURSE(
+ 
+RECURSE( 
     ascii
     cast
-    float_to_string
-    float_to_string/metrics
+    float_to_string 
+    float_to_string/metrics 
     join
     join/metrics
-    subst_global
-    subst_global/metrics
-)
+    subst_global 
+    subst_global/metrics 
+) 
diff --git a/util/string/builder.cpp b/util/string/builder.cpp
index a3821d3399..e1f696c931 100644
--- a/util/string/builder.cpp
+++ b/util/string/builder.cpp
@@ -3,6 +3,6 @@
 #include <util/stream/output.h>
 
 template <>
-void Out<TStringBuilder>(IOutputStream& os, const TStringBuilder& sb) {
+void Out<TStringBuilder>(IOutputStream& os, const TStringBuilder& sb) { 
     os << static_cast<const TString&>(sb);
 }
diff --git a/util/string/builder_ut.cpp b/util/string/builder_ut.cpp
index 22def683ec..49d1882266 100644
--- a/util/string/builder_ut.cpp
+++ b/util/string/builder_ut.cpp
@@ -17,19 +17,19 @@ struct TClassWithStreamOperator {
     }
 };
 
-IOutputStream& operator<<(IOutputStream& out, const TClassWithStreamOperator& value) {
+IOutputStream& operator<<(IOutputStream& out, const TClassWithStreamOperator& value) { 
     return out << value.Id << " " << value.Name;
 }
 
-Y_UNIT_TEST_SUITE(TStringBuilderTest) {
-    Y_UNIT_TEST(TestStringBuilder) {
+Y_UNIT_TEST_SUITE(TStringBuilderTest) { 
+    Y_UNIT_TEST(TestStringBuilder) { 
         TestEquals("", TStringBuilder());
         TestEquals("a", TStringBuilder() << "a");
         TestEquals("a1", TStringBuilder() << "a" << 1);
         TestEquals("value: 123 name", TStringBuilder() << "value: " << TClassWithStreamOperator(123, "name"));
     }
 
-    Y_UNIT_TEST(TestStringBuilderOut) {
+    Y_UNIT_TEST(TestStringBuilderOut) { 
         TString s;
         TStringOutput out(s);
         TStringBuilder sb;
@@ -38,7 +38,7 @@ Y_UNIT_TEST_SUITE(TStringBuilderTest) {
         TestEquals("a", s);
     }
 
-    Y_UNIT_TEST(TestStringBuilderRValue) {
+    Y_UNIT_TEST(TestStringBuilderRValue) { 
         struct TRValueAcceptTester {
             static bool IsRValue(const TString&) {
                 return false;
diff --git a/util/string/cast.cpp b/util/string/cast.cpp
index aa1e65a8e9..d1165cade1 100644
--- a/util/string/cast.cpp
+++ b/util/string/cast.cpp
@@ -30,123 +30,123 @@ using double_conversion::StringToDoubleConverter;
  * ------------------------------ formatters ------------------------------
  */
 
-namespace {
+namespace { 
     constexpr char IntToChar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-    static_assert(Y_ARRAY_SIZE(IntToChar) == 16, "expect Y_ARRAY_SIZE(IntToChar) == 16");
-
+ 
+    static_assert(Y_ARRAY_SIZE(IntToChar) == 16, "expect Y_ARRAY_SIZE(IntToChar) == 16"); 
+ 
     // clang-format off
     constexpr int LetterToIntMap[] = {
-        20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 20, 0, 1,
-        2, 3, 4, 5, 6, 7, 8, 9, 20, 20,
-        20, 20, 20, 20, 20, 10, 11, 12, 13, 14,
-        15, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-        20, 20, 20, 20, 20, 20, 20, 10, 11, 12,
-        13, 14, 15,
-    };
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 20, 0, 1, 
+        2, 3, 4, 5, 6, 7, 8, 9, 20, 20, 
+        20, 20, 20, 20, 20, 10, 11, 12, 13, 14, 
+        15, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+        20, 20, 20, 20, 20, 20, 20, 10, 11, 12, 
+        13, 14, 15, 
+    }; 
     // clang-format on
-
-    template <class T>
+ 
+    template <class T> 
     std::enable_if_t<std::is_signed<T>::value, std::make_unsigned_t<T>> NegateNegativeSigned(T value) noexcept {
         return std::make_unsigned_t<T>(-(value + 1)) + std::make_unsigned_t<T>(1);
     }
 
-    template <class T>
+    template <class T> 
     std::enable_if_t<std::is_unsigned<T>::value, std::make_unsigned_t<T>> NegateNegativeSigned(T) noexcept {
         Y_UNREACHABLE();
-    }
+    } 
 
     template <class T>
     std::make_signed_t<T> NegatePositiveSigned(T value) noexcept {
         return value > 0 ? (-std::make_signed_t<T>(value - 1) - 1) : 0;
     }
 
-    template <class T, unsigned base, class TChar>
-    struct TBasicIntFormatter {
-        static_assert(1 < base && base < 17, "expect 1 < base && base < 17");
+    template <class T, unsigned base, class TChar> 
+    struct TBasicIntFormatter { 
+        static_assert(1 < base && base < 17, "expect 1 < base && base < 17"); 
         static_assert(std::is_unsigned<T>::value, "TBasicIntFormatter can only handle unsigned integers.");
 
-        static inline size_t Format(T value, TChar* buf, size_t len) {
+        static inline size_t Format(T value, TChar* buf, size_t len) { 
             Y_ENSURE(len, TStringBuf("zero length"));
 
-            TChar* tmp = buf;
-
-            do {
+            TChar* tmp = buf; 
+ 
+            do { 
                 // divide only once, do not use mod
                 const T nextVal = static_cast<T>(value / base);
                 *tmp++ = IntToChar[base == 2 || base == 4 || base == 8 || base == 16 ? value & (base - 1) : value - base * nextVal];
                 value = nextVal;
-            } while (value && --len);
-
+            } while (value && --len); 
+ 
             Y_ENSURE(!value, TStringBuf("not enough room in buffer"));
-
-            const size_t result = tmp - buf;
-
-            --tmp;
-
-            while (buf < tmp) {
-                TChar c = *buf;
-
-                *buf = *tmp;
-                *tmp = c;
-                ++buf;
-                --tmp;
-            }
-
-            return result;
+ 
+            const size_t result = tmp - buf; 
+ 
+            --tmp; 
+ 
+            while (buf < tmp) { 
+                TChar c = *buf; 
+ 
+                *buf = *tmp; 
+                *tmp = c; 
+                ++buf; 
+                --tmp; 
+            } 
+ 
+            return result; 
         }
-    };
+    }; 
 
-    template <class T, unsigned base, class TChar>
-    struct TIntFormatter {
-        static_assert(1 < base && base < 17, "expect 1 < base && base < 17");
+    template <class T, unsigned base, class TChar> 
+    struct TIntFormatter { 
+        static_assert(1 < base && base < 17, "expect 1 < base && base < 17"); 
         static_assert(std::is_integral<T>::value, "T must be an integral type.");
 
-        static inline size_t Format(T value, TChar* buf, size_t len) {
+        static inline size_t Format(T value, TChar* buf, size_t len) { 
             using TUFmt = TBasicIntFormatter<std::make_unsigned_t<T>, base, TChar>;
-
+ 
             if (std::is_signed<T>::value && value < 0) {
                 Y_ENSURE(len >= 2, TStringBuf("not enough room in buffer"));
-
-                *buf = '-';
+ 
+                *buf = '-'; 
 
                 return 1 + TUFmt::Format(NegateNegativeSigned(value), buf + 1, len - 1);
-            }
-
+            } 
+ 
             return TUFmt::Format(value, buf, len);
         }
-    };
+    }; 
 
-    template <class T>
-    struct TFltModifiers;
+    template <class T> 
+    struct TFltModifiers; 
 
-    template <class T, int base, class TChar>
+    template <class T, int base, class TChar> 
     Y_NO_INLINE size_t FormatInt(T value, TChar* buf, size_t len) {
-        return TIntFormatter<T, base, TChar>::Format(value, buf, len);
-    }
+        return TIntFormatter<T, base, TChar>::Format(value, buf, len); 
+    } 
 
-    template <class T>
+    template <class T> 
     inline size_t FormatFlt(T t, char* buf, size_t len) {
-        const int ret = snprintf(buf, len, TFltModifiers<T>::ModifierWrite, t);
+        const int ret = snprintf(buf, len, TFltModifiers<T>::ModifierWrite, t); 
 
         Y_ENSURE(ret >= 0 && (size_t)ret <= len, TStringBuf("cannot format float"));
 
-        return (size_t)ret;
+        return (size_t)ret; 
     }
 
-    enum EParseStatus {
-        PS_OK = 0,
-        PS_EMPTY_STRING,
-        PS_PLUS_STRING,
-        PS_MINUS_STRING,
-        PS_BAD_SYMBOL,
-        PS_OVERFLOW,
-    };
+    enum EParseStatus { 
+        PS_OK = 0, 
+        PS_EMPTY_STRING, 
+        PS_PLUS_STRING, 
+        PS_MINUS_STRING, 
+        PS_BAD_SYMBOL, 
+        PS_OVERFLOW, 
+    }; 
 
     constexpr ui8 SAFE_LENS[4][17] = {
         {0, 0, 7, 5, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1},
@@ -177,19 +177,19 @@ namespace {
         return (c >= '0') && ((*digit = (c - '0')) < BASE);
     }
 
-    template <class T, unsigned base, class TChar>
-    struct TBasicIntParser {
-        static_assert(1 < base && base < 17, "Expect 1 < base && base < 17.");
+    template <class T, unsigned base, class TChar> 
+    struct TBasicIntParser { 
+        static_assert(1 < base && base < 17, "Expect 1 < base && base < 17."); 
         static_assert(std::is_unsigned<T>::value, "TBasicIntParser can only handle unsigned integers.");
-
+ 
         enum : unsigned {
             BASE_POW_2 = base * base,
         };
 
         static inline EParseStatus Parse(const TChar** ppos, const TChar* end, T max, T* target) noexcept {
-            Y_ASSERT(*ppos != end); /* This check should be somewhere up the stack. */
+            Y_ASSERT(*ppos != end); /* This check should be somewhere up the stack. */ 
             const size_t maxSafeLen = SAFE_LENS[ConstLog2(sizeof(T))][base];
-
+ 
             // can parse without overflow
             if (size_t(end - *ppos) <= maxSafeLen) {
                 T result;
@@ -205,7 +205,7 @@ namespace {
         }
 
         static inline bool ParseFast(const TChar* pos, const TChar* end, T* target) noexcept {
-            T result = T();
+            T result = T(); 
             T d1;
             T d2;
 
@@ -229,164 +229,164 @@ namespace {
 
         static inline EParseStatus ParseSlow(const TChar** ppos, const TChar* end, T max, T* target) noexcept {
             T result = T();
-            T preMulMax = max / base;
-            const TChar* pos = *ppos;
-
-            while (pos != end) {
-                T digit;
+            T preMulMax = max / base; 
+            const TChar* pos = *ppos; 
+ 
+            while (pos != end) { 
+                T digit; 
 
                 if (!CharToDigit<base>(*pos, &digit)) {
-                    *ppos = pos;
-
-                    return PS_BAD_SYMBOL;
-                }
-
-                if (result > preMulMax) {
-                    return PS_OVERFLOW;
-                }
-
-                result *= base;
-
-                if (result > max - digit) {
-                    return PS_OVERFLOW;
-                }
-
-                result += digit;
-                pos++;
-            }
-
-            *target = result;
-
-            return PS_OK;
-        }
+                    *ppos = pos; 
+
+                    return PS_BAD_SYMBOL; 
+                } 
+ 
+                if (result > preMulMax) { 
+                    return PS_OVERFLOW; 
+                } 
+ 
+                result *= base; 
+ 
+                if (result > max - digit) { 
+                    return PS_OVERFLOW; 
+                } 
+ 
+                result += digit; 
+                pos++; 
+            } 
+ 
+            *target = result; 
+
+            return PS_OK; 
+        } 
     };
 
-    template <class T>
-    struct TBounds {
-        T PositiveMax;
-        T NegativeMax;
-    };
+    template <class T> 
+    struct TBounds { 
+        T PositiveMax; 
+        T NegativeMax; 
+    }; 
 
-    template <class T, unsigned base, class TChar>
-    struct TIntParser {
-        static_assert(1 < base && base < 17, "Expect 1 < base && base < 17.");
+    template <class T, unsigned base, class TChar> 
+    struct TIntParser { 
+        static_assert(1 < base && base < 17, "Expect 1 < base && base < 17."); 
         static_assert(std::is_integral<T>::value, "T must be an integral type.");
 
-        enum {
+        enum { 
             IsSigned = std::is_signed<T>::value
-        };
-
-        using TUnsigned = std::make_unsigned_t<T>;
-
-        static inline EParseStatus Parse(const TChar** ppos, const TChar* end, const TBounds<TUnsigned>& bounds, T* target) {
-            const TChar* pos = *ppos;
-            if (pos == end) {
-                return PS_EMPTY_STRING;
+        }; 
+ 
+        using TUnsigned = std::make_unsigned_t<T>; 
+ 
+        static inline EParseStatus Parse(const TChar** ppos, const TChar* end, const TBounds<TUnsigned>& bounds, T* target) { 
+            const TChar* pos = *ppos; 
+            if (pos == end) { 
+                return PS_EMPTY_STRING; 
             }
 
             bool negative = false;
-            TUnsigned max;
-            if (*pos == '+') {
-                pos++;
-                max = bounds.PositiveMax;
-
-                if (pos == end) {
-                    return PS_PLUS_STRING;
-                }
-            } else if (IsSigned && *pos == '-') {
-                pos++;
-                max = bounds.NegativeMax;
-                negative = true;
-
-                if (pos == end) {
-                    return PS_MINUS_STRING;
-                }
-            } else {
-                max = bounds.PositiveMax;
-            }
-
-            TUnsigned result;
-            EParseStatus error = TBasicIntParser<TUnsigned, base, TChar>::Parse(&pos, end, max, &result);
-            if (error != PS_OK) {
+            TUnsigned max; 
+            if (*pos == '+') { 
+                pos++; 
+                max = bounds.PositiveMax; 
+ 
+                if (pos == end) { 
+                    return PS_PLUS_STRING; 
+                } 
+            } else if (IsSigned && *pos == '-') { 
+                pos++; 
+                max = bounds.NegativeMax; 
+                negative = true; 
+ 
+                if (pos == end) { 
+                    return PS_MINUS_STRING; 
+                } 
+            } else { 
+                max = bounds.PositiveMax; 
+            } 
+ 
+            TUnsigned result; 
+            EParseStatus error = TBasicIntParser<TUnsigned, base, TChar>::Parse(&pos, end, max, &result); 
+            if (error != PS_OK) { 
                 *ppos = pos;
-                return error;
-            }
-
-            if (IsSigned) {
+                return error; 
+            } 
+ 
+            if (IsSigned) { 
                 *target = negative ? NegatePositiveSigned(result) : static_cast<T>(result);
-            } else {
-                *target = result;
-            }
-            return PS_OK;
+            } else { 
+                *target = result; 
+            } 
+            return PS_OK; 
         }
-    };
+    }; 
 
-    template <class TChar>
+    template <class TChar> 
     [[noreturn]] static Y_NO_INLINE void ThrowParseError(EParseStatus status, const TChar* data, size_t len, const TChar* pos) {
-        Y_ASSERT(status != PS_OK);
-
+        Y_ASSERT(status != PS_OK); 
+ 
         typedef TBasicString<TChar> TStringType;
-
-        switch (status) {
-            case PS_EMPTY_STRING:
+ 
+        switch (status) { 
+            case PS_EMPTY_STRING: 
                 ythrow TFromStringException() << TStringBuf("Cannot parse empty string as number. ");
-            case PS_PLUS_STRING:
+            case PS_PLUS_STRING: 
                 ythrow TFromStringException() << TStringBuf("Cannot parse string \"+\" as number. ");
-            case PS_MINUS_STRING:
+            case PS_MINUS_STRING: 
                 ythrow TFromStringException() << TStringBuf("Cannot parse string \"-\" as number. ");
-            case PS_BAD_SYMBOL:
+            case PS_BAD_SYMBOL: 
                 ythrow TFromStringException() << TStringBuf("Unexpected symbol \"") << EscapeC(*pos) << TStringBuf("\" at pos ") << (pos - data) << TStringBuf(" in string ") << TStringType(data, len).Quote() << TStringBuf(". ");
-            case PS_OVERFLOW:
+            case PS_OVERFLOW: 
                 ythrow TFromStringException() << TStringBuf("Integer overflow in string ") << TStringType(data, len).Quote() << TStringBuf(". ");
-            default:
+            default: 
                 ythrow yexception() << TStringBuf("Unknown error code in string converter. ");
-        }
+        } 
     }
 
-    template <typename T, typename TUnsigned, int base, typename TChar>
+    template <typename T, typename TUnsigned, int base, typename TChar> 
     Y_NO_INLINE T ParseInt(const TChar* data, size_t len, const TBounds<TUnsigned>& bounds) {
-        T result;
-        const TChar* pos = data;
-        EParseStatus status = TIntParser<T, base, TChar>::Parse(&pos, pos + len, bounds, &result);
-
-        if (status == PS_OK) {
-            return result;
-        } else {
-            ThrowParseError(status, data, len, pos);
-        }
-    }
-
-    template <typename T, typename TUnsigned, int base, typename TChar>
+        T result; 
+        const TChar* pos = data; 
+        EParseStatus status = TIntParser<T, base, TChar>::Parse(&pos, pos + len, bounds, &result); 
+
+        if (status == PS_OK) { 
+            return result; 
+        } else { 
+            ThrowParseError(status, data, len, pos); 
+        } 
+    } 
+
+    template <typename T, typename TUnsigned, int base, typename TChar> 
     Y_NO_INLINE bool TryParseInt(const TChar* data, size_t len, const TBounds<TUnsigned>& bounds, T* result) {
-        return TIntParser<T, base, TChar>::Parse(&data, data + len, bounds, result) == PS_OK;
-    }
-
-    template <class T>
+        return TIntParser<T, base, TChar>::Parse(&data, data + len, bounds, result) == PS_OK; 
+    } 
+ 
+    template <class T> 
     inline T ParseFlt(const char* data, size_t len) {
-        /*
-         * TODO
-         */
-
-        if (len > 256) {
-            len = 256;
-        }
-
-        char* c = (char*)alloca(len + 1);
-        memcpy(c, data, len);
-        c[len] = 0;
-
-        T ret;
-        char ec;
-
-        // try to read a value and an extra character in order to catch cases when
-        // the string start with a valid float but is followed by unexpected characters
-        if (sscanf(c, TFltModifiers<T>::ModifierReadAndChar, &ret, &ec) == 1) {
-            return ret;
-        }
-
+        /* 
+         * TODO 
+         */ 
+ 
+        if (len > 256) { 
+            len = 256; 
+        } 
+ 
+        char* c = (char*)alloca(len + 1); 
+        memcpy(c, data, len); 
+        c[len] = 0; 
+ 
+        T ret; 
+        char ec; 
+ 
+        // try to read a value and an extra character in order to catch cases when 
+        // the string start with a valid float but is followed by unexpected characters 
+        if (sscanf(c, TFltModifiers<T>::ModifierReadAndChar, &ret, &ec) == 1) { 
+            return ret; 
+        } 
+ 
         ythrow TFromStringException() << TStringBuf("cannot parse float(") << TStringBuf(data, len) << TStringBuf(")");
-    }
-
+    } 
+ 
 #define DEF_FLT_MOD(type, modifierWrite, modifierRead)                    \
     template <>                                                           \
     struct TFltModifiers<type> {                                          \
@@ -397,14 +397,14 @@ namespace {
     const char* const TFltModifiers<type>::ModifierWrite = modifierWrite; \
     const char* const TFltModifiers<type>::ModifierReadAndChar = modifierRead "%c";
 
-    DEF_FLT_MOD(long double, "%.10Lg", "%Lg")
+    DEF_FLT_MOD(long double, "%.10Lg", "%Lg") 
 
 #undef DEF_FLT_MOD
 
-    /* The following constants are initialized in terms of <climits> constants to make
-     * sure they go into binary as actual values and there is no associated
-     * initialization code.
-     * */
+    /* The following constants are initialized in terms of <climits> constants to make 
+     * sure they go into binary as actual values and there is no associated 
+     * initialization code. 
+     * */ 
     constexpr TBounds<ui64> bSBounds = {static_cast<ui64>(SCHAR_MAX), static_cast<ui64>(UCHAR_MAX - SCHAR_MAX)};
     constexpr TBounds<ui64> bUBounds = {static_cast<ui64>(UCHAR_MAX), 0};
     constexpr TBounds<ui64> sSBounds = {static_cast<ui64>(SHRT_MAX), static_cast<ui64>(USHRT_MAX - SHRT_MAX)};
@@ -450,8 +450,8 @@ size_t ToStringImpl<char8_t>(char8_t value, char* buf, size_t len) {
 }
 #endif
 
-using TCharIType = std::conditional_t<std::is_signed<char>::value, i64, ui64>;
-using TWCharIType = std::conditional_t<std::is_signed<wchar_t>::value, i64, ui64>;
+using TCharIType = std::conditional_t<std::is_signed<char>::value, i64, ui64>; 
+using TWCharIType = std::conditional_t<std::is_signed<wchar_t>::value, i64, ui64>; 
 
 DEF_INT_SPEC_I(char, TCharIType)
 DEF_INT_SPEC_I(wchar_t, TWCharIType)
@@ -472,13 +472,13 @@ DEF_FLT_SPEC(long double)
 
 #undef DEF_FLT_SPEC
 
-template <>
-size_t ToStringImpl<bool>(bool t, char* buf, size_t len) {
+template <> 
+size_t ToStringImpl<bool>(bool t, char* buf, size_t len) { 
     Y_ENSURE(len, TStringBuf("zero length"));
-    *buf = t ? '1' : '0';
-    return 1;
-}
-
+    *buf = t ? '1' : '0'; 
+    return 1; 
+} 
+ 
 /*
  * ------------------------------ parsers ------------------------------
  */
@@ -543,12 +543,12 @@ TWtringBuf FromStringImpl<TWtringBuf>(const wchar16* data, size_t len) {
 
 // Try-versions
 template <>
-bool TryFromStringImpl<TStringBuf>(const char* data, size_t len, TStringBuf& result) {
-    result = {data, len};
-    return true;
-}
-
-template <>
+bool TryFromStringImpl<TStringBuf>(const char* data, size_t len, TStringBuf& result) { 
+    result = {data, len}; 
+    return true; 
+} 
+ 
+template <> 
 bool TryFromStringImpl<TString>(const char* data, size_t len, TString& result) {
     result = TString(data, len);
     return true;
@@ -561,12 +561,12 @@ bool TryFromStringImpl<std::string>(const char* data, size_t len, std::string& r
 }
 
 template <>
-bool TryFromStringImpl<TWtringBuf>(const wchar16* data, size_t len, TWtringBuf& result) {
-    result = {data, len};
-    return true;
-}
-
-template <>
+bool TryFromStringImpl<TWtringBuf>(const wchar16* data, size_t len, TWtringBuf& result) { 
+    result = {data, len}; 
+    return true; 
+} 
+ 
+template <> 
 bool TryFromStringImpl<TUtf16String>(const wchar16* data, size_t len, TUtf16String& result) {
     result = TUtf16String(data, len);
     return true;
@@ -648,7 +648,7 @@ bool TryFromStringImpl<double>(const char* data, size_t len, double& result) {
         return false;
     }
 
-    char* se = nullptr;
+    char* se = nullptr; 
     double d = StrToD(data, data + len, &se);
 
     if (se != data + len) {
diff --git a/util/string/cast_ut.cpp b/util/string/cast_ut.cpp
index 033450c38c..e6fec11e2c 100644
--- a/util/string/cast_ut.cpp
+++ b/util/string/cast_ut.cpp
@@ -149,7 +149,7 @@ inline void CheckConvertToBuffer(const T& value, const size_t size, const TStrin
 }
 #endif
 
-Y_UNIT_TEST_SUITE(TCastTest) {
+Y_UNIT_TEST_SUITE(TCastTest) { 
     template <class A>
     inline TRet<A> F() {
         return TRet<A>();
@@ -173,10 +173,10 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(res, false);
         UNIT_ASSERT_DOUBLES_EQUAL(f, 42.0, eps); // check value was not trashed
         UNIT_ASSERT_EXCEPTION(f = FromString<TFloat>(str), TFromStringException);
-        Y_UNUSED(f); // shut up compiler about 'assigned value that is not used'
+        Y_UNUSED(f); // shut up compiler about 'assigned value that is not used' 
     }
 
-    Y_UNIT_TEST(TestToFrom) {
+    Y_UNIT_TEST(TestToFrom) { 
         test1(bool, true);
         test1(bool, false);
         test2(bool, "");
@@ -229,18 +229,18 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         test1(long long int, LLONG_MIN + 1);
     }
 
-    Y_UNIT_TEST(TestVolatile) {
+    Y_UNIT_TEST(TestVolatile) { 
         volatile int x = 1;
         UNIT_ASSERT_VALUES_EQUAL(ToString(x), "1");
     }
 
-    Y_UNIT_TEST(TestStrToD) {
-        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.1", nullptr), 1.1, EPS);
-        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.12345678", nullptr), 1.12345678, EPS);
-        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("10E-5", nullptr), 10E-5, EPS);
-        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.1E+5", nullptr), 1.1E+5, EPS);
+    Y_UNIT_TEST(TestStrToD) { 
+        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.1", nullptr), 1.1, EPS); 
+        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.12345678", nullptr), 1.12345678, EPS); 
+        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("10E-5", nullptr), 10E-5, EPS); 
+        UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.1E+5", nullptr), 1.1E+5, EPS); 
 
-        char* ret = nullptr;
+        char* ret = nullptr; 
 
         UNIT_ASSERT_DOUBLES_EQUAL(StrToD("1.1y", &ret), 1.1, EPS);
         UNIT_ASSERT_VALUES_EQUAL(*ret, 'y');
@@ -252,7 +252,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(*ret, 'z');
     }
 
-    Y_UNIT_TEST(TestFloats) {
+    Y_UNIT_TEST(TestFloats) { 
         // "%g" mode
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.1f, PREC_NDIGITS, 6), "0.1"); // drop trailing zeroes
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.12345678f, PREC_NDIGITS, 6), "0.123457");
@@ -289,7 +289,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_STRINGS_EQUAL(FloatToString(-std::numeric_limits<float>::infinity()), "-inf");
     }
 
-    Y_UNIT_TEST(TestReadFloats) {
+    Y_UNIT_TEST(TestReadFloats) { 
         GoodFloatTester<float>("0.0001", 0.0001f, EPS);
         GoodFloatTester<double>("0.0001", 0.0001, EPS);
         GoodFloatTester<long double>("0.0001", 0.0001, EPS);
@@ -303,24 +303,24 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         //BadFloatTester<float>("10E");
         //BadFloatTester<float>("10.E");
         BadFloatTester<float>("..0");
-        BadFloatTester<float>(""); // IGNIETFERRO-300
+        BadFloatTester<float>(""); // IGNIETFERRO-300 
         BadFloatTester<double>("1.00.01");
         BadFloatTester<double>("1.0001E5b");
         BadFloatTester<double>("1.0001s");
         BadFloatTester<double>("1..01");
-        BadFloatTester<double>(""); // IGNIETFERRO-300
+        BadFloatTester<double>(""); // IGNIETFERRO-300 
         BadFloatTester<long double>(".1.00");
         BadFloatTester<long double>("1.00.");
         BadFloatTester<long double>("1.0001e5-");
         BadFloatTester<long double>("10e 2");
-        BadFloatTester<long double>(""); // IGNIETFERRO-300
+        BadFloatTester<long double>(""); // IGNIETFERRO-300 
     }
 
-    Y_UNIT_TEST(TestLiteral) {
+    Y_UNIT_TEST(TestLiteral) { 
         UNIT_ASSERT_VALUES_EQUAL(ToString("abc"), TString("abc"));
     }
 
-    Y_UNIT_TEST(TestFromStringStringBuf) {
+    Y_UNIT_TEST(TestFromStringStringBuf) { 
         TString a = "xyz";
         TStringBuf b = FromString<TStringBuf>(a);
         UNIT_ASSERT_VALUES_EQUAL(a, b);
@@ -328,7 +328,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
     }
 
 #if 0
-    Y_UNIT_TEST(TestBufferOverflow) {
+    Y_UNIT_TEST(TestBufferOverflow) { 
         CheckConvertToBuffer<float>(1.f, 5, "1");
         CheckConvertToBuffer<float>(1.005f, 3, "1.005");
         CheckConvertToBuffer<float>(1.00000000f, 3, "1");
@@ -349,7 +349,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
     }
 #endif
 
-    Y_UNIT_TEST(TestWide) {
+    Y_UNIT_TEST(TestWide) { 
         TUtf16String iw = u"-100500";
         int iv = 0;
         UNIT_ASSERT_VALUES_EQUAL(TryFromString(iw, iv), true);
@@ -371,7 +371,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(uv, 21474836470ull);
     }
 
-    Y_UNIT_TEST(TestDefault) {
+    Y_UNIT_TEST(TestDefault) { 
         size_t res = 0;
         const size_t def1 = 42;
 
@@ -437,7 +437,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(FromStringWithDefault<size_t>(s4), size_t());
     }
 
-    Y_UNIT_TEST(TestBool) {
+    Y_UNIT_TEST(TestBool) { 
         // True cases
         UNIT_ASSERT_VALUES_EQUAL(FromString<bool>("yes"), true);
         UNIT_ASSERT_VALUES_EQUAL(FromString<bool>("1"), true);
@@ -449,7 +449,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_EXCEPTION(FromString<bool>("something"), yexception);
     }
 
-    Y_UNIT_TEST(TestAutoDetectType) {
+    Y_UNIT_TEST(TestAutoDetectType) { 
         UNIT_ASSERT_DOUBLES_EQUAL((float)FromString("0.0001"), 0.0001, EPS);
         UNIT_ASSERT_DOUBLES_EQUAL((double)FromString("0.0015", sizeof("0.0015") - 2), 0.001, EPS);
         UNIT_ASSERT_DOUBLES_EQUAL((long double)FromString(TStringBuf("0.0001")), 0.0001, EPS);
@@ -472,7 +472,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         }
     }
 
-    Y_UNIT_TEST(ErrorMessages) {
+    Y_UNIT_TEST(ErrorMessages) { 
         try {
             FromString<ui32>("");
             UNIT_ASSERT(false);
@@ -509,47 +509,47 @@ Y_UNIT_TEST_SUITE(TCastTest) {
             CheckMessage(e, "Unexpected symbol \".\" at pos 1 in string \"0.328413745072\"");
         }
     }
-
-    Y_UNIT_TEST(TryStringBuf) {
-        {
+ 
+    Y_UNIT_TEST(TryStringBuf) { 
+        { 
             constexpr TStringBuf hello = "hello";
-            TStringBuf out;
-            UNIT_ASSERT(TryFromString(hello, out));
+            TStringBuf out; 
+            UNIT_ASSERT(TryFromString(hello, out)); 
             UNIT_ASSERT_VALUES_EQUAL(hello, out);
-        }
-        {
+        } 
+        { 
             constexpr TStringBuf empty = "";
-            TStringBuf out;
-            UNIT_ASSERT(TryFromString(empty, out));
+            TStringBuf out; 
+            UNIT_ASSERT(TryFromString(empty, out)); 
             UNIT_ASSERT_VALUES_EQUAL(empty, out);
-        }
-        {
-            constexpr TStringBuf empty;
-            TStringBuf out;
-            UNIT_ASSERT(TryFromString(empty, out));
+        } 
+        { 
+            constexpr TStringBuf empty; 
+            TStringBuf out; 
+            UNIT_ASSERT(TryFromString(empty, out)); 
             UNIT_ASSERT_VALUES_EQUAL(empty, out);
-        }
-        {
+        } 
+        { 
             const auto hello = u"hello";
-            TWtringBuf out;
-            UNIT_ASSERT(TryFromString(hello, out));
+            TWtringBuf out; 
+            UNIT_ASSERT(TryFromString(hello, out)); 
             UNIT_ASSERT_VALUES_EQUAL(hello, out);
-        }
-        {
+        } 
+        { 
             const TUtf16String empty;
-            TWtringBuf out;
-            UNIT_ASSERT(TryFromString(empty, out));
+            TWtringBuf out; 
+            UNIT_ASSERT(TryFromString(empty, out)); 
             UNIT_ASSERT_VALUES_EQUAL(empty, out);
-        }
-        {
-            constexpr TWtringBuf empty;
-            TWtringBuf out;
-            UNIT_ASSERT(TryFromString(empty, out));
+        } 
+        { 
+            constexpr TWtringBuf empty; 
+            TWtringBuf out; 
+            UNIT_ASSERT(TryFromString(empty, out)); 
             UNIT_ASSERT_VALUES_EQUAL(empty, out);
-        }
-    }
+        } 
+    } 
 
-    Y_UNIT_TEST(Nan) {
+    Y_UNIT_TEST(Nan) { 
         double xx = 0;
 
         UNIT_ASSERT(!TryFromString("NaN", xx));
@@ -557,7 +557,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT(!TryFromString("nan", xx));
     }
 
-    Y_UNIT_TEST(Infinity) {
+    Y_UNIT_TEST(Infinity) { 
         double xx = 0;
 
         UNIT_ASSERT(!TryFromString("Infinity", xx));
@@ -565,7 +565,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT(!TryFromString("infinity", xx));
     }
 
-    Y_UNIT_TEST(TestBorderCases) {
+    Y_UNIT_TEST(TestBorderCases) { 
         UNIT_ASSERT_VALUES_EQUAL(ToString(0.0), "0");
         UNIT_ASSERT_VALUES_EQUAL(ToString(1.0), "1");
         UNIT_ASSERT_VALUES_EQUAL(ToString(10.0), "10");
diff --git a/util/string/escape.cpp b/util/string/escape.cpp
index cd09a7dbd0..0a79bd30d0 100644
--- a/util/string/escape.cpp
+++ b/util/string/escape.cpp
@@ -43,7 +43,7 @@
 namespace {
     template <typename TChar>
     static inline char HexDigit(TChar value) {
-        Y_ASSERT(value < 16);
+        Y_ASSERT(value < 16); 
         if (value < 10) {
             return '0' + value;
         } else {
@@ -53,7 +53,7 @@ namespace {
 
     template <typename TChar>
     static inline char OctDigit(TChar value) {
-        Y_ASSERT(value < 8);
+        Y_ASSERT(value < 8); 
         return '0' + value;
     }
 
diff --git a/util/string/escape_ut.cpp b/util/string/escape_ut.cpp
index cd38ecffd3..b1bd7f2a94 100644
--- a/util/string/escape_ut.cpp
+++ b/util/string/escape_ut.cpp
@@ -7,20 +7,20 @@
 
 using namespace std::string_view_literals;
 
-namespace {
-    struct TExample {
+namespace { 
+    struct TExample { 
         TString Expected;
         TString Source;
-
-        TExample(const TStringBuf expected, const TStringBuf source)
-            : Expected{expected}
+ 
+        TExample(const TStringBuf expected, const TStringBuf source) 
+            : Expected{expected} 
             , Source{source}
         {
-        }
-    };
-}
-
-static const TExample CommonTestData[] = {
+        } 
+    }; 
+} 
+ 
+static const TExample CommonTestData[] = { 
     // Should be valid UTF-8.
     {"http://ya.ru/", "http://ya.ru/"},
     {"http://ya.ru/\\x17\\n", "http://ya.ru/\x17\n"},
@@ -46,16 +46,16 @@ static const TExample CommonTestData[] = {
     {"There are questions \\x3F?", "There are questions ??"},
 };
 
-Y_UNIT_TEST_SUITE(TEscapeCTest) {
-    Y_UNIT_TEST(TestStrokaEscapeC) {
-        for (const auto& e : CommonTestData) {
+Y_UNIT_TEST_SUITE(TEscapeCTest) { 
+    Y_UNIT_TEST(TestStrokaEscapeC) { 
+        for (const auto& e : CommonTestData) { 
             TString expected(e.Expected);
             TString source(e.Source);
             TString actual(EscapeC(e.Source));
             TString actual2(UnescapeC(e.Expected));
 
-            UNIT_ASSERT_VALUES_EQUAL(e.Expected, actual);
-            UNIT_ASSERT_VALUES_EQUAL(e.Source, actual2);
+            UNIT_ASSERT_VALUES_EQUAL(e.Expected, actual); 
+            UNIT_ASSERT_VALUES_EQUAL(e.Source, actual2); 
         }
 
         UNIT_ASSERT_VALUES_EQUAL("http://ya.ru/\\x17\\n\\xAB", EscapeC(TString("http://ya.ru/\x17\n\xab")));
@@ -79,8 +79,8 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         UNIT_ASSERT_VALUES_EQUAL("Странный компроматтест", UnescapeC(TString("\\u0421\\u0442\\u0440\\u0430\\u043d\\u043d\\u044b\\u0439 \\u043a\\u043e\\u043c\\u043f\\u0440\\u043e\\u043c\\u0430\\u0442тест")));
     }
 
-    Y_UNIT_TEST(TestWtrokaEscapeC) {
-        for (const auto& e : CommonTestData) {
+    Y_UNIT_TEST(TestWtrokaEscapeC) { 
+        for (const auto& e : CommonTestData) { 
             TUtf16String expected(UTF8ToWide(e.Expected));
             TUtf16String source(UTF8ToWide(e.Source));
             TUtf16String actual(EscapeC(source));
@@ -95,7 +95,7 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         UNIT_ASSERT_VALUES_EQUAL(u"\\xFF", EscapeC(wchar16(255)));
     }
 
-    Y_UNIT_TEST(TestEscapeTrigraphs) {
+    Y_UNIT_TEST(TestEscapeTrigraphs) { 
         UNIT_ASSERT_VALUES_EQUAL("?", EscapeC(TString("?")));
         UNIT_ASSERT_VALUES_EQUAL("\\x3F?", EscapeC(TString("??")));
         UNIT_ASSERT_VALUES_EQUAL("\\x3F\\x3F?", EscapeC(TString("???")));
@@ -104,7 +104,7 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         UNIT_ASSERT_VALUES_EQUAL("\\x3F?x\\x3F\\x3F?z", EscapeC(TString("??x???z")));
     }
 
-    Y_UNIT_TEST(TestUnescapeCCharLen) {
+    Y_UNIT_TEST(TestUnescapeCCharLen) { 
         auto test = [](const char* str, size_t len) {
             UNIT_ASSERT_EQUAL(UnescapeCCharLen(str, str + strlen(str)), len);
         };
@@ -131,7 +131,7 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         test("\\4xxx", 2);
     }
 
-    Y_UNIT_TEST(TestUnbounded) {
+    Y_UNIT_TEST(TestUnbounded) { 
         char buf[100000];
 
         for (const auto& x : CommonTestData) {
diff --git a/util/string/fuzzing/escape_c/main.cpp b/util/string/fuzzing/escape_c/main.cpp
index 742126416a..aa733cec76 100644
--- a/util/string/fuzzing/escape_c/main.cpp
+++ b/util/string/fuzzing/escape_c/main.cpp
@@ -1,11 +1,11 @@
-#include <util/generic/string.h>
-#include <util/string/escape.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const ui8* const data, const size_t size) {
-    const TString src(reinterpret_cast<const char*>(data), size);
-    const auto escaped = EscapeC(src);
-    const auto dst = UnescapeC(escaped);
-
-    Y_VERIFY(src == dst);
-    return 0;
-}
+#include <util/generic/string.h> 
+#include <util/string/escape.h> 
+ 
+extern "C" int LLVMFuzzerTestOneInput(const ui8* const data, const size_t size) { 
+    const TString src(reinterpret_cast<const char*>(data), size); 
+    const auto escaped = EscapeC(src); 
+    const auto dst = UnescapeC(escaped); 
+ 
+    Y_VERIFY(src == dst); 
+    return 0; 
+} 
diff --git a/util/string/fuzzing/escape_c/ya.make b/util/string/fuzzing/escape_c/ya.make
index 61e64ac9de..0cdee23d31 100644
--- a/util/string/fuzzing/escape_c/ya.make
+++ b/util/string/fuzzing/escape_c/ya.make
@@ -1,13 +1,13 @@
-OWNER(
-    yazevnul
-    g:util
-)
+OWNER( 
+    yazevnul 
+    g:util 
+) 
 SUBSCRIBER(g:util-subscribers)
-
-FUZZ()
-
-SRCS(
-    main.cpp
-)
-
-END()
+ 
+FUZZ() 
+ 
+SRCS( 
+    main.cpp 
+) 
+ 
+END() 
diff --git a/util/string/fuzzing/ya.make b/util/string/fuzzing/ya.make
index 617e0f2b1d..e3a87d3740 100644
--- a/util/string/fuzzing/ya.make
+++ b/util/string/fuzzing/ya.make
@@ -1,11 +1,11 @@
-OWNER(
+OWNER( 
     g:util
-    pg
-)
+    pg 
+) 
 SUBSCRIBER(g:util-subscribers)
-
+ 
 RECURSE(
-    collapse
-    escape_c
+    collapse 
+    escape_c 
     strtod
 )
diff --git a/util/string/hex.h b/util/string/hex.h
index af3d2d528f..08f7398129 100644
--- a/util/string/hex.h
+++ b/util/string/hex.h
@@ -16,7 +16,7 @@ extern const char* const Char2DigitTable;
 
 inline static int Char2Digit(char ch) {
     char result = Char2DigitTable[(unsigned char)ch];
-    Y_ENSURE(result != '\xff', "invalid hex character " << (int)ch);
+    Y_ENSURE(result != '\xff', "invalid hex character " << (int)ch); 
     return result;
 }
 
diff --git a/util/string/hex_ut.cpp b/util/string/hex_ut.cpp
index 39a83d5e62..485583ce35 100644
--- a/util/string/hex_ut.cpp
+++ b/util/string/hex_ut.cpp
@@ -2,16 +2,16 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-Y_UNIT_TEST_SUITE(THexCodingTest) {
-    Y_UNIT_TEST(TestEncode) {
+Y_UNIT_TEST_SUITE(THexCodingTest) { 
+    Y_UNIT_TEST(TestEncode) { 
         UNIT_ASSERT_EQUAL(HexEncode("i1634iqwbf,&msdb"), "693136333469717762662C266D736462");
     }
 
-    Y_UNIT_TEST(TestDecode) {
+    Y_UNIT_TEST(TestDecode) { 
         UNIT_ASSERT_EQUAL(HexDecode("693136333469717762662C266D736462"), "i1634iqwbf,&msdb");
     }
 
-    Y_UNIT_TEST(TestDecodeCase) {
+    Y_UNIT_TEST(TestDecodeCase) { 
         UNIT_ASSERT_EQUAL(HexDecode("12ABCDEF"), HexDecode("12abcdef"));
         UNIT_ASSERT_EXCEPTION(HexDecode("Hello"), yexception); //< incorrect chars
         UNIT_ASSERT_EXCEPTION(HexDecode("123"), yexception);   //< odd length
diff --git a/util/string/join_ut.cpp b/util/string/join_ut.cpp
index 3ed2b2459c..fde333a37d 100644
--- a/util/string/join_ut.cpp
+++ b/util/string/join_ut.cpp
@@ -3,7 +3,7 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <util/generic/vector.h>
 
-#include <util/stream/output.h>
+#include <util/stream/output.h> 
 
 struct TCustomData {
     TVector<int> Ints;
@@ -13,8 +13,8 @@ TString ToString(const TCustomData& d) {
     return JoinSeq("__", d.Ints);
 }
 
-Y_UNIT_TEST_SUITE(JoinStringTest) {
-    Y_UNIT_TEST(ScalarItems) {
+Y_UNIT_TEST_SUITE(JoinStringTest) { 
+    Y_UNIT_TEST(ScalarItems) { 
         UNIT_ASSERT_EQUAL(Join(',', 10, 11.1, "foobar"), "10,11.1,foobar");
         UNIT_ASSERT_EQUAL(Join(", ", 10, 11.1, "foobar"), "10, 11.1, foobar");
         UNIT_ASSERT_EQUAL(Join(", ", 10, 11.1, TString("foobar")), "10, 11.1, foobar");
@@ -26,7 +26,7 @@ Y_UNIT_TEST_SUITE(JoinStringTest) {
         UNIT_ASSERT_EQUAL(Join(" ", "a", "b", "", "c"), "a b  c");
     }
 
-    Y_UNIT_TEST(IntContainerItems) {
+    Y_UNIT_TEST(IntContainerItems) { 
         int v[] = {1, 2, 3};
         TVector<int> vv(v, v + 3);
         UNIT_ASSERT_EQUAL(JoinSeq(" ", vv), "1 2 3");
@@ -38,7 +38,7 @@ Y_UNIT_TEST_SUITE(JoinStringTest) {
         UNIT_ASSERT_VALUES_EQUAL(JoinSeq(" ", v), "1 2 3");
     }
 
-    Y_UNIT_TEST(StrContainerItems) {
+    Y_UNIT_TEST(StrContainerItems) { 
         // try various overloads and template type arguments
         static const char* const result = "1 22 333";
         static const char* const v[] = {"1", "22", "333"};
@@ -148,13 +148,13 @@ Y_UNIT_TEST_SUITE(JoinStringTest) {
         UNIT_ASSERT_VALUES_EQUAL(JoinSeq(" ", v), result);
     }
 
-    Y_UNIT_TEST(CustomToString) {
-        TCustomData d1{{1, 2, 3, 4, 5}};
-        TCustomData d2{{0, -1, -2}};
+    Y_UNIT_TEST(CustomToString) { 
+        TCustomData d1{{1, 2, 3, 4, 5}}; 
+        TCustomData d2{{0, -1, -2}}; 
         UNIT_ASSERT_EQUAL(Join(" ", d1, d2), "1__2__3__4__5 0__-1__-2");
     }
 
-    Y_UNIT_TEST(JoinChars) {
+    Y_UNIT_TEST(JoinChars) { 
         // Note that char delimeter is printed as single char string,
         // but joined char values are printed as their numeric codes! O_o
         UNIT_ASSERT_EQUAL(Join('a', 'a', 'a'), "97a97");
diff --git a/util/string/printf.cpp b/util/string/printf.cpp
index 5b7c34d4e1..a8a2e71c9d 100644
--- a/util/string/printf.cpp
+++ b/util/string/printf.cpp
@@ -1,7 +1,7 @@
 #include "printf.h"
 
 #include <util/stream/printf.h>
-#include <util/stream/str.h>
+#include <util/stream/str.h> 
 
 int vsprintf(TString& s, const char* c, va_list params) {
     TStringOutput so(s.remove());
diff --git a/util/string/printf.h b/util/string/printf.h
index 925c6edaff..742bf1e584 100644
--- a/util/string/printf.h
+++ b/util/string/printf.h
@@ -1,10 +1,10 @@
 #pragma once
 
 #include <util/generic/fwd.h>
-#include <util/system/compiler.h>
-
-#include <cstdarg>
+#include <util/system/compiler.h> 
 
+#include <cstdarg> 
+ 
 /// formatted print. return printed length:
 int Y_PRINTF_FORMAT(2, 0) vsprintf(TString& s, const char* c, va_list params);
 /// formatted print. return printed length:
diff --git a/util/string/printf_ut.cpp b/util/string/printf_ut.cpp
index 2b2f980b70..b6d43cb3a2 100644
--- a/util/string/printf_ut.cpp
+++ b/util/string/printf_ut.cpp
@@ -2,15 +2,15 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-Y_UNIT_TEST_SUITE(TStringPrintf) {
-    Y_UNIT_TEST(TestSprintf) {
+Y_UNIT_TEST_SUITE(TStringPrintf) { 
+    Y_UNIT_TEST(TestSprintf) { 
         TString s;
         int len = sprintf(s, "Hello %s", "world");
         UNIT_ASSERT_EQUAL(s, TString("Hello world"));
         UNIT_ASSERT_EQUAL(len, 11);
     }
 
-    Y_UNIT_TEST(TestFcat) {
+    Y_UNIT_TEST(TestFcat) { 
         TString s;
         int len = sprintf(s, "Hello %s", "world");
         UNIT_ASSERT_EQUAL(s, TString("Hello world"));
@@ -20,11 +20,11 @@ Y_UNIT_TEST_SUITE(TStringPrintf) {
         UNIT_ASSERT_EQUAL(len, 7);
     }
 
-    Y_UNIT_TEST(TestSpecial) {
+    Y_UNIT_TEST(TestSpecial) { 
         UNIT_ASSERT_EQUAL("4294967295", Sprintf("%" PRIu32, (ui32)(-1)));
     }
 
-    Y_UNIT_TEST(TestExplicitPositions) {
+    Y_UNIT_TEST(TestExplicitPositions) { 
         UNIT_ASSERT_EQUAL("abc xyz abc", Sprintf("%1$s %2$s %1$s", "abc", "xyz"));
     }
 }
diff --git a/util/string/split.h b/util/string/split.h
index bc46d9e64c..58d8f81c5e 100644
--- a/util/string/split.h
+++ b/util/string/split.h
@@ -261,7 +261,7 @@ struct TSetDelimiter: private TFindFirstOf<const Char> {
 };
 
 namespace NSplitTargetHasPushBack {
-    Y_HAS_MEMBER(push_back, PushBack);
+    Y_HAS_MEMBER(push_back, PushBack); 
 }
 
 template <class T, class = void>
diff --git a/util/string/split_ut.cpp b/util/string/split_ut.cpp
index 43e59f2d75..0135d5c3af 100644
--- a/util/string/split_ut.cpp
+++ b/util/string/split_ut.cpp
@@ -2,7 +2,7 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-#include <util/stream/output.h>
+#include <util/stream/output.h> 
 #include <util/charset/wide.h>
 #include <util/datetime/cputimer.h>
 #include <util/generic/maybe.h>
@@ -119,8 +119,8 @@ void TestLimitingConsumerOnRange(TVector<TString>& good, const char* b, const ch
     UNIT_ASSERT_EQUAL(TString(limits.Last), TString(last));
 }
 
-Y_UNIT_TEST_SUITE(SplitStringTest) {
-    Y_UNIT_TEST(TestCharSingleDelimiter) {
+Y_UNIT_TEST_SUITE(SplitStringTest) { 
+    Y_UNIT_TEST(TestCharSingleDelimiter) { 
         TString data("qw ab  qwabcab");
         TString canonic[] = {"qw", "ab", "", "qwabcab"};
         TVector<TString> good(canonic, canonic + 4);
@@ -130,7 +130,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnRange<TContainerConsumer>(good, data.data(), data.end(), delim);
     }
 
-    Y_UNIT_TEST(TestWideSingleDelimiter) {
+    Y_UNIT_TEST(TestWideSingleDelimiter) { 
         TUtf16String data(u"qw ab  qwabcab");
         TUtf16String canonic[] = {u"qw", u"ab", TUtf16String(), u"qwabcab"};
         TVector<TUtf16String> good(canonic, canonic + 4);
@@ -140,7 +140,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnRange<TContainerConsumer>(good, data.data(), data.end(), delim);
     }
 
-    Y_UNIT_TEST(TestConvertToIntCharSingleDelimiter) {
+    Y_UNIT_TEST(TestConvertToIntCharSingleDelimiter) { 
         TString data("42 4242 -12345 0");
         i32 canonic[] = {42, 4242, -12345, 0};
         TVector<i32> good(canonic, canonic + 4);
@@ -159,7 +159,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestConsumerOnRange<TSkipEmptyTokens<TStrokaConsumer>>(good, data.data(), data.end(), " ");
     }
 
-    Y_UNIT_TEST(TestCharKeepDelimiters) {
+    Y_UNIT_TEST(TestCharKeepDelimiters) { 
         TString data("qw ab  qwabcab ");
         TString canonic[] = {"qw", " ", "ab", " ", "", " ", "qwabcab", " ", ""};
         TVector<TString> good(canonic, canonic + 9);
@@ -168,7 +168,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestConsumerOnRange<TKeepDelimiters<TStrokaConsumer>>(good, data.data(), data.end(), " ");
     }
 
-    Y_UNIT_TEST(TestCharLimit) {
+    Y_UNIT_TEST(TestCharLimit) { 
         TString data("qw ab  qwabcab ");
         TString canonic[] = {"qw", "ab"};
         TVector<TString> good(canonic, canonic + 2);
@@ -177,7 +177,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestLimitingConsumerOnRange(good, data.data(), data.end(), " ", 3, " qwabcab ");
     }
 
-    Y_UNIT_TEST(TestCharStringDelimiter) {
+    Y_UNIT_TEST(TestCharStringDelimiter) { 
         TString data("qw ab qwababcab");
         TString canonic[] = {"qw ", " qw", "", "c", ""};
         TVector<TString> good(canonic, canonic + 5);
@@ -187,7 +187,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnRange<TContainerConsumer>(good, data.data(), data.end(), delim);
     }
 
-    Y_UNIT_TEST(TestWideStringDelimiter) {
+    Y_UNIT_TEST(TestWideStringDelimiter) { 
         TUtf16String data(u"qw ab qwababcab");
         TUtf16String canonic[] = {u"qw ", u" qw", TUtf16String(), u"c", TUtf16String()};
         TVector<TUtf16String> good(canonic, canonic + 5);
@@ -198,7 +198,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnRange<TContainerConsumer>(good, data.data(), data.end(), delim);
     }
 
-    Y_UNIT_TEST(TestCharSetDelimiter) {
+    Y_UNIT_TEST(TestCharSetDelimiter) { 
         TString data("qw ab qwababccab");
         TString canonic[] = {"q", " ab q", "abab", "", "ab"};
         TVector<TString> good(canonic, canonic + 5);
@@ -208,7 +208,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnRange<TContainerConsumer>(good, data.data(), data.end(), delim);
     }
 
-    Y_UNIT_TEST(TestWideSetDelimiter) {
+    Y_UNIT_TEST(TestWideSetDelimiter) { 
         TUtf16String data(u"qw ab qwababccab");
         TUtf16String canonic[] = {u"q", u" ab q", u"abab", TUtf16String(), u"ab"};
         TVector<TUtf16String> good(canonic, canonic + 5);
@@ -218,7 +218,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         TestDelimiterOnString<TContainerConsumer>(good, data.data(), delim);
     }
 
-    Y_UNIT_TEST(TestWideSetDelimiterRange) {
+    Y_UNIT_TEST(TestWideSetDelimiterRange) { 
         TUtf16String data(u"qw ab qwababccab");
         TUtf16String canonic[] = {u"q", u" ab q", u"abab", TUtf16String(), u"ab"};
         TVector<TUtf16String> good(1);
@@ -237,7 +237,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         Cmp(good, test);
     }
 
-    Y_UNIT_TEST(TestSplit) {
+    Y_UNIT_TEST(TestSplit) { 
         TString data("qw ab qwababcba");
         TString canonic[] = {"qw ", " qw", "c"};
         TVector<TString> good(canonic, canonic + 3);
@@ -251,7 +251,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         Cmp(good, test1);
     }
 
-    Y_UNIT_TEST(ConvenientSplitTest) {
+    Y_UNIT_TEST(ConvenientSplitTest) { 
         TString data("abc 22 33.5 xyz");
         TString str;
         int num1 = 0;
@@ -264,7 +264,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         UNIT_ASSERT_VALUES_EQUAL(strBuf, "xyz");
     }
 
-    Y_UNIT_TEST(ConvenientSplitTestWithMaybe) {
+    Y_UNIT_TEST(ConvenientSplitTestWithMaybe) { 
         TString data("abc 42");
         TString str;
         TMaybe<double> num2 = 1;
@@ -277,7 +277,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         UNIT_ASSERT(!maybe);
     }
 
-    Y_UNIT_TEST(ConvenientSplitTestExceptions) {
+    Y_UNIT_TEST(ConvenientSplitTestExceptions) { 
         TString data("abc 22 33");
         TString s1, s2, s3, s4;
 
@@ -286,7 +286,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         UNIT_ASSERT_EXCEPTION(Split(data, ' ', s1, s2, s3, s4), yexception);
     }
 
-    Y_UNIT_TEST(ConvenientSplitTestMaybeExceptions) {
+    Y_UNIT_TEST(ConvenientSplitTestMaybeExceptions) { 
         TString data("abc 22 33");
         TString s1, s2;
         TMaybe<TString> m1, m2;
diff --git a/util/string/strip_ut.cpp b/util/string/strip_ut.cpp
index d1029d1498..663b648a21 100644
--- a/util/string/strip_ut.cpp
+++ b/util/string/strip_ut.cpp
@@ -4,8 +4,8 @@
 
 #include <util/charset/wide.h>
 
-Y_UNIT_TEST_SUITE(TStripStringTest) {
-    Y_UNIT_TEST(TestStrip) {
+Y_UNIT_TEST_SUITE(TStripStringTest) { 
+    Y_UNIT_TEST(TestStrip) { 
         struct TTest {
             const char* Str;
             const char* StripLeftRes;
@@ -26,25 +26,25 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             {"a c", "a c", "a c", "a c"},
         };
 
-        for (const auto& test : tests) {
+        for (const auto& test : tests) { 
             TString inputStr(test.Str);
 
             TString s;
             Strip(inputStr, s);
-            UNIT_ASSERT_EQUAL(s, test.StripRes);
+            UNIT_ASSERT_EQUAL(s, test.StripRes); 
 
-            UNIT_ASSERT_EQUAL(StripString(inputStr), test.StripRes);
-            UNIT_ASSERT_EQUAL(StripStringLeft(inputStr), test.StripLeftRes);
-            UNIT_ASSERT_EQUAL(StripStringRight(inputStr), test.StripRightRes);
+            UNIT_ASSERT_EQUAL(StripString(inputStr), test.StripRes); 
+            UNIT_ASSERT_EQUAL(StripStringLeft(inputStr), test.StripLeftRes); 
+            UNIT_ASSERT_EQUAL(StripStringRight(inputStr), test.StripRightRes); 
 
-            TStringBuf inputStrBuf(test.Str);
-            UNIT_ASSERT_EQUAL(StripString(inputStrBuf), test.StripRes);
-            UNIT_ASSERT_EQUAL(StripStringLeft(inputStrBuf), test.StripLeftRes);
-            UNIT_ASSERT_EQUAL(StripStringRight(inputStrBuf), test.StripRightRes);
+            TStringBuf inputStrBuf(test.Str); 
+            UNIT_ASSERT_EQUAL(StripString(inputStrBuf), test.StripRes); 
+            UNIT_ASSERT_EQUAL(StripStringLeft(inputStrBuf), test.StripLeftRes); 
+            UNIT_ASSERT_EQUAL(StripStringRight(inputStrBuf), test.StripRightRes); 
         };
     }
 
-    Y_UNIT_TEST(TestCustomStrip) {
+    Y_UNIT_TEST(TestCustomStrip) { 
         struct TTest {
             const char* Str;
             const char* Result;
@@ -56,14 +56,14 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             {"012//", "012"},
         };
 
-        for (auto test : tests) {
+        for (auto test : tests) { 
             UNIT_ASSERT_EQUAL(
                 StripString(TString(test.Str), EqualsStripAdapter('/')),
-                test.Result);
+                test.Result); 
         };
     }
 
-    Y_UNIT_TEST(TestCustomStripLeftRight) {
+    Y_UNIT_TEST(TestCustomStripLeftRight) { 
         struct TTest {
             const char* Str;
             const char* ResultLeft;
@@ -76,30 +76,30 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             {"012//", "012//", "012"},
         };
 
-        for (const auto& test : tests) {
+        for (const auto& test : tests) { 
             UNIT_ASSERT_EQUAL(
                 StripStringLeft(TString(test.Str), EqualsStripAdapter('/')),
-                test.ResultLeft);
+                test.ResultLeft); 
             UNIT_ASSERT_EQUAL(
                 StripStringRight(TString(test.Str), EqualsStripAdapter('/')),
-                test.ResultRight);
+                test.ResultRight); 
         };
     }
 
-    Y_UNIT_TEST(TestNullStringStrip) {
-        TStringBuf nullString(nullptr, nullptr);
+    Y_UNIT_TEST(TestNullStringStrip) { 
+        TStringBuf nullString(nullptr, nullptr); 
         UNIT_ASSERT_EQUAL(
             StripString(nullString),
             TString());
     }
 
-    Y_UNIT_TEST(TestWtrokaStrip) {
+    Y_UNIT_TEST(TestWtrokaStrip) { 
         UNIT_ASSERT_EQUAL(StripString(TWtringBuf(u" abc ")), u"abc");
         UNIT_ASSERT_EQUAL(StripStringLeft(TWtringBuf(u" abc ")), u"abc ");
         UNIT_ASSERT_EQUAL(StripStringRight(TWtringBuf(u" abc ")), u" abc");
     }
 
-    Y_UNIT_TEST(TestWtrokaCustomStrip) {
+    Y_UNIT_TEST(TestWtrokaCustomStrip) { 
         UNIT_ASSERT_EQUAL(
             StripString(
                 TWtringBuf(u"/abc/"),
@@ -107,7 +107,7 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             u"abc");
     }
 
-    Y_UNIT_TEST(TestCollapse) {
+    Y_UNIT_TEST(TestCollapse) { 
         TString s;
         Collapse(TString("  123    456  "), s);
         UNIT_ASSERT(s == " 123 456 ");
@@ -124,7 +124,7 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
 #endif
     }
 
-    Y_UNIT_TEST(TestCollapseText) {
+    Y_UNIT_TEST(TestCollapseText) { 
         TString abs1("Very long description string written in unknown language.");
         TString abs2(abs1);
         TString abs3(abs1);
diff --git a/util/string/subst.cpp b/util/string/subst.cpp
index b2df328dc1..8daef0708b 100644
--- a/util/string/subst.cpp
+++ b/util/string/subst.cpp
@@ -1,200 +1,200 @@
 #include "subst.h"
-
-#include <util/generic/strbuf.h>
-#include <util/generic/string.h>
-#include <util/system/compiler.h>
-
-#include <string>
-#include <type_traits>
-
-// a bit of template magic (to be fast and unreadable)
-template <class TStringType, class TTo, bool Main>
-static Y_FORCE_INLINE void MoveBlock(typename TStringType::value_type* ptr, size_t& srcPos, size_t& dstPos, const size_t off, const TTo to, const size_t toSize) {
-    const size_t unchangedSize = off - srcPos;
-    if (dstPos < srcPos) {
-        for (size_t i = 0; i < unchangedSize; ++i) {
-            ptr[dstPos++] = ptr[srcPos++];
-        }
-    } else {
-        dstPos += unchangedSize;
-        srcPos += unchangedSize;
-    }
-
-    if (Main) {
-        for (size_t i = 0; i < toSize; ++i) {
-            ptr[dstPos++] = to[i];
-        }
-    }
-}
-
-template <typename T, typename U>
-static bool IsIntersect(const T& a, const U& b) noexcept {
-    if (b.data() < a.data()) {
-        return IsIntersect(b, a);
-    }
-
-    return !a.empty() && !b.empty() &&
-           ((a.data() <= b.data() && b.data() < a.data() + a.size()) ||
-            (a.data() < b.data() + b.size() && b.data() + b.size() <= a.data() + a.size()));
-}
-
-/**
- * Replaces all occurences of substring @c from in string @c s to string @c to.
- * Uses two separate implementations (inplace for shrink and append for grow case)
- * See IGNIETFERRO-394
- **/
+ 
+#include <util/generic/strbuf.h> 
+#include <util/generic/string.h> 
+#include <util/system/compiler.h> 
+ 
+#include <string> 
+#include <type_traits> 
+ 
+// a bit of template magic (to be fast and unreadable) 
+template <class TStringType, class TTo, bool Main> 
+static Y_FORCE_INLINE void MoveBlock(typename TStringType::value_type* ptr, size_t& srcPos, size_t& dstPos, const size_t off, const TTo to, const size_t toSize) { 
+    const size_t unchangedSize = off - srcPos; 
+    if (dstPos < srcPos) { 
+        for (size_t i = 0; i < unchangedSize; ++i) { 
+            ptr[dstPos++] = ptr[srcPos++]; 
+        } 
+    } else { 
+        dstPos += unchangedSize; 
+        srcPos += unchangedSize; 
+    } 
+ 
+    if (Main) { 
+        for (size_t i = 0; i < toSize; ++i) { 
+            ptr[dstPos++] = to[i]; 
+        } 
+    } 
+} 
+ 
+template <typename T, typename U> 
+static bool IsIntersect(const T& a, const U& b) noexcept { 
+    if (b.data() < a.data()) { 
+        return IsIntersect(b, a); 
+    } 
+ 
+    return !a.empty() && !b.empty() && 
+           ((a.data() <= b.data() && b.data() < a.data() + a.size()) || 
+            (a.data() < b.data() + b.size() && b.data() + b.size() <= a.data() + a.size())); 
+} 
+ 
+/** 
+ * Replaces all occurences of substring @c from in string @c s to string @c to. 
+ * Uses two separate implementations (inplace for shrink and append for grow case) 
+ * See IGNIETFERRO-394 
+ **/ 
 template <class TStringType, typename TStringViewType = TBasicStringBuf<typename TStringType::value_type>>
-static inline size_t SubstGlobalImpl(TStringType& s, const TStringViewType from, const TStringViewType to, size_t fromPos = 0) {
+static inline size_t SubstGlobalImpl(TStringType& s, const TStringViewType from, const TStringViewType to, size_t fromPos = 0) { 
     if (from.empty()) {
-        return 0;
-    }
-
-    Y_ASSERT(!IsIntersect(s, from));
-    Y_ASSERT(!IsIntersect(s, to));
-
-    const size_t fromSize = from.size();
-    const size_t toSize = to.size();
-    size_t replacementsCount = 0;
-    size_t off = fromPos;
-    size_t srcPos = 0;
-
-    if (toSize > fromSize) {
-        // string will grow: append to another string
-        TStringType result;
-        for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) {
-            if (!replacementsCount) {
-                // first replacement occured, we can prepare result string
-                result.reserve(s.size() + s.size() / 3);
-            }
-            result.append(s.begin() + srcPos, s.begin() + off);
+        return 0; 
+    } 
+ 
+    Y_ASSERT(!IsIntersect(s, from)); 
+    Y_ASSERT(!IsIntersect(s, to)); 
+ 
+    const size_t fromSize = from.size(); 
+    const size_t toSize = to.size(); 
+    size_t replacementsCount = 0; 
+    size_t off = fromPos; 
+    size_t srcPos = 0; 
+ 
+    if (toSize > fromSize) { 
+        // string will grow: append to another string 
+        TStringType result; 
+        for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) { 
+            if (!replacementsCount) { 
+                // first replacement occured, we can prepare result string 
+                result.reserve(s.size() + s.size() / 3); 
+            } 
+            result.append(s.begin() + srcPos, s.begin() + off); 
             result.append(to.data(), to.size());
-            srcPos = off + fromSize;
-            ++replacementsCount;
-        }
-        if (replacementsCount) {
-            // append tail
-            result.append(s.begin() + srcPos, s.end());
-            s = std::move(result);
-        }
-        return replacementsCount;
-    }
-
-    // string will not grow: use inplace algo
-    size_t dstPos = 0;
+            srcPos = off + fromSize; 
+            ++replacementsCount; 
+        } 
+        if (replacementsCount) { 
+            // append tail 
+            result.append(s.begin() + srcPos, s.end()); 
+            s = std::move(result); 
+        } 
+        return replacementsCount; 
+    } 
+ 
+    // string will not grow: use inplace algo 
+    size_t dstPos = 0; 
     typename TStringType::value_type* ptr = &*s.begin();
-    for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) {
-        Y_ASSERT(dstPos <= srcPos);
-        MoveBlock<TStringType, TStringViewType, true>(ptr, srcPos, dstPos, off, to, toSize);
-        srcPos = off + fromSize;
-        ++replacementsCount;
-    }
-
-    if (replacementsCount) {
-        // append tail
-        MoveBlock<TStringType, TStringViewType, false>(ptr, srcPos, dstPos, s.size(), to, toSize);
-        s.resize(dstPos);
-    }
-    return replacementsCount;
-}
-
-/// Replaces all occurences of the 'from' symbol in a string to the 'to' symbol.
-template <class TStringType>
-inline size_t SubstCharGlobalImpl(TStringType& s, typename TStringType::value_type from, typename TStringType::value_type to, size_t fromPos = 0) {
-    if (fromPos >= s.size()) {
-        return 0;
-    }
-
-    size_t result = 0;
-    fromPos = s.find(from, fromPos);
-
-    // s.begin() might cause memory copying, so call it only if needed
-    if (fromPos != TStringType::npos) {
+    for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) { 
+        Y_ASSERT(dstPos <= srcPos); 
+        MoveBlock<TStringType, TStringViewType, true>(ptr, srcPos, dstPos, off, to, toSize); 
+        srcPos = off + fromSize; 
+        ++replacementsCount; 
+    } 
+ 
+    if (replacementsCount) { 
+        // append tail 
+        MoveBlock<TStringType, TStringViewType, false>(ptr, srcPos, dstPos, s.size(), to, toSize); 
+        s.resize(dstPos); 
+    } 
+    return replacementsCount; 
+} 
+ 
+/// Replaces all occurences of the 'from' symbol in a string to the 'to' symbol. 
+template <class TStringType> 
+inline size_t SubstCharGlobalImpl(TStringType& s, typename TStringType::value_type from, typename TStringType::value_type to, size_t fromPos = 0) { 
+    if (fromPos >= s.size()) { 
+        return 0; 
+    } 
+ 
+    size_t result = 0; 
+    fromPos = s.find(from, fromPos); 
+ 
+    // s.begin() might cause memory copying, so call it only if needed 
+    if (fromPos != TStringType::npos) { 
         auto* it = &*s.begin() + fromPos;
-        *it = to;
-        ++result;
-        // at this point string is copied and it's safe to use constant s.end() to iterate
+        *it = to; 
+        ++result; 
+        // at this point string is copied and it's safe to use constant s.end() to iterate 
         const auto* const sEnd = &*s.end();
-        // unrolled loop goes first because it is more likely that `it` will be properly aligned
-        for (const auto* const end = sEnd - (sEnd - it) % 4; it < end;) {
-            if (*it == from) {
-                *it = to;
-                ++result;
-            }
-            ++it;
-            if (*it == from) {
-                *it = to;
-                ++result;
-            }
-            ++it;
-            if (*it == from) {
-                *it = to;
-                ++result;
-            }
-            ++it;
-            if (*it == from) {
-                *it = to;
-                ++result;
-            }
-            ++it;
-        }
-        for (; it < sEnd; ++it) {
-            if (*it == from) {
-                *it = to;
-                ++result;
-            }
-        }
-    }
-
-    return result;
-}
-
-/* Standard says that `char16_t` is a distinct type and has same size, signedness and alignment as
- * `std::uint_least16_t`, so we check if `char16_t` has same signedness and size as `wchar16` to be
- * sure that we can make safe casts between values of these types and pointers.
- */
-static_assert(sizeof(wchar16) == sizeof(char16_t), "");
+        // unrolled loop goes first because it is more likely that `it` will be properly aligned 
+        for (const auto* const end = sEnd - (sEnd - it) % 4; it < end;) { 
+            if (*it == from) { 
+                *it = to; 
+                ++result; 
+            } 
+            ++it; 
+            if (*it == from) { 
+                *it = to; 
+                ++result; 
+            } 
+            ++it; 
+            if (*it == from) { 
+                *it = to; 
+                ++result; 
+            } 
+            ++it; 
+            if (*it == from) { 
+                *it = to; 
+                ++result; 
+            } 
+            ++it; 
+        } 
+        for (; it < sEnd; ++it) { 
+            if (*it == from) { 
+                *it = to; 
+                ++result; 
+            } 
+        } 
+    } 
+ 
+    return result; 
+} 
+ 
+/* Standard says that `char16_t` is a distinct type and has same size, signedness and alignment as 
+ * `std::uint_least16_t`, so we check if `char16_t` has same signedness and size as `wchar16` to be 
+ * sure that we can make safe casts between values of these types and pointers. 
+ */ 
+static_assert(sizeof(wchar16) == sizeof(char16_t), ""); 
 static_assert(sizeof(wchar32) == sizeof(char32_t), "");
-static_assert(std::is_unsigned<wchar16>::value == std::is_unsigned<char16_t>::value, "");
+static_assert(std::is_unsigned<wchar16>::value == std::is_unsigned<char16_t>::value, ""); 
 static_assert(std::is_unsigned<wchar32>::value == std::is_unsigned<char32_t>::value, "");
-
-size_t SubstGlobal(TString& text, const TStringBuf what, const TStringBuf with, size_t from) {
-    return SubstGlobalImpl(text, what, with, from);
-}
-
-size_t SubstGlobal(std::string& text, const TStringBuf what, const TStringBuf with, size_t from) {
-    return SubstGlobalImpl(text, what, with, from);
-}
-
-size_t SubstGlobal(TUtf16String& text, const TWtringBuf what, const TWtringBuf with, size_t from) {
-    return SubstGlobalImpl(text, what, with, from);
-}
-
+ 
+size_t SubstGlobal(TString& text, const TStringBuf what, const TStringBuf with, size_t from) { 
+    return SubstGlobalImpl(text, what, with, from); 
+} 
+ 
+size_t SubstGlobal(std::string& text, const TStringBuf what, const TStringBuf with, size_t from) { 
+    return SubstGlobalImpl(text, what, with, from); 
+} 
+ 
+size_t SubstGlobal(TUtf16String& text, const TWtringBuf what, const TWtringBuf with, size_t from) { 
+    return SubstGlobalImpl(text, what, with, from); 
+} 
+ 
 size_t SubstGlobal(TUtf32String& text, const TUtf32StringBuf what, const TUtf32StringBuf with, size_t from) {
     return SubstGlobalImpl(text, what, with, from);
 }
 
-size_t SubstGlobal(std::u16string& text, const TWtringBuf what, const TWtringBuf with, size_t from) {
+size_t SubstGlobal(std::u16string& text, const TWtringBuf what, const TWtringBuf with, size_t from) { 
     return SubstGlobalImpl(text,
                            std::u16string_view(reinterpret_cast<const char16_t*>(what.data()), what.size()),
                            std::u16string_view(reinterpret_cast<const char16_t*>(with.data()), with.size()),
                            from);
-}
-
-size_t SubstGlobal(TString& text, char what, char with, size_t from) {
-    return SubstCharGlobalImpl(text, what, with, from);
-}
-
-size_t SubstGlobal(std::string& text, char what, char with, size_t from) {
-    return SubstCharGlobalImpl(text, what, with, from);
-}
-
-size_t SubstGlobal(TUtf16String& text, wchar16 what, wchar16 with, size_t from) {
-    return SubstCharGlobalImpl(text, (char16_t)what, (char16_t)with, from);
-}
-
-size_t SubstGlobal(std::u16string& text, wchar16 what, wchar16 with, size_t from) {
-    return SubstCharGlobalImpl(text, (char16_t)what, (char16_t)with, from);
-}
+} 
+ 
+size_t SubstGlobal(TString& text, char what, char with, size_t from) { 
+    return SubstCharGlobalImpl(text, what, with, from); 
+} 
+ 
+size_t SubstGlobal(std::string& text, char what, char with, size_t from) { 
+    return SubstCharGlobalImpl(text, what, with, from); 
+} 
+ 
+size_t SubstGlobal(TUtf16String& text, wchar16 what, wchar16 with, size_t from) { 
+    return SubstCharGlobalImpl(text, (char16_t)what, (char16_t)with, from); 
+} 
+ 
+size_t SubstGlobal(std::u16string& text, wchar16 what, wchar16 with, size_t from) { 
+    return SubstCharGlobalImpl(text, (char16_t)what, (char16_t)with, from); 
+} 
 
 size_t SubstGlobal(TUtf32String& text, wchar32 what, wchar32 with, size_t from) {
     return SubstCharGlobalImpl(text, (char32_t)what, (char32_t)with, from);
diff --git a/util/string/subst.h b/util/string/subst.h
index 45b622fbef..32a2789801 100644
--- a/util/string/subst.h
+++ b/util/string/subst.h
@@ -1,44 +1,44 @@
 #pragma once
 
-#include <util/generic/fwd.h>
+#include <util/generic/fwd.h> 
 
-#include <stlfwd>
+#include <stlfwd> 
 
-/* Replace all occurences of substring `what` with string `with` starting from position `from`.
- *
- * @param text      String to modify.
- * @param what      Substring to replace.
- * @param with      Substring to use as replacement.
- * @param from      Position at with to start replacement.
- *
- * @return          Number of replacements occured.
- */
-size_t SubstGlobal(TString& text, TStringBuf what, TStringBuf with, size_t from = 0);
-size_t SubstGlobal(std::string& text, TStringBuf what, TStringBuf with, size_t from = 0);
-size_t SubstGlobal(TUtf16String& text, TWtringBuf what, TWtringBuf with, size_t from = 0);
-size_t SubstGlobal(std::u16string& text, TWtringBuf what, TWtringBuf with, size_t from = 0);
+/* Replace all occurences of substring `what` with string `with` starting from position `from`. 
+ * 
+ * @param text      String to modify. 
+ * @param what      Substring to replace. 
+ * @param with      Substring to use as replacement. 
+ * @param from      Position at with to start replacement. 
+ * 
+ * @return          Number of replacements occured. 
+ */ 
+size_t SubstGlobal(TString& text, TStringBuf what, TStringBuf with, size_t from = 0); 
+size_t SubstGlobal(std::string& text, TStringBuf what, TStringBuf with, size_t from = 0); 
+size_t SubstGlobal(TUtf16String& text, TWtringBuf what, TWtringBuf with, size_t from = 0); 
+size_t SubstGlobal(std::u16string& text, TWtringBuf what, TWtringBuf with, size_t from = 0); 
 size_t SubstGlobal(TUtf32String& text, TUtf32StringBuf what, TUtf32StringBuf with, size_t from = 0);
 
-/* Replace all occurences of character `what` with character `with` starting from position `from`.
- *
- * @param text      String to modify.
- * @param what      Character to replace.
- * @param with      Character to use as replacement.
- * @param from      Position at with to start replacement.
- *
- * @return          Number of replacements occured.
- */
-size_t SubstGlobal(TString& text, char what, char with, size_t from = 0);
-size_t SubstGlobal(std::string& text, char what, char with, size_t from = 0);
-size_t SubstGlobal(TUtf16String& text, wchar16 what, wchar16 with, size_t from = 0);
-size_t SubstGlobal(std::u16string& text, wchar16 what, wchar16 with, size_t from = 0);
+/* Replace all occurences of character `what` with character `with` starting from position `from`. 
+ * 
+ * @param text      String to modify. 
+ * @param what      Character to replace. 
+ * @param with      Character to use as replacement. 
+ * @param from      Position at with to start replacement. 
+ * 
+ * @return          Number of replacements occured. 
+ */ 
+size_t SubstGlobal(TString& text, char what, char with, size_t from = 0); 
+size_t SubstGlobal(std::string& text, char what, char with, size_t from = 0); 
+size_t SubstGlobal(TUtf16String& text, wchar16 what, wchar16 with, size_t from = 0); 
+size_t SubstGlobal(std::u16string& text, wchar16 what, wchar16 with, size_t from = 0); 
 size_t SubstGlobal(TUtf32String& text, wchar32 what, wchar32 with, size_t from = 0);
 
-// TODO(yazevnul):
-// - rename `SubstGlobal` to `ReplaceAll` for convenience
+// TODO(yazevnul): 
+// - rename `SubstGlobal` to `ReplaceAll` for convenience 
 // - add `SubstGlobalCopy(TStringBuf)` for convenience
-// - add `RemoveAll(text, what, from)` as a shortcut for `SubstGlobal(text, what, "", from)`
-// - rename file to `replace.h`
+// - add `RemoveAll(text, what, from)` as a shortcut for `SubstGlobal(text, what, "", from)` 
+// - rename file to `replace.h` 
 
 /* Replace all occurences of substring or character `what` with string or character `with` starting from position `from`, and return result string.
  *
diff --git a/util/string/subst_ut.cpp b/util/string/subst_ut.cpp
index 21eccef779..fc88469ceb 100644
--- a/util/string/subst_ut.cpp
+++ b/util/string/subst_ut.cpp
@@ -4,7 +4,7 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-Y_UNIT_TEST_SUITE(TStringSubst) {
+Y_UNIT_TEST_SUITE(TStringSubst) { 
     static const size_t MIN_FROM_CTX = 4;
     static const TVector<TString> ALL_FROM{TString("F"), TString("FF")};
     static const TVector<TString> ALL_TO{TString(""), TString("T"), TString("TT"), TString("TTT")};
@@ -24,7 +24,7 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
         }
     }
 
-    Y_UNIT_TEST(TestSubstGlobalNoSubstA) {
+    Y_UNIT_TEST(TestSubstGlobalNoSubstA) { 
         for (const auto& from : ALL_FROM) {
             const size_t fromSz = from.size();
             const size_t minSz = fromSz;
@@ -40,7 +40,7 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
         }
     }
 
-    Y_UNIT_TEST(TestSubstGlobalNoSubstB) {
+    Y_UNIT_TEST(TestSubstGlobalNoSubstB) { 
         for (const auto& from : ALL_FROM) {
             const size_t fromSz = from.size();
             const size_t minSz = fromSz;
@@ -103,23 +103,23 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
         }
     }
 
-    Y_UNIT_TEST(TestSubstGlobalSubst1) {
+    Y_UNIT_TEST(TestSubstGlobalSubst1) { 
         DoTestSubstGlobal(1);
     }
 
-    Y_UNIT_TEST(TestSubstGlobalSubst2) {
+    Y_UNIT_TEST(TestSubstGlobalSubst2) { 
         DoTestSubstGlobal(2);
     }
 
-    Y_UNIT_TEST(TestSubstGlobalSubst3) {
+    Y_UNIT_TEST(TestSubstGlobalSubst3) { 
         DoTestSubstGlobal(3);
     }
 
-    Y_UNIT_TEST(TestSubstGlobalSubst4) {
+    Y_UNIT_TEST(TestSubstGlobalSubst4) { 
         DoTestSubstGlobal(4);
     }
 
-    Y_UNIT_TEST(TestSubstGlobalOld) {
+    Y_UNIT_TEST(TestSubstGlobalOld) { 
         TString s;
         s = "aaa";
         SubstGlobal(s, "a", "bb");
@@ -160,7 +160,7 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
         UNIT_ASSERT_EQUAL(s10, TString("Москва Париж"));
     }
 
-    Y_UNIT_TEST(TestSubstCharGlobal) {
+    Y_UNIT_TEST(TestSubstCharGlobal) { 
         TUtf16String w = u"abcdabcd";
         SubstGlobal(w, wchar16('b'), wchar16('B'), 3);
         UNIT_ASSERT_EQUAL(w, u"abcdaBcd");
@@ -180,74 +180,74 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
         UNIT_ASSERT_EQUAL(s2, TString("abb"));
     }
 
-    Y_UNIT_TEST(TestSubstStdString) {
+    Y_UNIT_TEST(TestSubstStdString) { 
         std::string s = "aaa";
         SubstGlobal(s, "a", "b", 1);
         UNIT_ASSERT_EQUAL(s, "abb");
     }
-
+ 
     Y_UNIT_TEST(TestSubstStdStringRet) {
         const std::string s1 = "aaa";
         const std::string s2 = SubstGlobalCopy(s1, "a", "b", 1);
         UNIT_ASSERT_EQUAL(s2, "abb");
     }
 
-    Y_UNIT_TEST(TestSubstGlobalChar) {
-        {
+    Y_UNIT_TEST(TestSubstGlobalChar) { 
+        { 
             const TString s = "a";
             const TString st = "b";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aa";
             const TString st = "bb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaa";
             const TString st = "bbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaaa";
             const TString st = "bbbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaaaa";
             const TString st = "bbbbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaaaaa";
             const TString st = "bbbbbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaaaaaa";
             const TString st = "bbbbbbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-        {
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+        { 
             const TString s = "aaaaaaaa";
             const TString st = "bbbbbbbb";
             TString ss = s;
-            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b'));
-            UNIT_ASSERT_VALUES_EQUAL(st, ss);
-        }
-    }
+            UNIT_ASSERT_VALUES_EQUAL(s.size(), SubstGlobal(ss, 'a', 'b')); 
+            UNIT_ASSERT_VALUES_EQUAL(st, ss); 
+        } 
+    } 
 }
diff --git a/util/string/type.cpp b/util/string/type.cpp
index 49671c02c2..668b445afa 100644
--- a/util/string/type.cpp
+++ b/util/string/type.cpp
@@ -24,11 +24,11 @@ static bool IsNumberT(const TStringType& s) noexcept {
     return std::all_of(s.begin(), s.end(), IsAsciiDigit<typename TStringType::value_type>);
 }
 
-bool IsNumber(const TStringBuf s) noexcept {
+bool IsNumber(const TStringBuf s) noexcept { 
     return IsNumberT(s);
 }
 
-bool IsNumber(const TWtringBuf s) noexcept {
+bool IsNumber(const TWtringBuf s) noexcept { 
     return IsNumberT(s);
 }
 
@@ -41,11 +41,11 @@ static bool IsHexNumberT(const TStringType& s) noexcept {
     return std::all_of(s.begin(), s.end(), IsAsciiHex<typename TStringType::value_type>);
 }
 
-bool IsHexNumber(const TStringBuf s) noexcept {
+bool IsHexNumber(const TStringBuf s) noexcept { 
     return IsHexNumberT(s);
 }
 
-bool IsHexNumber(const TWtringBuf s) noexcept {
+bool IsHexNumber(const TWtringBuf s) noexcept { 
     return IsHexNumberT(s);
 }
 
diff --git a/util/string/type_ut.cpp b/util/string/type_ut.cpp
index 03e7af62bd..7f342a8e24 100644
--- a/util/string/type_ut.cpp
+++ b/util/string/type_ut.cpp
@@ -4,15 +4,15 @@
 
 #include <util/charset/wide.h>
 
-Y_UNIT_TEST_SUITE(TStringClassify) {
-    Y_UNIT_TEST(TestIsSpace) {
+Y_UNIT_TEST_SUITE(TStringClassify) { 
+    Y_UNIT_TEST(TestIsSpace) { 
         UNIT_ASSERT_EQUAL(IsSpace(" "), true);
         UNIT_ASSERT_EQUAL(IsSpace("\t\r\n"), true);
         UNIT_ASSERT_EQUAL(IsSpace(""), false);
         UNIT_ASSERT_EQUAL(IsSpace("   a"), false);
     }
 
-    Y_UNIT_TEST(TestIsTrue) {
+    Y_UNIT_TEST(TestIsTrue) { 
         UNIT_ASSERT(IsTrue("1"));
         UNIT_ASSERT(IsTrue("yes"));
         UNIT_ASSERT(IsTrue("YeS"));
@@ -26,7 +26,7 @@ Y_UNIT_TEST_SUITE(TStringClassify) {
         UNIT_ASSERT(!IsTrue("foobar"));
     }
 
-    Y_UNIT_TEST(TestIsFalse) {
+    Y_UNIT_TEST(TestIsFalse) { 
         UNIT_ASSERT(IsFalse("0"));
         UNIT_ASSERT(IsFalse("no"));
         UNIT_ASSERT(IsFalse("off"));
@@ -39,7 +39,7 @@ Y_UNIT_TEST_SUITE(TStringClassify) {
         UNIT_ASSERT(!IsFalse("foobar"));
     }
 
-    Y_UNIT_TEST(TestIsNumber) {
+    Y_UNIT_TEST(TestIsNumber) { 
         UNIT_ASSERT(IsNumber("0"));
         UNIT_ASSERT(IsNumber("12345678901234567890"));
         UNIT_ASSERT(!IsNumber("1234567890a"));
@@ -54,7 +54,7 @@ Y_UNIT_TEST_SUITE(TStringClassify) {
         UNIT_ASSERT(!IsNumber(u"foobar"));
     }
 
-    Y_UNIT_TEST(TestIsHexNumber) {
+    Y_UNIT_TEST(TestIsHexNumber) { 
         UNIT_ASSERT(IsHexNumber("0"));
         UNIT_ASSERT(IsHexNumber("aaaadddAAAAA"));
         UNIT_ASSERT(IsHexNumber("0123456789ABCDEFabcdef"));
diff --git a/util/string/util.h b/util/string/util.h
index 0d77a5042b..4c9732fcaf 100644
--- a/util/string/util.h
+++ b/util/string/util.h
@@ -132,7 +132,7 @@ public:
     /// strsep + remember character that was destroyed
     char* sep(char*& s, char& sep_char) const {
         if (!s)
-            return nullptr;
+            return nullptr; 
         char* ret = s;
         char* next = brk(ret);
         if (*next) {
@@ -141,7 +141,7 @@ public:
             s = next + 1;
         } else {
             sep_char = 0;
-            s = nullptr;
+            s = nullptr; 
         }
         return ret;
     }
diff --git a/util/string/util_ut.cpp b/util/string/util_ut.cpp
index 18a2d8e195..706b63cfdc 100644
--- a/util/string/util_ut.cpp
+++ b/util/string/util_ut.cpp
@@ -20,7 +20,7 @@ public:
         UNIT_ASSERT_EQUAL(strcmp(rul.sep(s1), ""), 0);
         UNIT_ASSERT_EQUAL(strcmp(rul.sep(s1), "%^&"), 0);
         UNIT_ASSERT_EQUAL(strcmp(rul.sep(s1), "+-"), 0);
-        UNIT_ASSERT_EQUAL(rul.sep(s1), nullptr);
+        UNIT_ASSERT_EQUAL(rul.sep(s1), nullptr); 
     }
 
     void TestRemoveAll() {
@@ -35,7 +35,7 @@ public:
             {"hello world", 'x', "hello world"},
         };
 
-        for (const T* t = tests; t != std::end(tests); ++t) {
+        for (const T* t = tests; t != std::end(tests); ++t) { 
             TString str(t->Str);
             RemoveAll(str, t->Ch);
             UNIT_ASSERT_EQUAL(t->Result, str);
diff --git a/util/string/vector.h b/util/string/vector.h
index e36c348bbe..fce7e4ab00 100644
--- a/util/string/vector.h
+++ b/util/string/vector.h
@@ -1,14 +1,14 @@
 #pragma once
 
-#include "cast.h"
+#include "cast.h" 
 #include "split.h"
-
+ 
 #include <util/generic/map.h>
-#include <util/generic/strbuf.h>
+#include <util/generic/strbuf.h> 
 #include <util/generic/string.h>
 #include <util/generic/vector.h>
 #include <util/string/cast.h>
-#include <util/system/yassert.h>
+#include <util/system/yassert.h> 
 
 #define KEEP_EMPTY_TOKENS 0x01
 
@@ -120,8 +120,8 @@ inline TString JoinVectorIntoString(const TVector<T>& v, size_t index, size_t co
 TUtf16String JoinStrings(const TVector<TUtf16String>& v, const TWtringBuf delim);
 TUtf16String JoinStrings(const TVector<TUtf16String>& v, size_t index, size_t count, const TWtringBuf delim);
 
-//! Converts vector of strings to vector of type T variables
-template <typename T, typename TStringType>
+//! Converts vector of strings to vector of type T variables 
+template <typename T, typename TStringType> 
 TVector<T> Scan(const TVector<TStringType>& input) {
     TVector<T> output;
     output.reserve(input.size());
diff --git a/util/string/vector_ut.cpp b/util/string/vector_ut.cpp
index 817120f268..9c4222f9ee 100644
--- a/util/string/vector_ut.cpp
+++ b/util/string/vector_ut.cpp
@@ -4,14 +4,14 @@
 #include "cast.h"
 #include "vector.h"
 
-Y_UNIT_TEST_SUITE(TStringJoinTest) {
-    Y_UNIT_TEST(Test1) {
+Y_UNIT_TEST_SUITE(TStringJoinTest) { 
+    Y_UNIT_TEST(Test1) { 
         TVector<TUtf16String> v;
 
         UNIT_ASSERT_EQUAL(JoinStrings(v, ToWtring("")), ToWtring(""));
     }
 
-    Y_UNIT_TEST(Test2) {
+    Y_UNIT_TEST(Test2) { 
         TVector<TUtf16String> v;
 
         v.push_back(ToWtring("1"));
@@ -20,7 +20,7 @@ Y_UNIT_TEST_SUITE(TStringJoinTest) {
         UNIT_ASSERT_EQUAL(JoinStrings(v, ToWtring(" ")), ToWtring("1 2"));
     }
 
-    Y_UNIT_TEST(Test3) {
+    Y_UNIT_TEST(Test3) { 
         TVector<TUtf16String> v;
 
         v.push_back(ToWtring("1"));
@@ -29,7 +29,7 @@ Y_UNIT_TEST_SUITE(TStringJoinTest) {
         UNIT_ASSERT_EQUAL(JoinStrings(v, 1, 10, ToWtring(" ")), ToWtring("2"));
     }
 
-    Y_UNIT_TEST(TestJoinWStrings) {
+    Y_UNIT_TEST(TestJoinWStrings) { 
         const TUtf16String str = u"Яндекс";
         const TVector<TUtf16String> v(1, str);