Restoring authorship annotation for Ilnur Khuziev <ilnur.khuziev@yandex.ru>. Commit 1 of 2.

71 files changed, 531 insertions, 531 deletions

diff --git a/util/system/align_ut.cpp b/util/system/align_ut.cpp
index 3ba3a3442b..0d80d42e6a 100644
--- a/util/system/align_ut.cpp
+++ b/util/system/align_ut.cpp
@@ -1,6 +1,6 @@
 #include "align.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 class TAlignTest: public TTestBase {
     UNIT_TEST_SUITE(TAlignTest);
diff --git a/util/system/atexit_ut.cpp b/util/system/atexit_ut.cpp
index 953f432811..a26f5abb35 100644
--- a/util/system/atexit_ut.cpp
+++ b/util/system/atexit_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "atexit.h"
 
diff --git a/util/system/atomic_ut.cpp b/util/system/atomic_ut.cpp
index 07211ffba7..235d2dd060 100644
--- a/util/system/atomic_ut.cpp
+++ b/util/system/atomic_ut.cpp
@@ -1,6 +1,6 @@
 #include "atomic.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/ylimits.h>
 
diff --git a/util/system/backtrace_ut.cpp b/util/system/backtrace_ut.cpp
index 9b5ead71bc..7e4919a1bb 100644
--- a/util/system/backtrace_ut.cpp
+++ b/util/system/backtrace_ut.cpp
@@ -1,7 +1,7 @@
 #include "backtrace.h"
 
 #include <util/generic/array_ref.h>
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/stream/output.h>
 
diff --git a/util/system/benchmark/cpu_id/main.cpp b/util/system/benchmark/cpu_id/main.cpp
index 8efe539983..a073543508 100644
--- a/util/system/benchmark/cpu_id/main.cpp
+++ b/util/system/benchmark/cpu_id/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h>
+#include <library/cpp/testing/benchmark/bench.h> 
 
 #include <util/system/cpu_id.h>
 
diff --git a/util/system/benchmark/create_destroy_thread/main.cpp b/util/system/benchmark/create_destroy_thread/main.cpp
index 0ca2a9d96f..ebafa960d2 100644
--- a/util/system/benchmark/create_destroy_thread/main.cpp
+++ b/util/system/benchmark/create_destroy_thread/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h>
+#include <library/cpp/testing/benchmark/bench.h> 
 
 #include <util/system/thread.h>
 
diff --git a/util/system/benchmark/rdtsc/main.cpp b/util/system/benchmark/rdtsc/main.cpp
index 8189d10f06..d51ea9d172 100644
--- a/util/system/benchmark/rdtsc/main.cpp
+++ b/util/system/benchmark/rdtsc/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h>
+#include <library/cpp/testing/benchmark/bench.h> 
 
 #include <util/system/datetime.h>
 #include <util/generic/xrange.h>
diff --git a/util/system/byteorder_ut.cpp b/util/system/byteorder_ut.cpp
index 39b8603d3f..f53b19af48 100644
--- a/util/system/byteorder_ut.cpp
+++ b/util/system/byteorder_ut.cpp
@@ -1,6 +1,6 @@
 #include "byteorder.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 class TByteOrderTest: public TTestBase {
     UNIT_TEST_SUITE(TByteOrderTest);
diff --git a/util/system/compat_ut.cpp b/util/system/compat_ut.cpp
index dbd9289c17..eac69c58cb 100644
--- a/util/system/compat_ut.cpp
+++ b/util/system/compat_ut.cpp
@@ -1,6 +1,6 @@
 #include "compat.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/folder/dirut.h>
 #include <util/stream/output.h>
diff --git a/util/system/compiler.h b/util/system/compiler.h
index b373edcc46..d534f92779 100644
--- a/util/system/compiler.h
+++ b/util/system/compiler.h
@@ -187,15 +187,15 @@
     #define Y_PUBLIC
 #endif
 
-#if !defined(Y_UNUSED) && !defined(__cplusplus)
+#if !defined(Y_UNUSED) && !defined(__cplusplus) 
     #define Y_UNUSED(var) (void)(var)
 #endif
-#if !defined(Y_UNUSED) && defined(__cplusplus)
+#if !defined(Y_UNUSED) && defined(__cplusplus) 
 template <class... Types>
 constexpr Y_FORCE_INLINE int Y_UNUSED(Types&&...) {
     return 0;
 };
-#endif
+#endif 
 
 /**
  * @def Y_ASSUME
@@ -553,15 +553,15 @@ _YandexAbort();
 // Memory sanitizer sometimes doesn't correctly set parameter shadow of constant functions.
 #if (defined(__clang__) || defined(__GNUC__)) && !defined(_msan_enabled_)
     /**
- * @def Y_CONST_FUNCTION
-   methods and functions, marked with this method are promised to:
-     1. do not have side effects
-     2. this method do not read global memory
-   NOTE: this attribute can't be set for methods that depend on data, pointed by this
-   this allow compilers to do hard optimization of that functions
-   NOTE: in common case this attribute can't be set if method have pointer-arguments
-   NOTE: as result there no any reason to discard result of such method
-*/
+ * @def Y_CONST_FUNCTION 
+   methods and functions, marked with this method are promised to: 
+     1. do not have side effects 
+     2. this method do not read global memory 
+   NOTE: this attribute can't be set for methods that depend on data, pointed by this 
+   this allow compilers to do hard optimization of that functions 
+   NOTE: in common case this attribute can't be set if method have pointer-arguments 
+   NOTE: as result there no any reason to discard result of such method 
+*/ 
     #define Y_CONST_FUNCTION [[gnu::const]]
 #endif
 
@@ -571,13 +571,13 @@ _YandexAbort();
 
 #if defined(__clang__) || defined(__GNUC__)
     /**
- * @def Y_PURE_FUNCTION
-   methods and functions, marked with this method are promised to:
-     1. do not have side effects
-     2. result will be the same if no global memory changed
-   this allow compilers to do hard optimization of that functions
-   NOTE: as result there no any reason to discard result of such method
-*/
+ * @def Y_PURE_FUNCTION 
+   methods and functions, marked with this method are promised to: 
+     1. do not have side effects 
+     2. result will be the same if no global memory changed 
+   this allow compilers to do hard optimization of that functions 
+   NOTE: as result there no any reason to discard result of such method 
+*/ 
     #define Y_PURE_FUNCTION [[gnu::pure]]
 #endif
 
diff --git a/util/system/compiler_ut.cpp b/util/system/compiler_ut.cpp
index f93b1c0850..63cc6cdbeb 100644
--- a/util/system/compiler_ut.cpp
+++ b/util/system/compiler_ut.cpp
@@ -1,6 +1,6 @@
 #include "compiler.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TCompilerTest) {
     Y_UNIT_TEST(TestPragmaNoWshadow) {
diff --git a/util/system/condvar_ut.cpp b/util/system/condvar_ut.cpp
index 5130a18d32..cc8ae57dd2 100644
--- a/util/system/condvar_ut.cpp
+++ b/util/system/condvar_ut.cpp
@@ -2,7 +2,7 @@
 #include "guard.h"
 #include "condvar.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/system/atomic.h>
 #include <util/system/atomic_ops.h>
diff --git a/util/system/context_ut.cpp b/util/system/context_ut.cpp
index 45cb0249f7..042a934bab 100644
--- a/util/system/context_ut.cpp
+++ b/util/system/context_ut.cpp
@@ -1,6 +1,6 @@
 #include "context.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/deque.h>
 #include <util/generic/yexception.h>
diff --git a/util/system/cpu_id.cpp b/util/system/cpu_id.cpp
index 598c71f4d9..aa9c180c64 100644
--- a/util/system/cpu_id.cpp
+++ b/util/system/cpu_id.cpp
@@ -118,10 +118,10 @@ bool NX86::HaveSSE42() noexcept {
     return (TX86CpuInfo(0x1).ECX >> 20) & 1u;
 }
 
-bool NX86::HaveF16C() noexcept {
-    return (TX86CpuInfo(0x1).ECX >> 29) & 1u;
-}
-
+bool NX86::HaveF16C() noexcept { 
+    return (TX86CpuInfo(0x1).ECX >> 29) & 1u; 
+} 
+ 
 bool NX86::HavePOPCNT() noexcept {
     return (TX86CpuInfo(0x1).ECX >> 23) & 1u;
 }
diff --git a/util/system/cpu_id.h b/util/system/cpu_id.h
index 3c49e728a7..f6ec49a9fa 100644
--- a/util/system/cpu_id.h
+++ b/util/system/cpu_id.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "types.h"
-#include "compiler.h"
+#include "compiler.h" 
 #include <util/generic/singleton.h>
 
 #define Y_CPU_ID_ENUMERATE(F) \
@@ -11,7 +11,7 @@
     F(SSSE3)                  \
     F(SSE41)                  \
     F(SSE42)                  \
-    F(F16C)                   \
+    F(F16C)                   \ 
     F(POPCNT)                 \
     F(BMI1)                   \
     F(BMI2)                   \
@@ -78,11 +78,11 @@ namespace NX86 {
     bool CpuId(ui32 op, ui32 res[4]) noexcept;
     bool CpuId(ui32 op, ui32 subOp, ui32 res[4]) noexcept;
 
-#define Y_DEF_NAME(X) Y_CONST_FUNCTION bool Have##X() noexcept;
+#define Y_DEF_NAME(X) Y_CONST_FUNCTION bool Have##X() noexcept; 
     Y_CPU_ID_ENUMERATE(Y_DEF_NAME)
 #undef Y_DEF_NAME
 
-#define Y_DEF_NAME(X) Y_CONST_FUNCTION bool CachedHave##X() noexcept;
+#define Y_DEF_NAME(X) Y_CONST_FUNCTION bool CachedHave##X() noexcept; 
     Y_CPU_ID_ENUMERATE_OUTLINED_CACHED_DEFINE(Y_DEF_NAME)
 #undef Y_DEF_NAME
 
diff --git a/util/system/cpu_id_ut.cpp b/util/system/cpu_id_ut.cpp
index 68f1f8aac7..ac41440900 100644
--- a/util/system/cpu_id_ut.cpp
+++ b/util/system/cpu_id_ut.cpp
@@ -2,7 +2,7 @@
 
 #include "platform.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 // There are no tests yet for instructions that use 512-bit wide registers because they are not
 // supported by some compilers yet.
@@ -18,7 +18,7 @@ static void ExecuteSSE3Instruction();
 static void ExecuteSSSE3Instruction();
 static void ExecuteSSE41Instruction();
 static void ExecuteSSE42Instruction();
-static void ExecuteF16CInstruction();
+static void ExecuteF16CInstruction(); 
 static void ExecuteAVXInstruction();
 static void ExecuteAVX2Instruction();
 static void ExecutePOPCNTInstruction();
@@ -134,13 +134,13 @@ void ExecuteSSE42Instruction() {
                          : "eax");
 }
 
-void ExecuteF16CInstruction() {
-    __asm__ __volatile__("vcvtph2ps %%xmm0, %%ymm0\n"
-                         :
-                         :
-                         : "xmm0");
-}
-
+void ExecuteF16CInstruction() { 
+    __asm__ __volatile__("vcvtph2ps %%xmm0, %%ymm0\n" 
+                         : 
+                         : 
+                         : "xmm0"); 
+} 
+ 
 void ExecuteAVXInstruction() {
     __asm__ __volatile__("vzeroupper\n"
                          :
@@ -276,9 +276,9 @@ void ExecuteSSE41Instruction() {
 void ExecuteSSE42Instruction() {
 }
 
-void ExecuteF16CInstruction() {
-}
-
+void ExecuteF16CInstruction() { 
+} 
+ 
 void ExecuteAVXInstruction() {
 }
 
@@ -373,9 +373,9 @@ void ExecuteSSE41Instruction() {
 void ExecuteSSE42Instruction() {
 }
 
-void ExecuteF16CInstruction() {
-}
-
+void ExecuteF16CInstruction() { 
+} 
+ 
 void ExecuteAVXInstruction() {
 }
 
diff --git a/util/system/daemon_ut.cpp b/util/system/daemon_ut.cpp
index f93b9a9645..5a0201185c 100644
--- a/util/system/daemon_ut.cpp
+++ b/util/system/daemon_ut.cpp
@@ -1,6 +1,6 @@
 #include "daemon.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/network/pair.h>
 #include <util/network/socket.h>
diff --git a/util/system/defaults.h b/util/system/defaults.h
index dcd7abea38..325480a55b 100644
--- a/util/system/defaults.h
+++ b/util/system/defaults.h
@@ -83,14 +83,14 @@
 
 #ifdef NDEBUG
     #define Y_IF_DEBUG(X)
-    #ifdef __cplusplus
-constexpr bool Y_IS_DEBUG_BUILD = false;
-    #endif
+    #ifdef __cplusplus 
+constexpr bool Y_IS_DEBUG_BUILD = false; 
+    #endif 
 #else
     #define Y_IF_DEBUG(X) X
-    #ifdef __cplusplus
-constexpr bool Y_IS_DEBUG_BUILD = true;
-    #endif
+    #ifdef __cplusplus 
+constexpr bool Y_IS_DEBUG_BUILD = true; 
+    #endif 
 #endif
 
 /**
diff --git a/util/system/direct_io_ut.cpp b/util/system/direct_io_ut.cpp
index 839c3de7ca..f8f7ede132 100644
--- a/util/system/direct_io_ut.cpp
+++ b/util/system/direct_io_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/yexception.h>
 #include <util/system/fs.h>
diff --git a/util/system/env.cpp b/util/system/env.cpp
index ead9b566a5..a3d46e48d3 100644
--- a/util/system/env.cpp
+++ b/util/system/env.cpp
@@ -50,18 +50,18 @@ TString GetEnv(const TString& key, const TString& def) {
 }
 
 void SetEnv(const TString& key, const TString& value) {
-    bool isOk = false;
-    int errorCode = 0;
+    bool isOk = false; 
+    int errorCode = 0; 
 #ifdef _win_
     isOk = SetEnvironmentVariable(key.data(), value.data());
-    if (!isOk) {
-        errorCode = GetLastError();
-    }
+    if (!isOk) { 
+        errorCode = GetLastError(); 
+    } 
 #else
     isOk = (0 == setenv(key.data(), value.data(), true /*replace*/));
-    if (!isOk) {
-        errorCode = errno;
-    }
+    if (!isOk) { 
+        errorCode = errno; 
+    } 
 #endif
-    Y_ENSURE_EX(isOk, TSystemError() << "failed to SetEnv with error-code " << errorCode);
+    Y_ENSURE_EX(isOk, TSystemError() << "failed to SetEnv with error-code " << errorCode); 
 }
diff --git a/util/system/env_ut.cpp b/util/system/env_ut.cpp
index e03cc01658..fb8bcd2420 100644
--- a/util/system/env_ut.cpp
+++ b/util/system/env_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/string.h>
 #include "env.h"
diff --git a/util/system/error_ut.cpp b/util/system/error_ut.cpp
index 763b0dddb7..98ea0e9f7d 100644
--- a/util/system/error_ut.cpp
+++ b/util/system/error_ut.cpp
@@ -1,6 +1,6 @@
 #include "error.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/ylimits.h>
 
diff --git a/util/system/event_ut.cpp b/util/system/event_ut.cpp
index 2506cb7a91..40565a8688 100644
--- a/util/system/event_ut.cpp
+++ b/util/system/event_ut.cpp
@@ -1,7 +1,7 @@
 #include "event.h"
 #include "atomic.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/thread/pool.h>
 
diff --git a/util/system/execpath.cpp b/util/system/execpath.cpp
index 33198af58b..c2d798e1c4 100644
--- a/util/system/execpath.cpp
+++ b/util/system/execpath.cpp
@@ -84,7 +84,7 @@ static inline TString FreeBSDGetArgv0() {
 }
 
 static inline bool FreeBSDGuessExecPath(const TString& guessPath, TString& execPath) {
-    if (NFs::Exists(guessPath)) {
+    if (NFs::Exists(guessPath)) { 
         // now it should work for real
         execPath = FreeBSDGetExecPath();
         if (RealPath(execPath) == RealPath(guessPath)) {
diff --git a/util/system/execpath_ut.cpp b/util/system/execpath_ut.cpp
index 16b01466f5..40838e01a7 100644
--- a/util/system/execpath_ut.cpp
+++ b/util/system/execpath_ut.cpp
@@ -1,6 +1,6 @@
 #include "execpath.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "platform.h"
 #include <util/folder/dirut.h>
@@ -11,7 +11,7 @@ Y_UNIT_TEST_SUITE(TExecPathTest) {
         TString persistentExecPath = GetPersistentExecPath();
 
         try {
-            UNIT_ASSERT(NFs::Exists(execPath));
+            UNIT_ASSERT(NFs::Exists(execPath)); 
             UNIT_ASSERT(NFs::Exists(persistentExecPath));
         } catch (...) {
             Cerr << execPath << Endl;
diff --git a/util/system/file_ut.cpp b/util/system/file_ut.cpp
index 941e6a50f3..8b759a8a89 100644
--- a/util/system/file_ut.cpp
+++ b/util/system/file_ut.cpp
@@ -2,7 +2,7 @@
 #include "fs.h"
 #include "tempfile.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/stream/file.h>
 #include <util/generic/yexception.h>
diff --git a/util/system/filemap.cpp b/util/system/filemap.cpp
index 7454a4cb94..42b6b775d2 100644
--- a/util/system/filemap.cpp
+++ b/util/system/filemap.cpp
@@ -31,7 +31,7 @@
 #endif
 
 #include <util/generic/utility.h>
-#include <util/system/sanitizers.h>
+#include <util/system/sanitizers.h> 
 #include "filemap.h"
 
 #undef PAGE_SIZE
@@ -260,7 +260,7 @@ public:
         } else {
             ythrow yexception() << "Can't map " << (unsigned long)size << " bytes at offset " << offset << " of '" << DbgName_ << "': " << LastSystemErrorText();
         }
-        NSan::Unpoison(result.Ptr, result.Size);
+        NSan::Unpoison(result.Ptr, result.Size); 
         if (Mode_ & oPrecharge) {
             NPrivate::Precharge(result.Ptr, result.Size, 0, result.Size);
         }
diff --git a/util/system/filemap.h b/util/system/filemap.h
index 11be64bff4..a1c1c43bc5 100644
--- a/util/system/filemap.h
+++ b/util/system/filemap.h
@@ -255,7 +255,7 @@ public:
     Y_PURE_FUNCTION bool empty() const noexcept {
         return Empty();
     }
-
+ 
     Y_PURE_FUNCTION bool Empty() const noexcept {
         return 0 == Size_;
     }
diff --git a/util/system/filemap_ut.cpp b/util/system/filemap_ut.cpp
index 73f109dc88..415b42ca7d 100644
--- a/util/system/filemap_ut.cpp
+++ b/util/system/filemap_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #ifdef _unix_
     #include <sys/resource.h>
diff --git a/util/system/flock_ut.cpp b/util/system/flock_ut.cpp
index b5f6cb5328..7b4f7e1c5e 100644
--- a/util/system/flock_ut.cpp
+++ b/util/system/flock_ut.cpp
@@ -3,7 +3,7 @@
 #include "guard.h"
 #include "tempfile.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TFileLockTest) {
     Y_UNIT_TEST(TestFlock) {
diff --git a/util/system/fs.cpp b/util/system/fs.cpp
index d2611a8ccc..2ee29591a7 100644
--- a/util/system/fs.cpp
+++ b/util/system/fs.cpp
@@ -12,9 +12,9 @@
 #include <util/memory/tempbuf.h>
 #include <util/stream/file.h>
 #include <util/charset/wide.h>
-#include <util/folder/iterator.h>
-#include <util/system/fstat.h>
-#include <util/folder/path.h>
+#include <util/folder/iterator.h> 
+#include <util/system/fstat.h> 
+#include <util/folder/path.h> 
 
 bool NFs::Remove(const TString& path) {
 #if defined(_win_)
@@ -25,65 +25,65 @@ bool NFs::Remove(const TString& path) {
 }
 
 void NFs::RemoveRecursive(const TString& path) {
-    static const TStringBuf errStr = "error while removing ";
-
-    if (!NFs::Exists(path)) {
-        return;
-    }
-
-    if (!TFileStat(path).IsDir()) {
+    static const TStringBuf errStr = "error while removing "; 
+ 
+    if (!NFs::Exists(path)) { 
+        return; 
+    } 
+ 
+    if (!TFileStat(path).IsDir()) { 
         if (!NFs::Remove(path)) {
-            ythrow TSystemError() << errStr << path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")";
+            ythrow TSystemError() << errStr << path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")"; 
         }
-    }
-
-    TDirIterator dir(path);
-
+    } 
+ 
+    TDirIterator dir(path); 
+ 
     for (auto it = dir.begin(); it != dir.end(); ++it) {
-        switch (it->fts_info) {
-            case FTS_DOT:
-            case FTS_D:
+        switch (it->fts_info) { 
+            case FTS_DOT: 
+            case FTS_D: 
                 break;
-            default:
+            default: 
                 if (!NFs::Remove(it->fts_path)) {
-                    ythrow TSystemError() << errStr << it->fts_path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")";
+                    ythrow TSystemError() << errStr << it->fts_path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")"; 
                 }
-                break;
-        }
-    }
-}
-
+                break; 
+        } 
+    } 
+} 
+ 
 bool NFs::MakeDirectory(const TString& path, EFilePermissions mode) {
-#if defined(_win_)
+#if defined(_win_) 
     Y_UNUSED(mode);
-    return NFsPrivate::WinMakeDirectory(path);
-#else
+    return NFsPrivate::WinMakeDirectory(path); 
+#else 
     return mkdir(path.data(), mode) == 0;
-#endif
-}
-
+#endif 
+} 
+ 
 bool NFs::MakeDirectoryRecursive(const TString& path, EFilePermissions mode, bool alwaysCreate) {
-    if (NFs::Exists(path) && TFileStat(path).IsDir()) {
-        if (alwaysCreate) {
+    if (NFs::Exists(path) && TFileStat(path).IsDir()) { 
+        if (alwaysCreate) { 
             ythrow TIoException() << "path " << path << " already exists"
                                   << " with cwd (" << NFs::CurrentWorkingDirectory() << ")";
-        }
-        return true;
-    } else {
-        //NOTE: recursion is finite due to existence of "." and "/"
+        } 
+        return true; 
+    } else { 
+        //NOTE: recursion is finite due to existence of "." and "/" 
         if (!NFs::MakeDirectoryRecursive(TFsPath(path).Parent(), mode, false)) {
             return false;
         }
 
         bool isDirMade = NFs::MakeDirectory(path, mode);
         if (!isDirMade && alwaysCreate) {
-            ythrow TIoException() << "failed to create " << path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")";
-        }
+            ythrow TIoException() << "failed to create " << path << " with cwd (" << NFs::CurrentWorkingDirectory() << ")"; 
+        } 
 
         return TFileStat(path).IsDir();
-    }
-}
-
+    } 
+} 
+ 
 bool NFs::Rename(const TString& oldPath, const TString& newPath) {
 #if defined(_win_)
     return NFsPrivate::WinRename(oldPath, newPath);
@@ -145,35 +145,35 @@ void NFs::Copy(const TString& existingPath, const TString& newPath) {
 
     TransferData(&src, &dst);
 }
-
+ 
 bool NFs::Exists(const TString& path) {
-#if defined(_win_)
+#if defined(_win_) 
     return NFsPrivate::WinExists(path);
-#elif defined(_unix_)
+#elif defined(_unix_) 
     return access(path.data(), F_OK) == 0;
-#endif
-}
-
+#endif 
+} 
+ 
 TString NFs::CurrentWorkingDirectory() {
-#if defined(_win_)
-    return NFsPrivate::WinCurrentWorkingDirectory();
-#elif defined(_unix_)
-    TTempBuf result;
-    char* r = getcwd(result.Data(), result.Size());
+#if defined(_win_) 
+    return NFsPrivate::WinCurrentWorkingDirectory(); 
+#elif defined(_unix_) 
+    TTempBuf result; 
+    char* r = getcwd(result.Data(), result.Size()); 
     if (r == nullptr) {
-        throw TIoSystemError() << "failed to getcwd";
+        throw TIoSystemError() << "failed to getcwd"; 
     }
-    return result.Data();
-#endif
-}
-
+    return result.Data(); 
+#endif 
+} 
+ 
 void NFs::SetCurrentWorkingDirectory(TString path) {
-#ifdef _win_
-    bool ok = NFsPrivate::WinSetCurrentWorkingDirectory(path);
-#else
+#ifdef _win_ 
+    bool ok = NFsPrivate::WinSetCurrentWorkingDirectory(path); 
+#else 
     bool ok = !chdir(path.data());
-#endif
+#endif 
     if (!ok) {
-        ythrow TSystemError() << "failed to change directory to " << path.Quote();
+        ythrow TSystemError() << "failed to change directory to " << path.Quote(); 
     }
-}
+} 
diff --git a/util/system/fs.h b/util/system/fs.h
index 237daf2d2d..613ae9c793 100644
--- a/util/system/fs.h
+++ b/util/system/fs.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <util/generic/flags.h>
+#include <util/generic/flags.h> 
 #include <util/generic/string.h>
-#include <util/generic/yexception.h>
+#include <util/generic/yexception.h> 
 
 namespace NFs {
-    enum EFilePermission {
+    enum EFilePermission { 
         FP_ALL_EXEC = 01,
         FP_ALL_WRITE = 02,
         FP_ALL_READ = 04,
@@ -15,14 +15,14 @@ namespace NFs {
         FP_OWNER_READ = 0400,
         FP_OWNER_WRITE = 0200,
         FP_OWNER_EXEC = 0100,
-
+ 
         FP_COMMON_FILE = 0777,
         FP_SECRET_FILE = 0700,
-        FP_NONSECRET_FILE = 0744,
-    };
-
-    Y_DECLARE_FLAGS(EFilePermissions, EFilePermission);
-
+        FP_NONSECRET_FILE = 0744, 
+    }; 
+ 
+    Y_DECLARE_FLAGS(EFilePermissions, EFilePermission); 
+ 
     /// Remove a file or empty directory
     ///
     /// @param[in] path  Path to file or directory
@@ -30,53 +30,53 @@ namespace NFs {
     /// LastSystemError() is set in case of failure
     bool Remove(const TString& path);
 
-    /// Remove a file or directory with contents
-    ///
-    /// @param[in] path  Path to file or directory
-    /// @throws
+    /// Remove a file or directory with contents 
+    /// 
+    /// @param[in] path  Path to file or directory 
+    /// @throws 
     void RemoveRecursive(const TString& path);
-
-    /// Creates directory
-    ///
-    /// @param[in] path  Path to the directory
-    /// @param[in] mode  Access permissions field; NOTE: ignored on win
-    /// @returns         true on success or false otherwise
+ 
+    /// Creates directory 
+    /// 
+    /// @param[in] path  Path to the directory 
+    /// @param[in] mode  Access permissions field; NOTE: ignored on win 
+    /// @returns         true on success or false otherwise 
     bool MakeDirectory(const TString& path, EFilePermissions mode);
-
-    /// Creates directory
-    ///
-    /// @param[in] path  Path to the directory
-    /// @returns         true on success or false otherwise
-    /// NOTE: access permissions is set to 0777
+ 
+    /// Creates directory 
+    /// 
+    /// @param[in] path  Path to the directory 
+    /// @returns         true on success or false otherwise 
+    /// NOTE: access permissions is set to 0777 
     inline bool MakeDirectory(const TString& path) {
-        return MakeDirectory(path, FP_COMMON_FILE);
-    }
-
-    /// Creates directory and all non-existings parents
-    ///
-    /// @param[in] path          Path to be created
-    /// @param[in] mode          Access permissions field; NOTE: ignored on win
-    /// @param[in] alwaysCreate  Throw if path already exists or failed to create
-    /// @returns                 true if target path created or exists (and directory)
+        return MakeDirectory(path, FP_COMMON_FILE); 
+    } 
+ 
+    /// Creates directory and all non-existings parents 
+    /// 
+    /// @param[in] path          Path to be created 
+    /// @param[in] mode          Access permissions field; NOTE: ignored on win 
+    /// @param[in] alwaysCreate  Throw if path already exists or failed to create 
+    /// @returns                 true if target path created or exists (and directory) 
     bool MakeDirectoryRecursive(const TString& path, EFilePermissions mode, bool alwaysCreate);
-
-    /// Creates directory and all non-existings parents
-    ///
-    /// @param[in] path          Path to be created
-    /// @param[in] mode          Access permissions field; NOTE: ignored on win
+ 
+    /// Creates directory and all non-existings parents 
+    /// 
+    /// @param[in] path          Path to be created 
+    /// @param[in] mode          Access permissions field; NOTE: ignored on win 
     /// @returns                 true if target path created or exists (and directory)
     inline bool MakeDirectoryRecursive(const TString& path, EFilePermissions mode) {
-        return MakeDirectoryRecursive(path, mode, false);
-    }
-
-    /// Creates directory and all non-existings parents
-    ///
-    /// @param[in] path          Path to be created
-    /// @returns                 true if target path created or exists (and directory)
+        return MakeDirectoryRecursive(path, mode, false); 
+    } 
+ 
+    /// Creates directory and all non-existings parents 
+    /// 
+    /// @param[in] path          Path to be created 
+    /// @returns                 true if target path created or exists (and directory) 
     inline bool MakeDirectoryRecursive(const TString& path) {
-        return MakeDirectoryRecursive(path, FP_COMMON_FILE, false);
-    }
-
+        return MakeDirectoryRecursive(path, FP_COMMON_FILE, false); 
+    } 
+ 
     /// Rename a file or directory.
     /// Removes newPath if it exists
     ///
@@ -126,31 +126,31 @@ namespace NFs {
     /// @param[in] existingPath  Path to an existing file
     /// @param[in] newPath       New path of file
     void Copy(const TString& existingPath, const TString& newPath);
-
-    /// Returns path to the current working directory
-    ///
-    /// Note: is not threadsafe
+ 
+    /// Returns path to the current working directory 
+    /// 
+    /// Note: is not threadsafe 
     TString CurrentWorkingDirectory();
-
-    /// Changes current working directory
-    ///
-    /// @param[in] path          Path for new cwd
-    /// Note: is not threadsafe
+ 
+    /// Changes current working directory 
+    /// 
+    /// @param[in] path          Path for new cwd 
+    /// Note: is not threadsafe 
     void SetCurrentWorkingDirectory(TString path);
-
-    /// Checks if file exists
-    ///
-    /// @param[in] path          Path to check
+ 
+    /// Checks if file exists 
+    /// 
+    /// @param[in] path          Path to check 
     bool Exists(const TString& path);
-
-    /// Ensures that file exists
-    ///
-    /// @param[in] path          Path to check
-    /// @returns                 input argument
+ 
+    /// Ensures that file exists 
+    /// 
+    /// @param[in] path          Path to check 
+    /// @returns                 input argument 
     inline const TString& EnsureExists(const TString& path) {
         Y_ENSURE_EX(Exists(path), TFileError{} << "Path " << path << " does not exists (checked from cwd:" << NFs::CurrentWorkingDirectory() << ")");
-        return path;
-    }
+        return path; 
+    } 
 }
-
-Y_DECLARE_OPERATORS_FOR_FLAGS(NFs::EFilePermissions)
+ 
+Y_DECLARE_OPERATORS_FOR_FLAGS(NFs::EFilePermissions) 
diff --git a/util/system/fs_ut.cpp b/util/system/fs_ut.cpp
index de071ebf55..21d0a9729a 100644
--- a/util/system/fs_ut.cpp
+++ b/util/system/fs_ut.cpp
@@ -1,6 +1,6 @@
 #include "fs.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "file.h"
 #include "sysstat.h"
@@ -8,61 +8,61 @@
 #include <util/folder/dirut.h>
 #include <util/folder/path.h>
 
-//WARNING: on windows the test must be run with administative rules
-
+//WARNING: on windows the test must be run with administative rules 
+ 
 class TFsTest: public TTestBase {
     UNIT_TEST_SUITE(TFsTest);
-    UNIT_TEST(TestCreateRemove);
-    UNIT_TEST(TestRename);
+    UNIT_TEST(TestCreateRemove); 
+    UNIT_TEST(TestRename); 
     UNIT_TEST(TestSymlink);
     UNIT_TEST(TestHardlink);
-    UNIT_TEST(TestCwdOpts);
-    UNIT_TEST(TestEnsureExists);
+    UNIT_TEST(TestCwdOpts); 
+    UNIT_TEST(TestEnsureExists); 
     UNIT_TEST_SUITE_END();
 
 public:
-    void TestCreateRemove();
-    void TestRename();
+    void TestCreateRemove(); 
+    void TestRename(); 
     void TestSymlink();
     void TestHardlink();
-    void TestCwdOpts();
-    void TestEnsureExists();
+    void TestCwdOpts(); 
+    void TestEnsureExists(); 
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TFsTest);
 
-static void Touch(const TFsPath& path) {
-    TFile file(path, CreateAlways | WrOnly);
-    file.Write("123", 3);
-}
-
-void TFsTest::TestCreateRemove() {
-    TFsPath dir1 = "dir_aбвг";
-    NFs::RemoveRecursive(dir1);
-    UNIT_ASSERT(!NFs::Exists(dir1));
-    UNIT_ASSERT(NFs::MakeDirectory(dir1));
-
-    UNIT_ASSERT(TFileStat(dir1).IsDir());
-    UNIT_ASSERT(!NFs::MakeDirectory(dir1));
-
-    UNIT_ASSERT(NFs::Exists(dir1));
-    TFsPath subdir1 = dir1 / "a" / "b";
-    //TFsPath link = dir1 / "link";
-
-    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, true));
-    UNIT_ASSERT(NFs::Exists(subdir1));
-    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, false));
-    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE));
-    UNIT_ASSERT_EXCEPTION(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, true), TIoException);
-
-    TFsPath file1 = dir1 / "f1.txt";
+static void Touch(const TFsPath& path) { 
+    TFile file(path, CreateAlways | WrOnly); 
+    file.Write("123", 3); 
+} 
+ 
+void TFsTest::TestCreateRemove() { 
+    TFsPath dir1 = "dir_aбвг"; 
+    NFs::RemoveRecursive(dir1); 
+    UNIT_ASSERT(!NFs::Exists(dir1)); 
+    UNIT_ASSERT(NFs::MakeDirectory(dir1)); 
+ 
+    UNIT_ASSERT(TFileStat(dir1).IsDir()); 
+    UNIT_ASSERT(!NFs::MakeDirectory(dir1)); 
+ 
+    UNIT_ASSERT(NFs::Exists(dir1)); 
+    TFsPath subdir1 = dir1 / "a" / "b"; 
+    //TFsPath link = dir1 / "link"; 
+ 
+    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, true)); 
+    UNIT_ASSERT(NFs::Exists(subdir1)); 
+    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, false)); 
+    UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE)); 
+    UNIT_ASSERT_EXCEPTION(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, true), TIoException); 
+ 
+    TFsPath file1 = dir1 / "f1.txt"; 
     TFsPath file2 = subdir1 + TString("_f2.txt");
-    TFsPath file3 = subdir1 / "f2.txt";
-    Touch(file1);
-    Touch(file2);
-    Touch(file3);
-    //UNIT_ASSERT(NFs::SymLink(file3.RealPath(), link));
-
+    TFsPath file3 = subdir1 / "f2.txt"; 
+    Touch(file1); 
+    Touch(file2); 
+    Touch(file3); 
+    //UNIT_ASSERT(NFs::SymLink(file3.RealPath(), link)); 
+ 
     UNIT_ASSERT(NFs::MakeDirectoryRecursive(dir1 / "subdir1" / "subdir2" / "subdir3" / "subdir4", NFs::FP_COMMON_FILE, false));
     UNIT_ASSERT(NFs::MakeDirectoryRecursive(dir1 / "subdir1" / "subdir2", NFs::FP_COMMON_FILE, false));
 
@@ -72,202 +72,202 @@ void TFsTest::TestCreateRemove() {
 
     TString longUtf8Name = "";
     while (longUtf8Name.size() < 255) {
-        longUtf8Name = longUtf8Name + "fф";
-    }
+        longUtf8Name = longUtf8Name + "fф"; 
+    } 
     UNIT_ASSERT_EQUAL(longUtf8Name.size(), 255);
-    TFsPath longfile = dir1 / longUtf8Name;
-    Touch(longfile);
-
-    UNIT_ASSERT(NFs::Exists(longfile));
-    UNIT_ASSERT(NFs::Exists(file1));
-    UNIT_ASSERT(NFs::Exists(file2));
-    UNIT_ASSERT(NFs::Exists(file3));
-    //UNIT_ASSERT(NFs::Exists(link));
-
-    UNIT_ASSERT(!NFs::Remove(dir1));
-    NFs::RemoveRecursive(dir1);
-
-    UNIT_ASSERT(!NFs::Exists(file1));
-    UNIT_ASSERT(!NFs::Exists(file2));
-    UNIT_ASSERT(!NFs::Exists(file3));
-    //UNIT_ASSERT(!NFs::Exists(link));
-    UNIT_ASSERT(!NFs::Exists(subdir1));
-    UNIT_ASSERT(!NFs::Exists(longfile));
-    UNIT_ASSERT(!NFs::Exists(dir1));
-}
-
+    TFsPath longfile = dir1 / longUtf8Name; 
+    Touch(longfile); 
+ 
+    UNIT_ASSERT(NFs::Exists(longfile)); 
+    UNIT_ASSERT(NFs::Exists(file1)); 
+    UNIT_ASSERT(NFs::Exists(file2)); 
+    UNIT_ASSERT(NFs::Exists(file3)); 
+    //UNIT_ASSERT(NFs::Exists(link)); 
+ 
+    UNIT_ASSERT(!NFs::Remove(dir1)); 
+    NFs::RemoveRecursive(dir1); 
+ 
+    UNIT_ASSERT(!NFs::Exists(file1)); 
+    UNIT_ASSERT(!NFs::Exists(file2)); 
+    UNIT_ASSERT(!NFs::Exists(file3)); 
+    //UNIT_ASSERT(!NFs::Exists(link)); 
+    UNIT_ASSERT(!NFs::Exists(subdir1)); 
+    UNIT_ASSERT(!NFs::Exists(longfile)); 
+    UNIT_ASSERT(!NFs::Exists(dir1)); 
+} 
+ 
 void RunRenameTest(TFsPath src, TFsPath dst) {
     // if previous running was failed
-    TFsPath dir1 = "dir";
-    TFsPath dir2 = "dst_dir";
-
-    NFs::Remove(src);
-    NFs::Remove(dst);
-
-    NFs::Remove(dir1 / src);
-    NFs::Remove(dir1);
-    NFs::Remove(dir2 / src);
-    NFs::Remove(dir2);
-
+    TFsPath dir1 = "dir"; 
+    TFsPath dir2 = "dst_dir"; 
+
+    NFs::Remove(src); 
+    NFs::Remove(dst); 
+ 
+    NFs::Remove(dir1 / src); 
+    NFs::Remove(dir1); 
+    NFs::Remove(dir2 / src); 
+    NFs::Remove(dir2); 
+ 
     {
-        TFile file(src, CreateNew | WrOnly);
+        TFile file(src, CreateNew | WrOnly); 
         file.Write("123", 3);
     }
 
     UNIT_ASSERT(NFs::Rename(src, dst));
-    UNIT_ASSERT(NFs::Exists(dst));
-    UNIT_ASSERT(!NFs::Exists(src));
-
+    UNIT_ASSERT(NFs::Exists(dst)); 
+    UNIT_ASSERT(!NFs::Exists(src)); 
+ 
     {
-        TFile file(dst, OpenExisting);
+        TFile file(dst, OpenExisting); 
         UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 3);
     }
-
-    NFs::MakeDirectory(dir1);
+ 
+    NFs::MakeDirectory(dir1); 
     {
-        TFile file(dir1 / src, CreateNew | WrOnly);
-        file.Write("123", 3);
-    }
+        TFile file(dir1 / src, CreateNew | WrOnly); 
+        file.Write("123", 3); 
+    } 
     UNIT_ASSERT(NFs::Rename(dir1, dir2));
-    UNIT_ASSERT(NFs::Exists(dir2 / src));
-    UNIT_ASSERT(!NFs::Exists(dir1));
-
-    {
-        TFile file(dir2 / src, OpenExisting);
-        UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 3);
-    }
-
+    UNIT_ASSERT(NFs::Exists(dir2 / src)); 
+    UNIT_ASSERT(!NFs::Exists(dir1)); 
+ 
+    { 
+        TFile file(dir2 / src, OpenExisting); 
+        UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 3); 
+    } 
+ 
     UNIT_ASSERT(!NFs::Remove(src));
     UNIT_ASSERT(NFs::Remove(dst));
     UNIT_ASSERT(!NFs::Remove(dir1));
     UNIT_ASSERT(NFs::Remove(dir2 / src));
     UNIT_ASSERT(NFs::Remove(dir2));
-}
-
+} 
+ 
 void TFsTest::TestRename() {
-    RunRenameTest("src.txt", "dst.txt");
-    RunRenameTest("src_абвг.txt", "dst_абвг.txt");
-}
-
-static void RunHardlinkTest(const TFsPath& src, const TFsPath& dst) {
-    NFs::Remove(src);
-    NFs::Remove(dst);
-
-    {
-        TFile file(src, CreateNew | WrOnly);
-        file.Write("123", 3);
-    }
-
-    UNIT_ASSERT(NFs::HardLink(src, dst));
-
-    {
-        TFile file(dst, OpenExisting | RdOnly);
-        UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 3);
-    }
-    {
-        TFile file(src, OpenExisting | WrOnly);
+    RunRenameTest("src.txt", "dst.txt"); 
+    RunRenameTest("src_абвг.txt", "dst_абвг.txt"); 
+} 
+ 
+static void RunHardlinkTest(const TFsPath& src, const TFsPath& dst) { 
+    NFs::Remove(src); 
+    NFs::Remove(dst); 
+ 
+    { 
+        TFile file(src, CreateNew | WrOnly); 
+        file.Write("123", 3); 
+    } 
+ 
+    UNIT_ASSERT(NFs::HardLink(src, dst)); 
+ 
+    { 
+        TFile file(dst, OpenExisting | RdOnly); 
+        UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 3); 
+    } 
+    { 
+        TFile file(src, OpenExisting | WrOnly); 
         file.Write("1234", 4);
     }
     {
-        TFile file(dst, OpenExisting | RdOnly);
+        TFile file(dst, OpenExisting | RdOnly); 
         UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 4);
     }
     {
-        TFile file(dst, OpenExisting | WrOnly);
+        TFile file(dst, OpenExisting | WrOnly); 
         file.Write("12345", 5);
     }
-
+ 
     {
-        TFile file(src, OpenExisting | RdOnly);
+        TFile file(src, OpenExisting | RdOnly); 
         UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 5);
     }
-
+ 
     UNIT_ASSERT(NFs::Remove(dst));
     UNIT_ASSERT(NFs::Remove(src));
 }
 
-void TFsTest::TestHardlink() {
-    RunHardlinkTest("tempfile", "hardlinkfile");
-    RunHardlinkTest("tempfile_абвг", "hardlinkfile_абвг"); //utf-8 names
-}
-
+void TFsTest::TestHardlink() { 
+    RunHardlinkTest("tempfile", "hardlinkfile"); 
+    RunHardlinkTest("tempfile_абвг", "hardlinkfile_абвг"); //utf-8 names 
+} 
+ 
 static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
     // if previous running was failed
-    TFsPath subDir = "tempsubdir";
-    TFsPath srcFile = subDir / fileLocalName;
-
-    TFsPath subsubDir1 = subDir / "dir1";
-    TFsPath subsubDir2 = subDir / "dir2";
-
-    TFsPath linkD1 = "symlinkdir";
-    TFsPath linkD2 = subsubDir1 / "linkd2";
-    TFsPath dangling = subsubDir1 / "dangling";
-
-    NFs::Remove(srcFile);
-    NFs::Remove(symLinkName);
-    NFs::Remove(linkD2);
-    NFs::Remove(dangling);
-    NFs::Remove(subsubDir1);
-    NFs::Remove(subsubDir2);
-    NFs::Remove(subDir);
-    NFs::Remove(linkD1);
-
-    NFs::MakeDirectory(subDir);
-    NFs::MakeDirectory(subsubDir1, NFs::FP_NONSECRET_FILE);
-    NFs::MakeDirectory(subsubDir2, NFs::FP_SECRET_FILE);
+    TFsPath subDir = "tempsubdir"; 
+    TFsPath srcFile = subDir / fileLocalName; 
+
+    TFsPath subsubDir1 = subDir / "dir1"; 
+    TFsPath subsubDir2 = subDir / "dir2"; 
+ 
+    TFsPath linkD1 = "symlinkdir"; 
+    TFsPath linkD2 = subsubDir1 / "linkd2"; 
+    TFsPath dangling = subsubDir1 / "dangling"; 
+ 
+    NFs::Remove(srcFile); 
+    NFs::Remove(symLinkName); 
+    NFs::Remove(linkD2); 
+    NFs::Remove(dangling); 
+    NFs::Remove(subsubDir1); 
+    NFs::Remove(subsubDir2); 
+    NFs::Remove(subDir); 
+    NFs::Remove(linkD1); 
+ 
+    NFs::MakeDirectory(subDir); 
+    NFs::MakeDirectory(subsubDir1, NFs::FP_NONSECRET_FILE); 
+    NFs::MakeDirectory(subsubDir2, NFs::FP_SECRET_FILE); 
     {
-        TFile file(srcFile, CreateNew | WrOnly);
+        TFile file(srcFile, CreateNew | WrOnly); 
         file.Write("1234567", 7);
     }
-    UNIT_ASSERT(NFs::SymLink(subDir, linkD1));
-    UNIT_ASSERT(NFs::SymLink("../dir2", linkD2));
-    UNIT_ASSERT(NFs::SymLink("../dir3", dangling));
+    UNIT_ASSERT(NFs::SymLink(subDir, linkD1)); 
+    UNIT_ASSERT(NFs::SymLink("../dir2", linkD2)); 
+    UNIT_ASSERT(NFs::SymLink("../dir3", dangling)); 
     UNIT_ASSERT_STRINGS_EQUAL(NFs::ReadLink(linkD2), TString("..") + LOCSLASH_S "dir2");
     UNIT_ASSERT_STRINGS_EQUAL(NFs::ReadLink(dangling), TString("..") + LOCSLASH_S "dir3");
     {
-        TFile file(linkD1 / fileLocalName, OpenExisting | RdOnly);
+        TFile file(linkD1 / fileLocalName, OpenExisting | RdOnly); 
         UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 7);
     }
-    UNIT_ASSERT(NFs::SymLink(srcFile, symLinkName));
+    UNIT_ASSERT(NFs::SymLink(srcFile, symLinkName)); 
     {
-        TFile file(symLinkName, OpenExisting | RdOnly);
+        TFile file(symLinkName, OpenExisting | RdOnly); 
         UNIT_ASSERT_VALUES_EQUAL(file.GetLength(), 7);
     }
     {
-        TFileStat fs(linkD1);
+        TFileStat fs(linkD1); 
         UNIT_ASSERT(!fs.IsFile());
         UNIT_ASSERT(fs.IsDir());
         UNIT_ASSERT(!fs.IsSymlink());
     }
     {
-        TFileStat fs(linkD1, true);
+        TFileStat fs(linkD1, true); 
         UNIT_ASSERT(!fs.IsFile());
         //UNIT_ASSERT(fs.IsDir()); // failed on unix
         UNIT_ASSERT(fs.IsSymlink());
     }
     {
-        TFileStat fs(symLinkName);
+        TFileStat fs(symLinkName); 
         UNIT_ASSERT(fs.IsFile());
         UNIT_ASSERT(!fs.IsDir());
         UNIT_ASSERT(!fs.IsSymlink());
         UNIT_ASSERT_VALUES_EQUAL(fs.Size, 7u);
     }
-
+ 
     {
-        TFileStat fs(symLinkName, true);
+        TFileStat fs(symLinkName, true); 
         //UNIT_ASSERT(fs.IsFile()); // no evidence that symlink has to be a file as well
         UNIT_ASSERT(!fs.IsDir());
         UNIT_ASSERT(fs.IsSymlink());
     }
 
     UNIT_ASSERT(NFs::Remove(symLinkName));
-    UNIT_ASSERT(NFs::Exists(srcFile));
-
+    UNIT_ASSERT(NFs::Exists(srcFile)); 
+ 
     UNIT_ASSERT(NFs::Remove(linkD1));
-    UNIT_ASSERT(NFs::Exists(srcFile));
-
+    UNIT_ASSERT(NFs::Exists(srcFile)); 
+ 
     UNIT_ASSERT(!NFs::Remove(subDir));
-
+ 
     UNIT_ASSERT(NFs::Remove(srcFile));
     UNIT_ASSERT(NFs::Remove(linkD2));
     UNIT_ASSERT(NFs::Remove(dangling));
@@ -275,51 +275,51 @@ static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
     UNIT_ASSERT(NFs::Remove(subsubDir2));
     UNIT_ASSERT(NFs::Remove(subDir));
 }
-
+ 
 void TFsTest::TestSymlink() {
-    // if previous running was failed
-    RunSymLinkTest("f.txt", "fl.txt");
-    RunSymLinkTest("f_абвг.txt", "fl_абвг.txt"); //utf-8 names
-}
-
-void TFsTest::TestCwdOpts() {
-    TFsPath initialCwd = NFs::CurrentWorkingDirectory();
-    TFsPath subdir = "dir_forcwd_абвг";
-    NFs::MakeDirectory(subdir, NFs::FP_SECRET_FILE | NFs::FP_ALL_READ);
-    NFs::SetCurrentWorkingDirectory(subdir);
-    TFsPath newCwd = NFs::CurrentWorkingDirectory();
-
-    UNIT_ASSERT_EQUAL(newCwd.Fix(), (initialCwd / subdir).Fix());
-
-    NFs::SetCurrentWorkingDirectory("..");
-    TFsPath newCwd2 = NFs::CurrentWorkingDirectory();
-    UNIT_ASSERT_EQUAL(newCwd2.Fix(), initialCwd.Fix());
-    UNIT_ASSERT(NFs::Remove(subdir));
-}
-
-void TFsTest::TestEnsureExists() {
-    TFsPath fileExists = "tmp_file_абвг.txt";
-    TFsPath nonExists = "tmp2_file_абвг.txt";
-    {
-        NFs::Remove(fileExists);
-        NFs::Remove(nonExists);
-        TFile file(fileExists, CreateNew | WrOnly);
-        file.Write("1234567", 7);
-    }
-
-    UNIT_ASSERT_NO_EXCEPTION(NFs::EnsureExists(fileExists));
-    UNIT_ASSERT_EXCEPTION(NFs::EnsureExists(nonExists), TFileError);
-
-    TStringBuilder expected;
+    // if previous running was failed 
+    RunSymLinkTest("f.txt", "fl.txt"); 
+    RunSymLinkTest("f_абвг.txt", "fl_абвг.txt"); //utf-8 names 
+} 
+ 
+void TFsTest::TestCwdOpts() { 
+    TFsPath initialCwd = NFs::CurrentWorkingDirectory(); 
+    TFsPath subdir = "dir_forcwd_абвг"; 
+    NFs::MakeDirectory(subdir, NFs::FP_SECRET_FILE | NFs::FP_ALL_READ); 
+    NFs::SetCurrentWorkingDirectory(subdir); 
+    TFsPath newCwd = NFs::CurrentWorkingDirectory(); 
+ 
+    UNIT_ASSERT_EQUAL(newCwd.Fix(), (initialCwd / subdir).Fix()); 
+ 
+    NFs::SetCurrentWorkingDirectory(".."); 
+    TFsPath newCwd2 = NFs::CurrentWorkingDirectory(); 
+    UNIT_ASSERT_EQUAL(newCwd2.Fix(), initialCwd.Fix()); 
+    UNIT_ASSERT(NFs::Remove(subdir)); 
+} 
+ 
+void TFsTest::TestEnsureExists() { 
+    TFsPath fileExists = "tmp_file_абвг.txt"; 
+    TFsPath nonExists = "tmp2_file_абвг.txt"; 
+    { 
+        NFs::Remove(fileExists); 
+        NFs::Remove(nonExists); 
+        TFile file(fileExists, CreateNew | WrOnly); 
+        file.Write("1234567", 7); 
+    } 
+ 
+    UNIT_ASSERT_NO_EXCEPTION(NFs::EnsureExists(fileExists)); 
+    UNIT_ASSERT_EXCEPTION(NFs::EnsureExists(nonExists), TFileError); 
+ 
+    TStringBuilder expected; 
     TString got;
-    try {
+    try { 
         NFs::EnsureExists(nonExists);
         expected << __LOCATION__;
-    } catch (const TFileError& err) {
-        got = err.what();
-    }
-    UNIT_ASSERT(got.Contains(expected));
-    UNIT_ASSERT(got.Contains(NFs::CurrentWorkingDirectory()));
-
-    UNIT_ASSERT(NFs::Remove(fileExists));
-}
+    } catch (const TFileError& err) { 
+        got = err.what(); 
+    } 
+    UNIT_ASSERT(got.Contains(expected)); 
+    UNIT_ASSERT(got.Contains(NFs::CurrentWorkingDirectory())); 
+ 
+    UNIT_ASSERT(NFs::Remove(fileExists)); 
+} 
diff --git a/util/system/fs_win.cpp b/util/system/fs_win.cpp
index a410ccac06..8736b8ef00 100644
--- a/util/system/fs_win.cpp
+++ b/util/system/fs_win.cpp
@@ -20,11 +20,11 @@ namespace NFsPrivate {
     }
 
     static TString WCHARToUTF8(const LPWSTR wstr, size_t len) {
-        static_assert(sizeof(WCHAR) == sizeof(wchar16), "expect sizeof(WCHAR) == sizeof(wchar16)");
-
+        static_assert(sizeof(WCHAR) == sizeof(wchar16), "expect sizeof(WCHAR) == sizeof(wchar16)"); 
+ 
         return WideToUTF8((wchar16*)wstr, len);
-    }
-
+    } 
+ 
     HANDLE CreateFileWithUtf8Name(const TStringBuf fName, ui32 accessMode, ui32 shareMode, ui32 createMode, ui32 attributes, bool inheritHandle) {
         TUtf16String wstr;
         LPCWSTR wname = UTF8ToWCHAR(fName, wstr);
@@ -37,8 +37,8 @@ namespace NFsPrivate {
         secAttrs.lpSecurityDescriptor = nullptr;
         secAttrs.nLength = sizeof(secAttrs);
         return ::CreateFileW(wname, accessMode, shareMode, &secAttrs, createMode, attributes, nullptr);
-    }
-
+    } 
+ 
     bool WinRename(const TString& oldPath, const TString& newPath) {
         TUtf16String op, np;
         LPCWSTR opPtr = UTF8ToWCHAR(oldPath, op);
@@ -47,10 +47,10 @@ namespace NFsPrivate {
             ::SetLastError(ERROR_INVALID_NAME);
             return false;
         }
-
+ 
         return MoveFileExW(opPtr, npPtr, MOVEFILE_REPLACE_EXISTING) != 0;
     }
-
+ 
     bool WinRemove(const TString& path) {
         TUtf16String wstr;
         LPCWSTR wname = UTF8ToWCHAR(path, wstr);
@@ -67,10 +67,10 @@ namespace NFsPrivate {
 
         return false;
     }
-
+ 
     bool WinSymLink(const TString& targetName, const TString& linkName) {
         TString tName(targetName);
-        {
+        { 
             size_t pos;
             while ((pos = tName.find('/')) != TString::npos)
                 tName.replace(pos, 1, LOCSLASH_S);
@@ -79,7 +79,7 @@ namespace NFsPrivate {
         LPCWSTR wname = UTF8ToWCHAR(tName, tstr);
         TUtf16String lstr;
         LPCWSTR lname = UTF8ToWCHAR(linkName, lstr);
-
+ 
         // we can't create a dangling link to a dir in this way
         ui32 attr = ::GetFileAttributesW(wname);
         if (attr == INVALID_FILE_ATTRIBUTES) {
@@ -111,38 +111,38 @@ namespace NFsPrivate {
         }
 
         return (CreateHardLinkW(npPtr, epPtr, nullptr) != 0);
-    }
-
+    } 
+ 
     bool WinExists(const TString& path) {
         TUtf16String buf;
         LPCWSTR ptr = UTF8ToWCHAR(path, buf);
         return ::GetFileAttributesW(ptr) != INVALID_FILE_ATTRIBUTES;
     }
-
+ 
     TString WinCurrentWorkingDirectory() {
-        TTempBuf result;
-        LPWSTR buf = reinterpret_cast<LPWSTR>(result.Data());
-        int r = GetCurrentDirectoryW(result.Size() / sizeof(WCHAR), buf);
-        if (r == 0)
-            throw TIoSystemError() << "failed to GetCurrentDirectory";
-        return WCHARToUTF8(buf, r);
-    }
-
+        TTempBuf result; 
+        LPWSTR buf = reinterpret_cast<LPWSTR>(result.Data()); 
+        int r = GetCurrentDirectoryW(result.Size() / sizeof(WCHAR), buf); 
+        if (r == 0) 
+            throw TIoSystemError() << "failed to GetCurrentDirectory"; 
+        return WCHARToUTF8(buf, r); 
+    } 
+ 
     bool WinSetCurrentWorkingDirectory(const TString& path) {
         TUtf16String wstr;
-        LPCWSTR wname = UTF8ToWCHAR(path, wstr);
-        if (!wname) {
-            ::SetLastError(ERROR_INVALID_NAME);
-            return false;
-        }
-        return SetCurrentDirectoryW(wname);
-    }
-
+        LPCWSTR wname = UTF8ToWCHAR(path, wstr); 
+        if (!wname) { 
+            ::SetLastError(ERROR_INVALID_NAME); 
+            return false; 
+        } 
+        return SetCurrentDirectoryW(wname); 
+    } 
+ 
     bool WinMakeDirectory(const TString path) {
         TUtf16String buf;
-        LPCWSTR ptr = UTF8ToWCHAR(path, buf);
-        return CreateDirectoryW(ptr, (LPSECURITY_ATTRIBUTES) nullptr);
-    }
+        LPCWSTR ptr = UTF8ToWCHAR(path, buf); 
+        return CreateDirectoryW(ptr, (LPSECURITY_ATTRIBUTES) nullptr); 
+    } 
     // edited part of <Ntifs.h> from Windows DDK
 
 #define SYMLINK_FLAG_RELATIVE 1
@@ -229,5 +229,5 @@ bool GetObjectId(const char* path, GUID* id) {
     return false;
 }
 */
-
+ 
 }
diff --git a/util/system/fs_win.h b/util/system/fs_win.h
index 8086129828..7fdab7c198 100644
--- a/util/system/fs_win.h
+++ b/util/system/fs_win.h
@@ -8,22 +8,22 @@
 
 namespace NFsPrivate {
     bool WinRename(const TString& oldPath, const TString& newPath);
-
+ 
     bool WinSymLink(const TString& targetName, const TString& linkName);
-
+ 
     bool WinHardLink(const TString& existingPath, const TString& newPath);
-
+ 
     TString WinReadLink(const TString& path);
-
+ 
     HANDLE CreateFileWithUtf8Name(const TStringBuf fName, ui32 accessMode, ui32 shareMode, ui32 createMode, ui32 attributes, bool inheritHandle);
-
+ 
     bool WinRemove(const TString& path);
-
+ 
     bool WinExists(const TString& path);
-
+ 
     TString WinCurrentWorkingDirectory();
-
+ 
     bool WinSetCurrentWorkingDirectory(const TString& path);
-
+ 
     bool WinMakeDirectory(const TString path);
 }
diff --git a/util/system/fstat_ut.cpp b/util/system/fstat_ut.cpp
index 160ecd936e..040cacbb09 100644
--- a/util/system/fstat_ut.cpp
+++ b/util/system/fstat_ut.cpp
@@ -3,8 +3,8 @@
 #include "sysstat.h"
 #include "fs.h"
 
-#include <library/cpp/testing/unittest/registar.h>
-#include <library/cpp/testing/unittest/tests_data.h>
+#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/tests_data.h> 
 
 #include <util/folder/path.h>
 
diff --git a/util/system/getpid_ut.cpp b/util/system/getpid_ut.cpp
index e7122a2971..fb0d42ef76 100644
--- a/util/system/getpid_ut.cpp
+++ b/util/system/getpid_ut.cpp
@@ -1,6 +1,6 @@
 #include "getpid.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 class TGetPidTest: public TTestBase {
     UNIT_TEST_SUITE(TGetPidTest);
diff --git a/util/system/guard_ut.cpp b/util/system/guard_ut.cpp
index 404ede99ab..6f18e9a5ee 100644
--- a/util/system/guard_ut.cpp
+++ b/util/system/guard_ut.cpp
@@ -1,7 +1,7 @@
 #include "guard.h"
 #include "rwlock.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/thread/pool.h>
 
diff --git a/util/system/hi_lo_ut.cpp b/util/system/hi_lo_ut.cpp
index 850c12327d..8610fbb9fd 100644
--- a/util/system/hi_lo_ut.cpp
+++ b/util/system/hi_lo_ut.cpp
@@ -1,6 +1,6 @@
 #include <util/system/hi_lo.h>
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "defaults.h"
 
diff --git a/util/system/hostname_ut.cpp b/util/system/hostname_ut.cpp
index fb1cb7dde4..009c4f8064 100644
--- a/util/system/hostname_ut.cpp
+++ b/util/system/hostname_ut.cpp
@@ -1,6 +1,6 @@
 #include "hostname.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(THostNameTest) {
     Y_UNIT_TEST(Test1) {
diff --git a/util/system/info_ut.cpp b/util/system/info_ut.cpp
index ad7449f8f4..5b2dd00460 100644
--- a/util/system/info_ut.cpp
+++ b/util/system/info_ut.cpp
@@ -1,6 +1,6 @@
 #include "info.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 class TSysInfoTest: public TTestBase {
     UNIT_TEST_SUITE(TSysInfoTest);
diff --git a/util/system/interrupt_signals_ut.cpp b/util/system/interrupt_signals_ut.cpp
index bec54fec61..0dda781cea 100644
--- a/util/system/interrupt_signals_ut.cpp
+++ b/util/system/interrupt_signals_ut.cpp
@@ -4,7 +4,7 @@
 
 #include <util/datetime/base.h>
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #ifdef _win_
     #include <windows.h>
diff --git a/util/system/mem_info_ut.cpp b/util/system/mem_info_ut.cpp
index a1100ba646..864aff9cd4 100644
--- a/util/system/mem_info_ut.cpp
+++ b/util/system/mem_info_ut.cpp
@@ -1,6 +1,6 @@
 #include "mem_info.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "info.h"
 
diff --git a/util/system/mincore_ut.cpp b/util/system/mincore_ut.cpp
index fc46cb1632..39fe7fd91a 100644
--- a/util/system/mincore_ut.cpp
+++ b/util/system/mincore_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #ifdef _unix_
     #include <sys/resource.h>
diff --git a/util/system/mlock.cpp b/util/system/mlock.cpp
index 435338c98f..a47f94a993 100644
--- a/util/system/mlock.cpp
+++ b/util/system/mlock.cpp
@@ -54,27 +54,27 @@ void UnlockMemory(const void* addr, size_t len) {
 
 void LockAllMemory(ELockAllMemoryFlags flags) {
     Y_UNUSED(flags);
-#if defined(_android_)
+#if defined(_android_) 
 // unimplemented
-#elif defined(_cygwin_)
+#elif defined(_cygwin_) 
 // unimplemented
-#elif defined(_unix_)
-    int sys_flags = 0;
+#elif defined(_unix_) 
+    int sys_flags = 0; 
     if (flags & LockCurrentMemory) {
-        sys_flags |= MCL_CURRENT;
-    }
+        sys_flags |= MCL_CURRENT; 
+    } 
     if (flags & LockFutureMemory) {
-        sys_flags |= MCL_FUTURE;
-    }
+        sys_flags |= MCL_FUTURE; 
+    } 
     if (flags & LockMemoryOnFault) {
         sys_flags |= MCL_ONFAULT;
     }
-    if (mlockall(sys_flags)) {
-        ythrow yexception() << LastSystemErrorText();
-    }
-#endif
-}
-
+    if (mlockall(sys_flags)) { 
+        ythrow yexception() << LastSystemErrorText(); 
+    } 
+#endif 
+} 
+ 
 void UnlockAllMemory() {
 #if defined(_cygwin_)
 // unimplemented
diff --git a/util/system/mlock.h b/util/system/mlock.h
index f021c0fe67..389f65570d 100644
--- a/util/system/mlock.h
+++ b/util/system/mlock.h
@@ -22,10 +22,10 @@ enum ELockAllMemoryFlag {
 
     /** Since Linux 4.4, with LockCurrentMemory or LockFutureMemory or both, lock only pages that are or once they are present in memory. */
     LockMemoryOnFault = 4,
-};
+}; 
 Y_DECLARE_FLAGS(ELockAllMemoryFlags, ELockAllMemoryFlag)
 Y_DECLARE_OPERATORS_FOR_FLAGS(ELockAllMemoryFlags)
-
+ 
 /**
  * Performs provided locking operation.
  *
@@ -34,7 +34,7 @@ Y_DECLARE_OPERATORS_FOR_FLAGS(ELockAllMemoryFlags)
  * \param flags                         Locking operation to perform.
  */
 void LockAllMemory(ELockAllMemoryFlags flags);
-
+ 
 /**
  * Unlocks whatever was locked with a previous call to `LockAllMemory`.
  *
diff --git a/util/system/mutex_ut.cpp b/util/system/mutex_ut.cpp
index c8d7caafa1..b7509dfe35 100644
--- a/util/system/mutex_ut.cpp
+++ b/util/system/mutex_ut.cpp
@@ -1,7 +1,7 @@
 #include "mutex.h"
 #include "atomic.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/thread/pool.h>
 #include <util/random/random.h>
diff --git a/util/system/nice_ut.cpp b/util/system/nice_ut.cpp
index ae0051f285..5a49c0355a 100644
--- a/util/system/nice_ut.cpp
+++ b/util/system/nice_ut.cpp
@@ -2,7 +2,7 @@
 
 #include "platform.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #ifdef _unix_
     #include <sys/resource.h>
diff --git a/util/system/pipe_ut.cpp b/util/system/pipe_ut.cpp
index 6d53432de8..7bd6ed0c57 100644
--- a/util/system/pipe_ut.cpp
+++ b/util/system/pipe_ut.cpp
@@ -1,6 +1,6 @@
 #include "pipe.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TPipeTest) {
     Y_UNIT_TEST(TestPipe) {
diff --git a/util/system/platform_ut.cpp b/util/system/platform_ut.cpp
index 9bfbce8315..aa2abf593e 100644
--- a/util/system/platform_ut.cpp
+++ b/util/system/platform_ut.cpp
@@ -1,6 +1,6 @@
 #include "platform.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 class TPlatformTest: public TTestBase {
     UNIT_TEST_SUITE(TPlatformTest);
diff --git a/util/system/progname_ut.cpp b/util/system/progname_ut.cpp
index 11f3d9308b..7b740c8730 100644
--- a/util/system/progname_ut.cpp
+++ b/util/system/progname_ut.cpp
@@ -1,6 +1,6 @@
 #include "progname.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TProgramNameTest) {
     Y_UNIT_TEST(TestIt) {
diff --git a/util/system/rusage_ut.cpp b/util/system/rusage_ut.cpp
index 0d4e0fe54b..ee0308c0cf 100644
--- a/util/system/rusage_ut.cpp
+++ b/util/system/rusage_ut.cpp
@@ -1,6 +1,6 @@
 #include "rusage.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TRusageTest) {
     Y_UNIT_TEST(TestRusage) {
diff --git a/util/system/rwlock_ut.cpp b/util/system/rwlock_ut.cpp
index 2b384c05b3..b9484a9ac1 100644
--- a/util/system/rwlock_ut.cpp
+++ b/util/system/rwlock_ut.cpp
@@ -1,7 +1,7 @@
 #include "rwlock.h"
 #include "atomic.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/thread/pool.h>
 #include <util/random/random.h>
diff --git a/util/system/sanitizers_ut.cpp b/util/system/sanitizers_ut.cpp
index 5de096e14b..e6fd50c9a2 100644
--- a/util/system/sanitizers_ut.cpp
+++ b/util/system/sanitizers_ut.cpp
@@ -1,7 +1,7 @@
 #include "sanitizers.h"
 #include "sys_alloc.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(Sanitizers) {
     Y_UNIT_TEST(MarkAsIntentionallyLeaked) {
diff --git a/util/system/shellcommand.cpp b/util/system/shellcommand.cpp
index b1989b5c8c..ffe294a2d6 100644
--- a/util/system/shellcommand.cpp
+++ b/util/system/shellcommand.cpp
@@ -717,7 +717,7 @@ void TShellCommand::TImpl::OnFork(TPipes& pipes, sigset_t oldmask, char* const*
         }
 
         if (WorkDir.size()) {
-            NFs::SetCurrentWorkingDirectory(WorkDir);
+            NFs::SetCurrentWorkingDirectory(WorkDir); 
         }
 
         if (CloseAllFdsOnExec) {
diff --git a/util/system/shellcommand_ut.cpp b/util/system/shellcommand_ut.cpp
index 9d849279d2..982cf4438c 100644
--- a/util/system/shellcommand_ut.cpp
+++ b/util/system/shellcommand_ut.cpp
@@ -6,8 +6,8 @@
 #include "sigset.h"
 #include "spinlock.h"
 
-#include <library/cpp/testing/unittest/env.h>
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/env.h> 
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/folder/dirut.h>
 #include <util/random/random.h>
@@ -315,7 +315,7 @@ Y_UNIT_TEST_SUITE(TShellCommandTest) {
             UNIT_ASSERT(cmd.GetExitCode().Defined() && -15 == cmd.GetExitCode());
         }
         sleep(1);
-        UNIT_ASSERT(!NFs::Exists(tmpfile));
+        UNIT_ASSERT(!NFs::Exists(tmpfile)); 
     }
     // this ut is unix-only (win has no signal mask)
     Y_UNIT_TEST(TestSignalMask) {
@@ -346,7 +346,7 @@ Y_UNIT_TEST_SUITE(TShellCommandTest) {
             UNIT_ASSERT(TShellCommand::SHELL_ERROR == cmd.GetStatus() || TShellCommand::SHELL_FINISHED == cmd.GetStatus());
         }
         sleep(1);
-        UNIT_ASSERT(!NFs::Exists(tmpfile));
+        UNIT_ASSERT(!NFs::Exists(tmpfile)); 
 
         // child proc should receive SIGTERM
         options.SetClearSignalMask(true);
@@ -362,7 +362,7 @@ Y_UNIT_TEST_SUITE(TShellCommandTest) {
             UNIT_ASSERT(TShellCommand::SHELL_ERROR == cmd.GetStatus());
         }
         sleep(1);
-        UNIT_ASSERT(!NFs::Exists(tmpfile));
+        UNIT_ASSERT(!NFs::Exists(tmpfile)); 
 
         // restore signal mask
         rc = SigProcMask(SIG_SETMASK, &oldmask, nullptr);
diff --git a/util/system/shmat_ut.cpp b/util/system/shmat_ut.cpp
index 9d92243ae7..f465593e5f 100644
--- a/util/system/shmat_ut.cpp
+++ b/util/system/shmat_ut.cpp
@@ -1,6 +1,6 @@
 #include "shmat.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TTestSharedMemory) {
     Y_UNIT_TEST(TestInProc) {
diff --git a/util/system/spinlock_ut.cpp b/util/system/spinlock_ut.cpp
index e8639a6404..c24bf92d45 100644
--- a/util/system/spinlock_ut.cpp
+++ b/util/system/spinlock_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include "spinlock.h"
 
diff --git a/util/system/src_location_ut.cpp b/util/system/src_location_ut.cpp
index 5b86cb86ef..26036c2eb4 100644
--- a/util/system/src_location_ut.cpp
+++ b/util/system/src_location_ut.cpp
@@ -2,7 +2,7 @@
 
 #include <util/string/builder.h>
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 static inline TString GenLoc() {
     return TStringBuilder() << __LOCATION__;
diff --git a/util/system/src_root_ut.cpp b/util/system/src_root_ut.cpp
index e9a675eb9a..d232aa8b71 100644
--- a/util/system/src_root_ut.cpp
+++ b/util/system/src_root_ut.cpp
@@ -1,13 +1,13 @@
 #include "src_root.h"
 
 #include <util/folder/pathsplit.h>
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TestSourceRoot) {
     Y_UNIT_TEST(TestStrip) {
         // Reconstruct() converts "\" -> "/" on Windows
         const TString path = TPathSplit(__SOURCE_FILE_IMPL__.As<TStringBuf>()).Reconstruct();
-        UNIT_ASSERT_EQUAL(path, "util" LOCSLASH_S "system" LOCSLASH_S "src_root_ut.cpp");
+        UNIT_ASSERT_EQUAL(path, "util" LOCSLASH_S "system" LOCSLASH_S "src_root_ut.cpp"); 
     }
 
     Y_UNIT_TEST(TestPrivateChopPrefixRoutine) {
diff --git a/util/system/tempfile_ut.cpp b/util/system/tempfile_ut.cpp
index e4a0923d0b..aba7268060 100644
--- a/util/system/tempfile_ut.cpp
+++ b/util/system/tempfile_ut.cpp
@@ -1,6 +1,6 @@
 #include "tempfile.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/folder/dirut.h>
 #include <util/generic/yexception.h>
@@ -18,7 +18,7 @@ Y_UNIT_TEST_SUITE(TTempFileHandle) {
             tmp.FlushData();
             UNIT_ASSERT_STRINGS_EQUAL(TUnbufferedFileInput(tmp.Name()).ReadAll(), "hello world\n");
         }
-        UNIT_ASSERT(!NFs::Exists(path));
+        UNIT_ASSERT(!NFs::Exists(path)); 
     }
 
     Y_UNIT_TEST(InCurrentDir) {
diff --git a/util/system/thread_ut.cpp b/util/system/thread_ut.cpp
index d820898fd5..3d5c0ac15e 100644
--- a/util/system/thread_ut.cpp
+++ b/util/system/thread_ut.cpp
@@ -1,6 +1,6 @@
 #include "thread.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <atomic>
 
diff --git a/util/system/tls.h b/util/system/tls.h
index 3c4f56dbeb..6742d2dba6 100644
--- a/util/system/tls.h
+++ b/util/system/tls.h
@@ -269,7 +269,7 @@ namespace NTls {
                 THolder<void> mem(::operator new(sizeof(T)));
                 THolder<T> newval(Constructor_->Construct(mem.Get()));
 
-                Y_UNUSED(mem.Release());
+                Y_UNUSED(mem.Release()); 
                 Key_.Set((void*)newval.Get());
                 val = newval.Release();
             }
diff --git a/util/system/tls_ut.cpp b/util/system/tls_ut.cpp
index e84d34b42a..c2d87b3a35 100644
--- a/util/system/tls_ut.cpp
+++ b/util/system/tls_ut.cpp
@@ -1,7 +1,7 @@
 #include "tls.h"
 #include "thread.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TTestTLS) {
     struct X {
diff --git a/util/system/type_name_ut.cpp b/util/system/type_name_ut.cpp
index 86597f4232..deff6c5268 100644
--- a/util/system/type_name_ut.cpp
+++ b/util/system/type_name_ut.cpp
@@ -1,6 +1,6 @@
 #include "type_name.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/generic/yexception.h>
 #include <util/generic/fwd.h>
diff --git a/util/system/types_ut.cpp b/util/system/types_ut.cpp
index 19e40cef46..0412c0c678 100644
--- a/util/system/types_ut.cpp
+++ b/util/system/types_ut.cpp
@@ -1,6 +1,6 @@
 #include "types.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TestTypes) {
     Y_UNIT_TEST(TestScanf) {
diff --git a/util/system/unaligned_mem_ut.cpp b/util/system/unaligned_mem_ut.cpp
index 9de3f3e931..48c547dc5c 100644
--- a/util/system/unaligned_mem_ut.cpp
+++ b/util/system/unaligned_mem_ut.cpp
@@ -1,7 +1,7 @@
 #include "unaligned_mem.h"
 
-#include <library/cpp/testing/benchmark/bench.h>
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/unittest/registar.h> 
 
 #include <util/system/compiler.h>
 
diff --git a/util/system/user_ut.cpp b/util/system/user_ut.cpp
index 4f8a5ce2ef..ec86c2b490 100644
--- a/util/system/user_ut.cpp
+++ b/util/system/user_ut.cpp
@@ -1,6 +1,6 @@
 #include "user.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(TestUser) {
     Y_UNIT_TEST(TestNotEmpty) {
diff --git a/util/system/ut/ya.make b/util/system/ut/ya.make
index 127e7c261e..4b6dd01cdf 100644
--- a/util/system/ut/ya.make
+++ b/util/system/ut/ya.make
@@ -20,7 +20,7 @@ IF (OS_DARWIN)
 ENDIF()
 
 PEERDIR(
-    library/cpp/testing/benchmark
+    library/cpp/testing/benchmark 
 )
 
 SRCS(
diff --git a/util/system/yassert.h b/util/system/yassert.h
index 529823440c..831fbbd3d5 100644
--- a/util/system/yassert.h
+++ b/util/system/yassert.h
@@ -2,7 +2,7 @@
 
 #include "defaults.h"
 #include "src_root.h"
-#include "backtrace.h"
+#include "backtrace.h" 
 
 #if defined(_MSC_VER)
     #include <new>
@@ -55,7 +55,7 @@ inline void YaDebugBreak() {
 }
 
 #undef Y_ASSERT
-
+ 
 #if !defined(NDEBUG) && !defined(__GCCXML__)
     #define Y_ASSERT(a)                                         \
         do {                                                    \
diff --git a/util/system/yassert_ut.cpp b/util/system/yassert_ut.cpp
index ddd392666c..6c1da535a4 100644
--- a/util/system/yassert_ut.cpp
+++ b/util/system/yassert_ut.cpp
@@ -2,7 +2,7 @@
 // yassert.h must be included before all headers
 #include "yassert.h"
 
-#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/registar.h> 
 
 Y_UNIT_TEST_SUITE(YassertTest) {
     Y_UNIT_TEST(TestAcsLikeFunctionCall) {