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

23 files changed, 359 insertions, 359 deletions

diff --git a/library/cpp/charset/recyr.hh b/library/cpp/charset/recyr.hh
index 72619201b7..5ec8734bcf 100644
--- a/library/cpp/charset/recyr.hh
+++ b/library/cpp/charset/recyr.hh
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cstdlib>
- 
+
 #include <util/charset/recode_result.h>
 #include <util/generic/ptr.h>
 #include <util/generic/yexception.h>
diff --git a/library/cpp/containers/atomizer/atomizer.h b/library/cpp/containers/atomizer/atomizer.h
index 53a17378af..5e40f47ab9 100644
--- a/library/cpp/containers/atomizer/atomizer.h
+++ b/library/cpp/containers/atomizer/atomizer.h
@@ -144,7 +144,7 @@ public:
         std::pair<iterator, bool> ins = insert_copy(key, ui32(size() + 1));
         if (ins.second) {                  // new?
             if (pool.Begin() != old_begin) // repoint?
-                for (typename TOrder::iterator ptr = order.begin(); ptr != order.end(); ++ptr) 
+                for (typename TOrder::iterator ptr = order.begin(); ptr != order.end(); ++ptr)
                     if (old_begin <= (*ptr).first && (*ptr).first < old_end) // from old pool?
                         (*ptr).first += pool.Begin() - old_begin;
             order.push_back(std::pair<const char*, T>((*ins.first).first, atom_data ? *atom_data : T()));
diff --git a/library/cpp/http/misc/httpcodes.cpp b/library/cpp/http/misc/httpcodes.cpp
index c778b614d3..ad8c80ac1e 100644
--- a/library/cpp/http/misc/httpcodes.cpp
+++ b/library/cpp/http/misc/httpcodes.cpp
@@ -107,7 +107,7 @@ TStringBuf HttpCodeStrEx(int code) noexcept {
             return TStringBuf("431 Request Header Fields Too Large");
         case HTTP_UNAVAILABLE_FOR_LEGAL_REASONS:
             return TStringBuf("451 Unavailable For Legal Reason");
- 
+
         case HTTP_INTERNAL_SERVER_ERROR:
             return TStringBuf("500 Internal server error");
         case HTTP_NOT_IMPLEMENTED:
@@ -138,4 +138,4 @@ TStringBuf HttpCodeStrEx(int code) noexcept {
         default:
             return TStringBuf("000 Unknown HTTP code");
     }
-} 
+}
diff --git a/library/cpp/mime/types/mime.cpp b/library/cpp/mime/types/mime.cpp
index 84681d9e4d..706d776b24 100644
--- a/library/cpp/mime/types/mime.cpp
+++ b/library/cpp/mime/types/mime.cpp
@@ -8,10 +8,10 @@
 
 #include <cctype>
 
-/* 
+/*
  * MIME types
- */ 
- 
+ */
+
 class TMimeTypes {
     // Constructor
 public:
@@ -165,29 +165,29 @@ const char* TMimeTypes::StrByMime(MimeTypes mime) const {
 }
 
 const char* mimetypeByExt(const char* fname, const char* check_ext) {
-    const char* ext_p; 
+    const char* ext_p;
     if (fname == nullptr || *fname == 0 ||
         (ext_p = strrchr(fname, '.')) == nullptr || strlen(ext_p) - 1 > TMimeTypes::MAX_EXT_LEN) {
         return nullptr;
-    } 
- 
+    }
+
     char ext[TMimeTypes::MAX_EXT_LEN + 1];
-    size_t i; 
-    ext_p++; 
+    size_t i;
+    ext_p++;
     for (i = 0; i < TMimeTypes::MAX_EXT_LEN && ext_p[i]; i++)
         ext[i] = (char)tolower(ext_p[i]);
-    ext[i] = 0; 
- 
+    ext[i] = 0;
+
     if (check_ext != nullptr) {
-        if (strcmp(ext, check_ext) == 0) 
-            return check_ext; 
-        else 
+        if (strcmp(ext, check_ext) == 0)
+            return check_ext;
+        else
             return nullptr;
-    } 
- 
+    }
+
     return Singleton<TMimeTypes>()->StrByExt(ext);
-} 
- 
+}
+
 MimeTypes mimeByStr(const char* mimeStr) {
     return Singleton<TMimeTypes>()->MimeByStr(mimeStr);
 }
diff --git a/library/cpp/packedtypes/longs_ut.cpp b/library/cpp/packedtypes/longs_ut.cpp
index e7f0263d93..8b06c934d2 100644
--- a/library/cpp/packedtypes/longs_ut.cpp
+++ b/library/cpp/packedtypes/longs_ut.cpp
@@ -1,19 +1,19 @@
 #include "longs.h"
 
 #include <library/cpp/testing/unittest/registar.h>
- 
+
 #include <library/cpp/digest/old_crc/crc.h>
 #include <util/string/util.h>
 #include <util/stream/output.h>
 #include <util/system/hi_lo.h>
- 
+
 Y_UNIT_TEST_SUITE(TLongsTest) {
     Y_UNIT_TEST(TestLongs) {
         i16 x16 = 40;
         i64 x64 = 40;
         i64 y64;
         TString s;
- 
+
         s += Sprintf("x16=0x%x\n", (int)x16);
         s += Sprintf("LO_8(x16)=0x%x HI_8(x16)=0x%x\n\n", (int)Lo8(x16), (int)Hi8(x16));
 
diff --git a/library/cpp/regex/pcre/regexp.cpp b/library/cpp/regex/pcre/regexp.cpp
index a1a40cb3d7..575c09cee4 100644
--- a/library/cpp/regex/pcre/regexp.cpp
+++ b/library/cpp/regex/pcre/regexp.cpp
@@ -193,8 +193,8 @@ private:
 
 bool TRegExBase::IsCompiled() const {
     return Impl && Impl->IsCompiled();
-} 
- 
+}
+
 TRegExBase::TRegExBase(const char* re, int cflags) {
     if (re) {
         Compile(re, cflags);
@@ -206,8 +206,8 @@ TRegExBase::TRegExBase(const TString& re, int cflags) {
 }
 
 TRegExBase::~TRegExBase() {
-} 
- 
+}
+
 void TRegExBase::Compile(const TString& re, int cflags) {
     Impl = new TRegExBaseImpl(re, cflags);
 }
@@ -216,20 +216,20 @@ int TRegExBase::Exec(const char* str, regmatch_t pmatch[], int eflags, int nmatc
     if (!Impl)
         ythrow yexception() << "!Regular expression is not compiled";
     return Impl->Exec(str, pmatch, eflags, nmatches);
-} 
- 
+}
+
 int TRegExBase::GetCompileOptions() const {
     if (!Impl)
         ythrow yexception() << "!Regular expression is not compiled";
     return Impl->CompileOptions;
-} 
- 
+}
+
 TString TRegExBase::GetRegExpr() const {
     if (!Impl)
         ythrow yexception() << "!Regular expression is not compiled";
     return Impl->RegExpr;
-} 
- 
+}
+
 TRegExMatch::TRegExMatch(const char* re, int cflags)
     : TRegExBase(re, cflags)
 {
@@ -255,21 +255,21 @@ TString TRegExSubst::Replace(const char* str, int eflags) {
     TString s;
     if (BrfsCount) {
         if (Exec(str, PMatch, eflags) == 0) {
-            int i; 
+            int i;
             for (i = 0; i < BrfsCount; i++) {
                 s += TString(Replacement, Brfs[i].Beg, Brfs[i].End - Brfs[i].Beg);
                 if (Brfs[i].Refer >= 0 && Brfs[i].Refer < NMATCHES)
                     s += TString(str, PMatch[Brfs[i].Refer].rm_so, int(PMatch[Brfs[i].Refer].rm_eo - PMatch[Brfs[i].Refer].rm_so));
-            } 
+            }
             s += TString(Replacement, Brfs[i].Beg, Brfs[i].End - Brfs[i].Beg);
-        } 
-    } else { 
+        }
+    } else {
         s = Replacement;
-    } 
-    return s; 
-} 
- 
-//*** 
+    }
+    return s;
+}
+
+//***
 // ��� ������������ ������ aaa.$1.$$$$.$2.bbb.$$$ccc Brfs ����� �����:
 // {beg = 0,  end = 4,  Refer =  1} => "aaa." + $1_match
 // {beg = 6,  end = 8,  Refer = -1} => ".$"
@@ -279,39 +279,39 @@ TString TRegExSubst::Replace(const char* str, int eflags) {
 // {beg = 21, end = 22, Refer = -1} => "$"
 // {beg = 22, end = 25, Refer = -1} => "ccc"
 // {beg = 0,  end = 0,  Refer =  0}
-//*** 
+//***
 int TRegExSubst::ParseReplacement(const char* repl) {
     Replacement = repl;
     if (!Replacement || *Replacement == 0)
-        return 0; 
+        return 0;
     char* pos = (char*)Replacement;
     char* pos1 = nullptr;
     char* pos2 = nullptr;
-    int i = 0; 
+    int i = 0;
     while (pos && *pos && i < NMATCHES) {
-        pos1 = strchr(pos, '$'); 
+        pos1 = strchr(pos, '$');
         Brfs[i].Refer = -1;
-        pos2 = pos1; 
-        if (pos1) { 
-            pos2 = pos1 + 1; 
+        pos2 = pos1;
+        if (pos1) {
+            pos2 = pos1 + 1;
             while (IsAsciiDigit(*pos2))
-                pos2++; 
+                pos2++;
             if (pos2 > pos1 + 1) {
                 Brfs[i].Refer = atol(TString(Replacement, pos1 + 1 - Replacement, pos2 - (pos1 + 1)).data());
-            } else { 
-                pos1++; 
+            } else {
+                pos1++;
                 if (*pos2 == '$')
-                    pos2++; 
+                    pos2++;
                 Brfs[i].Refer = -1;
-            } 
-        } 
+            }
+        }
         Brfs[i].Beg = int(pos - (char*)Replacement);
         Brfs[i].End = (pos1 == nullptr ? (int)strlen(Replacement) : int(pos1 - Replacement));
-        pos = pos2; 
-        i++; 
-    } 
+        pos = pos2;
+        i++;
+    }
     Brfs[i].Beg = Brfs[i].End = 0;
     Brfs[i].Refer = -1;
     BrfsCount = i;
     return BrfsCount;
-} 
+}
diff --git a/library/cpp/regex/pcre/regexp.h b/library/cpp/regex/pcre/regexp.h
index 340cf9e45e..bc610bd2f3 100644
--- a/library/cpp/regex/pcre/regexp.h
+++ b/library/cpp/regex/pcre/regexp.h
@@ -1,6 +1,6 @@
 #pragma once
- 
-#include <sys/types.h> 
+
+#include <sys/types.h>
 
 #include <util/system/defaults.h>
 #include <util/generic/string.h>
@@ -11,7 +11,7 @@
 
 //THIS CODE LOOKS LIKE A TRASH, BUT WORKS.
 
-#define NMATCHES 100 
+#define NMATCHES 100
 #define REGEXP_GLOBAL 0x0080 // use this if you want to find all occurences
 
 class TRegExBaseImpl;
@@ -31,22 +31,22 @@ public:
     bool IsCompiled() const;
     int GetCompileOptions() const;
     TString GetRegExpr() const;
-}; 
- 
+};
+
 class TRegExMatch: public TRegExBase {
 public:
     TRegExMatch(const char* regExpr = nullptr, int cflags = REG_NOSUB | REG_EXTENDED);
     TRegExMatch(const TString& regExpr, int cflags = REG_NOSUB | REG_EXTENDED);
- 
+
     bool Match(const char* str) const;
 };
- 
+
 struct TBackReferences {
     int Beg;
     int End;
     int Refer;
 };
- 
+
 class TRegExSubst: public TRegExBase {
 private:
     const char* Replacement;
@@ -60,4 +60,4 @@ public:
 
     TString Replace(const char* str, int eflags = 0);
     int ParseReplacement(const char* replacement);
-}; 
+};
diff --git a/util/folder/fts.cpp b/util/folder/fts.cpp
index 7d9417ea35..0e6a6f86eb 100644
--- a/util/folder/fts.cpp
+++ b/util/folder/fts.cpp
@@ -1,38 +1,38 @@
-/*- 
- * Copyright (c) 1990, 1993, 1994 
+/*-
+ * Copyright (c) 1990, 1993, 1994
  *    The Regents of the University of California.  All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
- * are met: 
- * 1. Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer. 
- * 2. Redistributions in binary form must reproduce the above copyright 
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the distribution. 
- * 3. All advertising materials mentioning features or use of this software 
- *    must display the following acknowledgement: 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
  *    This product includes software developed by the University of
  *    California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors 
- *    may be used to endorse or promote products derived from this software 
- *    without specific prior written permission. 
- * 
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
- * SUCH DAMAGE. 
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  *
  * $OpenBSD: fts.c,v 1.22 1999/10/03 19:22:22 millert Exp $
- */ 
- 
+ */
+
 #include <util/memory/tempbuf.h>
 #include <util/system/compat.h>
 #include <util/system/compiler.h>
@@ -52,10 +52,10 @@
     #include "dirent_win.h"
     #include "lstat_win.h"
 #endif
- 
-#include <sys/stat.h> 
- 
-#include <fcntl.h> 
+
+#include <sys/stat.h>
+
+#include <fcntl.h>
 
 #include "fts.h"
 #include <limits.h>
@@ -165,7 +165,7 @@ dird get_dird(char* path) {
 }
 
 #endif // ndef _win_
- 
+
 #ifdef _win_
     #define S_ISDIR(st_mode) ((st_mode & _S_IFMT) == _S_IFDIR)
     #define S_ISREG(st_mode) ((st_mode & _S_IFMT) == _S_IFREG)
@@ -187,10 +187,10 @@ static int fts_safe_changedir(FTS*, FTSENT*, int, dird);
         #define dirfd(dirp) ((dirp)->dd_fd)
     #endif
     #define D_NAMLEN(dirp) (strlen(dirp->d_name))
-#else 
+#else
     #define D_NAMLEN(dirp) (dirp->d_namlen)
-#endif 
- 
+#endif
+
 static FTSENT* fts_alloc(FTS*, const char*, int);
 static FTSENT* fts_build(FTS*, int);
 static void fts_lfree(FTSENT*);
@@ -201,20 +201,20 @@ static int fts_palloc(FTS*, size_t);
 static FTSENT* fts_sort(FTS*, FTSENT*, int);
 static u_short fts_stat(FTS*, FTSENT*, int);
 static int fts_safe_changedir(FTS*, FTSENT*, int, const char*);
- 
+
 #define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
- 
+
 #define CLR(opt) (sp->fts_options &= ~(opt))
 #define ISSET(opt) (sp->fts_options & (opt))
 #define SET(opt) (sp->fts_options |= (opt))
- 
+
 #define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && chdir_dird(fd))
- 
-/* fts_build flags */ 
+
+/* fts_build flags */
 #define BCHILD 1 /* yfts_children */
 #define BNAMES 2 /* yfts_children, names only */
 #define BREAD 3  /* yfts_read */
- 
+
 static u_short
 yfts_type_from_info(u_short info) {
     if (info == FTS_D || info == FTS_DP || info == FTS_DOT) {
@@ -229,24 +229,24 @@ yfts_type_from_info(u_short info) {
 
 static void*
 yreallocf(void* ptr, size_t size)
-{ 
+{
     void* nptr;
- 
+
     nptr = realloc(ptr, size);
     if (!nptr && ptr) {
         free(ptr);
     }
     return (nptr);
-} 
+}
 
 FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, const FTSENT**))
-{ 
+{
     FTS* sp;
     FTSENT *p, *root;
     int nitems;
     FTSENT *parent, *tmp;
     int len;
- 
+
     errno = 0;
 
     Y_ASSERT(argv);
@@ -260,7 +260,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
         errno = EINVAL;
         return nullptr;
     }
- 
+
     /* Allocate/initialize the stream */
     if ((sp = (FTS*)malloc(sizeof(FTS))) == nullptr) {
         return nullptr;
@@ -268,7 +268,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     memset(sp, 0, sizeof(FTS));
     sp->fts_compar = compar;
     sp->fts_options = options;
- 
+
     /* Shush, GCC. */
     tmp = nullptr;
 
@@ -276,7 +276,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (ISSET(FTS_LOGICAL)) {
         SET(FTS_NOCHDIR);
     }
- 
+
     /*
      * Start out with 1K of path space, and enough, in any case,
      * to hold the user's paths.
@@ -284,13 +284,13 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN))) {
         goto mem1;
     }
- 
+
     /* Allocate/initialize root's parent. */
     if ((parent = fts_alloc(sp, "", 0)) == nullptr) {
         goto mem2;
     }
     parent->fts_level = FTS_ROOTPARENTLEVEL;
- 
+
     /* Allocate/initialize root(s). */
     for (root = nullptr, nitems = 0; *argv; ++argv, ++nitems) {
         /* Don't allow zero-length paths. */
@@ -308,19 +308,19 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
             errno = ENOENT;
             goto mem3;
         }
- 
+
         p = fts_alloc(sp, *argv, len);
         p->fts_level = FTS_ROOTLEVEL;
         p->fts_parent = parent;
         p->fts_accpath = p->fts_name;
         p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
         p->fts_type = yfts_type_from_info(p->fts_info);
- 
+
         /* Command-line "." and ".." are real directories. */
         if (p->fts_info == FTS_DOT) {
             p->fts_info = FTS_D;
         }
- 
+
         /*
          * If comparison routine supplied, traverse in sorted
          * order; otherwise traverse in the order specified.
@@ -341,7 +341,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (compar && nitems > 1) {
         root = fts_sort(sp, root, nitems);
     }
- 
+
     /*
      * Allocate a dummy pointer and make yfts_read think that we've just
      * finished the node before the root(s); set p->fts_info to FTS_INIT
@@ -353,7 +353,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     sp->fts_cur->fts_level = FTS_ROOTLEVEL;
     sp->fts_cur->fts_link = root;
     sp->fts_cur->fts_info = FTS_INIT;
- 
+
     /*
      * If using chdir(2), grab a file descriptor pointing to dot to ensure
      * that we can get back here; this could be avoided for some paths,
@@ -365,9 +365,9 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (!ISSET(FTS_NOCHDIR) && valid_dird(sp->fts_rfd = get_cwdd())) {
         SET(FTS_NOCHDIR);
     }
- 
+
     return (sp);
- 
+
 mem3:
     fts_lfree(root);
     free(parent);
@@ -376,14 +376,14 @@ mem2:
 mem1:
     free(sp);
     return nullptr;
-} 
- 
-static void 
+}
+
+static void
 fts_load(FTS* sp, FTSENT* p)
-{ 
+{
     size_t len;
     char* cp;
- 
+
     /*
      * Load the stream structure for the next traversal.  Since we don't
      * actually enter the directory until after the preorder visit, set
@@ -400,13 +400,13 @@ fts_load(FTS* sp, FTSENT* p)
     }
     p->fts_accpath = p->fts_path = sp->fts_path;
     sp->fts_dev = p->fts_dev;
-} 
- 
+}
+
 int yfts_close(FTS* sp)
-{ 
+{
     FTSENT *freep, *p;
     int saved_errno;
- 
+
     /*
      * This still works if we haven't read anything -- the dummy structure
      * points to the root list, so we step through to the end of the root
@@ -420,7 +420,7 @@ int yfts_close(FTS* sp)
         }
         free(p);
     }
- 
+
     /* Free up child linked list, sort array, path buffer. */
     if (sp->fts_child) {
         fts_lfree(sp->fts_child);
@@ -429,7 +429,7 @@ int yfts_close(FTS* sp)
         free(sp->fts_array);
     }
     free(sp->fts_path);
- 
+
     /* Return to original directory, save errno if necessary. */
     if (!ISSET(FTS_NOCHDIR)) {
         saved_errno = chdir_dird(sp->fts_rfd) ? errno : 0;
@@ -443,49 +443,49 @@ int yfts_close(FTS* sp)
             return (-1);
         }
     }
- 
+
     /* Free up the stream pointer. */
     free(sp);
     return (0);
-} 
- 
-/* 
+}
+
+/*
  * Special case of "/" at the end of the path so that slashes aren't
  * appended which would cause paths to be written as "....//foo".
- */ 
+ */
 #define NAPPEND(p)                                 \
     (p->fts_path[p->fts_pathlen - 1] == LOCSLASH_C \
          ? p->fts_pathlen - 1                      \
          : p->fts_pathlen)
- 
+
 FTSENT*
 yfts_read(FTS* sp) {
     FTSENT *p, *tmp;
     int instr;
     char* t;
     int saved_errno;
- 
+
     ClearLastSystemError();
 
     /* If finished or unrecoverable error, return NULL. */
     if (sp->fts_cur == nullptr || ISSET(FTS_STOP)) {
         return nullptr;
     }
- 
+
     /* Set current node pointer. */
     p = sp->fts_cur;
- 
+
     /* Save and zero out user instructions. */
     instr = p->fts_instr;
     p->fts_instr = FTS_NOINSTR;
- 
+
     /* Any type of file may be re-visited; re-stat and re-turn. */
     if (instr == FTS_AGAIN) {
         p->fts_info = fts_stat(sp, p, 0);
         p->fts_type = yfts_type_from_info(p->fts_info);
         return (p);
     }
- 
+
     /*
      * Following a symlink -- SLNONE test allows application to see
      * SLNONE and recover.  If indirecting through a symlink, have
@@ -506,7 +506,7 @@ yfts_read(FTS* sp) {
         }
         return (p);
     }
- 
+
     /* Directory in pre-order. */
     if (p->fts_info == FTS_D) {
         /* If skipped or crossed mount point, do post-order visit. */
@@ -522,14 +522,14 @@ yfts_read(FTS* sp) {
             p->fts_info = FTS_DP;
             return (p);
         }
- 
+
         /* Rebuild if only read the names and now traversing. */
         if (sp->fts_child && ISSET(FTS_NAMEONLY)) {
             CLR(FTS_NAMEONLY);
             fts_lfree(sp->fts_child);
             sp->fts_child = nullptr;
         }
- 
+
         /*
          * Cd to the subdirectory.
          *
@@ -561,13 +561,13 @@ yfts_read(FTS* sp) {
         sp->fts_child = nullptr;
         goto name;
     }
- 
+
     /* Move to the next node on this level. */
 next:
     tmp = p;
     if ((p = p->fts_link) != nullptr) {
         free(tmp);
- 
+
         /*
          * If reached the top, return to the original directory (or
          * the root of the tree), and load the paths for the next root.
@@ -580,7 +580,7 @@ next:
             fts_load(sp, p);
             return (sp->fts_cur = p);
         }
- 
+
         /*
          * User may have called yfts_set on the node.  If skipped,
          * ignore.  If followed, get a file descriptor so we can
@@ -603,18 +603,18 @@ next:
             }
             p->fts_instr = FTS_NOINSTR;
         }
- 
+
     name:
         t = sp->fts_path + NAPPEND(p->fts_parent);
         *t++ = LOCSLASH_C;
         memmove(t, p->fts_name, (size_t)p->fts_namelen + 1);
         return (sp->fts_cur = p);
     }
- 
+
     /* Move up to the parent node. */
     p = tmp->fts_parent;
     free(tmp);
- 
+
     if (p->fts_level == FTS_ROOTPARENTLEVEL) {
         /*
          * Done; free everything up and set errno to 0 so the user
@@ -624,10 +624,10 @@ next:
         errno = 0;
         return (sp->fts_cur = nullptr);
     }
- 
+
     /* NUL terminate the pathname. */
     sp->fts_path[p->fts_pathlen] = '\0';
- 
+
     /*
      * Return to the parent directory.  If at a root node or came through
      * a symlink, go back through the file descriptor.  Otherwise, cd up
@@ -654,17 +654,17 @@ next:
     }
     p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
     return (sp->fts_cur = p);
-} 
- 
-/* 
- * Fts_set takes the stream as an argument although it's not used in this 
- * implementation; it would be necessary if anyone wanted to add global 
- * semantics to fts using yfts_set.  An error return is allowed for similar 
- * reasons. 
- */ 
-/* ARGSUSED */ 
+}
+
+/*
+ * Fts_set takes the stream as an argument although it's not used in this
+ * implementation; it would be necessary if anyone wanted to add global
+ * semantics to fts using yfts_set.  An error return is allowed for similar
+ * reasons.
+ */
+/* ARGSUSED */
 int yfts_set(FTS* sp, FTSENT* p, int instr)
-{ 
+{
     (void)sp; //Unused
     if (instr && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
         instr != FTS_NOINSTR && instr != FTS_SKIP) {
@@ -673,37 +673,37 @@ int yfts_set(FTS* sp, FTSENT* p, int instr)
     }
     p->fts_instr = (u_short)instr;
     return (0);
-} 
- 
+}
+
 FTSENT*
 yfts_children(FTS* sp, int instr)
-{ 
+{
     FTSENT* p;
     dird fd;
     if (instr && instr != FTS_NAMEONLY) {
         errno = EINVAL;
         return nullptr;
     }
- 
+
     /* Set current node pointer. */
     p = sp->fts_cur;
- 
+
     /*
      * Errno set to 0 so user can distinguish empty directory from
      * an error.
      */
     errno = 0;
- 
+
     /* Fatal errors stop here. */
     if (ISSET(FTS_STOP)) {
         return nullptr;
     }
- 
+
     /* Return logical hierarchy of user's arguments. */
     if (p->fts_info == FTS_INIT) {
         return (p->fts_link);
     }
- 
+
     /*
      * If not a directory being visited in pre-order, stop here.  Could
      * allow FTS_DNR, assuming the user has fixed the problem, but the
@@ -712,19 +712,19 @@ yfts_children(FTS* sp, int instr)
     if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */) {
         return nullptr;
     }
- 
+
     /* Free up any previous child list. */
     if (sp->fts_child) {
         fts_lfree(sp->fts_child);
     }
- 
+
     if (instr == FTS_NAMEONLY) {
         SET(FTS_NAMEONLY);
         instr = BNAMES;
     } else {
         instr = BCHILD;
     }
- 
+
     /*
      * If using chdir on a relative path and called BEFORE yfts_read does
      * its chdir to the root of a traversal, we can lose -- we need to
@@ -736,7 +736,7 @@ yfts_children(FTS* sp, int instr)
         ISSET(FTS_NOCHDIR)) {
         return (sp->fts_child = fts_build(sp, instr));
     }
- 
+
     if (valid_dird(fd = get_cwdd())) {
         return nullptr;
     }
@@ -747,8 +747,8 @@ yfts_children(FTS* sp, int instr)
     }
     close_dird(fd);
     return (sp->fts_child);
-} 
- 
+}
+
 static inline struct dirent* yreaddir(DIR* dir, struct dirent* de) {
     // TODO(yazevnul|IGNIETFERRO-1070): remove these macroses by replacing `readdir_r` with proper
     // alternative
@@ -762,23 +762,23 @@ static inline struct dirent* yreaddir(DIR* dir, struct dirent* de) {
     return nullptr;
 }
 
-/* 
- * This is the tricky part -- do not casually change *anything* in here.  The 
- * idea is to build the linked list of entries that are used by yfts_children 
- * and yfts_read.  There are lots of special cases. 
- * 
- * The real slowdown in walking the tree is the stat calls.  If FTS_NOSTAT is 
- * set and it's a physical walk (so that symbolic links can't be directories), 
- * we can do things quickly.  First, if it's a 4.4BSD file system, the type 
- * of the file is in the directory entry.  Otherwise, we assume that the number 
- * of subdirectories in a node is equal to the number of links to the parent. 
- * The former skips all stat calls.  The latter skips stat calls in any leaf 
- * directories and for any files after the subdirectories in the directory have 
- * been found, cutting the stat calls by about 2/3. 
- */ 
+/*
+ * This is the tricky part -- do not casually change *anything* in here.  The
+ * idea is to build the linked list of entries that are used by yfts_children
+ * and yfts_read.  There are lots of special cases.
+ *
+ * The real slowdown in walking the tree is the stat calls.  If FTS_NOSTAT is
+ * set and it's a physical walk (so that symbolic links can't be directories),
+ * we can do things quickly.  First, if it's a 4.4BSD file system, the type
+ * of the file is in the directory entry.  Otherwise, we assume that the number
+ * of subdirectories in a node is equal to the number of links to the parent.
+ * The former skips all stat calls.  The latter skips stat calls in any leaf
+ * directories and for any files after the subdirectories in the directory have
+ * been found, cutting the stat calls by about 2/3.
+ */
 static FTSENT*
 fts_build(FTS* sp, int type)
-{ 
+{
     struct dirent* dp;
     FTSENT *p, *head;
     int nitems;
@@ -795,10 +795,10 @@ fts_build(FTS* sp, int type)
     int cderrno, descend, len, level, maxlen, nlinks, saved_errno,
         nostat, doadjust;
     char* cp;
- 
+
     /* Set current node pointer. */
     cur = sp->fts_cur;
- 
+
     /*
      * Open the directory for reading.  If this fails, we're done.
      * If being called from yfts_read, set the fts_info field.
@@ -818,7 +818,7 @@ fts_build(FTS* sp, int type)
         }
         return nullptr;
     }
- 
+
 #ifdef _win_
     dirpd = get_dird(cur->fts_accpath);
 #endif
@@ -839,7 +839,7 @@ fts_build(FTS* sp, int type)
         nlinks = -1;
         nostat = 0;
     }
- 
+
     /*
      * If we're going to need to stat anything or we want to descend
      * and stay in the directory, chdir.  If this fails we keep going,
@@ -883,7 +883,7 @@ fts_build(FTS* sp, int type)
     } else {
         descend = 0;
     }
- 
+
     /*
      * Figure out the max file name length that can be stored in the
      * current path -- the inner loop allocates more path as necessary.
@@ -904,9 +904,9 @@ fts_build(FTS* sp, int type)
     }
     ++len;
     maxlen = sp->fts_pathlen - len;
- 
+
     level = cur->fts_level + 1;
- 
+
     /* Read the directory, attaching each entry to the `link' pointer. */
     doadjust = 0;
 
@@ -917,7 +917,7 @@ fts_build(FTS* sp, int type)
         if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name)) {
             continue;
         }
- 
+
         if ((p = fts_alloc(sp, dp->d_name, (int)strlen(dp->d_name))) == nullptr) {
             goto mem1;
         }
@@ -953,7 +953,7 @@ fts_build(FTS* sp, int type)
             }
             maxlen = sp->fts_pathlen - len;
         }
- 
+
         if (len + strlen(dp->d_name) >= USHRT_MAX) {
             /*
              * In an FTSENT, fts_pathlen is a u_short so it is
@@ -975,7 +975,7 @@ fts_build(FTS* sp, int type)
         p->fts_level = (short)level;
         p->fts_parent = sp->fts_cur;
         p->fts_pathlen = u_short(len + strlen(dp->d_name));
- 
+
 #ifdef FTS_WHITEOUT
         if (dp->d_type == DT_WHT)
             p->fts_flags |= FTS_ISW;
@@ -1001,10 +1001,10 @@ fts_build(FTS* sp, int type)
             }
             p->fts_accpath = cur->fts_accpath;
         } else if (nlinks == 0
-#ifdef DT_DIR 
+#ifdef DT_DIR
                    || (nostat &&
                        dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
-#endif 
+#endif
         ) {
             p->fts_accpath =
                 ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
@@ -1020,14 +1020,14 @@ fts_build(FTS* sp, int type)
             /* Stat it. */
             p->fts_info = fts_stat(sp, p, 0);
             p->fts_type = yfts_type_from_info(p->fts_info);
- 
+
             /* Decrement link count if applicable. */
             if (nlinks > 0 && (p->fts_info == FTS_D ||
                                p->fts_info == FTS_DC || p->fts_info == FTS_DOT)) {
                 --nlinks;
             }
         }
- 
+
         /* We walk in directory order so "ls -f" doesn't get upset. */
         p->fts_link = nullptr;
         if (head == nullptr) {
@@ -1044,7 +1044,7 @@ fts_build(FTS* sp, int type)
         close_dird(dirpd);
 #endif
     }
- 
+
     /*
      * If realloc() changed the address of the path, adjust the
      * addresses for the rest of the tree and the dir list.
@@ -1052,7 +1052,7 @@ fts_build(FTS* sp, int type)
     if (doadjust) {
         fts_padjust(sp);
     }
- 
+
     /*
      * If not changing directories, reset the path back to original
      * state.
@@ -1063,7 +1063,7 @@ fts_build(FTS* sp, int type)
         }
         *cp = '\0';
     }
- 
+
     /*
      * If descended after called from yfts_children or after called from
      * yfts_read and nothing found, get back.  At the root level we use
@@ -1078,7 +1078,7 @@ fts_build(FTS* sp, int type)
         fts_lfree(head);
         return nullptr;
     }
- 
+
     /* If didn't find anything, return NULL. */
     if (!nitems) {
         if (type == BREAD) {
@@ -1087,24 +1087,24 @@ fts_build(FTS* sp, int type)
         fts_lfree(head);
         return nullptr;
     }
- 
+
     /* Sort the entries. */
     if (sp->fts_compar && nitems > 1) {
         head = fts_sort(sp, head, nitems);
     }
     return (head);
-} 
- 
-static u_short 
+}
+
+static u_short
 fts_stat(FTS* sp, FTSENT* p, int follow)
-{ 
+{
     dev_t dev;
     ino_t ino;
     stat_struct *sbp, sb;
     int saved_errno;
     /* If user needs stat info, stat buffer already allocated. */
     sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
- 
+
 #ifdef FTS_WHITEOUT
     /* check for whiteout */
     if (p->fts_flags & FTS_ISW) {
@@ -1137,7 +1137,7 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         memset(sbp, 0, sizeof(stat_struct));
         return (FTS_NS);
     }
- 
+
     if (S_ISDIR(sbp->st_mode)) {
         /*
          * Set the device/inode.  Used to find cycles and check for
@@ -1149,12 +1149,12 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         dev = p->fts_dev = sbp->st_dev;
         ino = p->fts_ino = sbp->st_ino;
         p->fts_nlink = sbp->st_nlink;
- 
+
         const char* fts_name_x = p->fts_name;
         if (ISDOT(fts_name_x)) {
             return (FTS_DOT);
         }
- 
+
         /*
          * Cycle detection is done by brute force when the directory
          * is first encountered.  If the tree gets deep enough or the
@@ -1183,13 +1183,13 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         return (FTS_F);
     }
     return (FTS_DEFAULT);
-} 
- 
+}
+
 static FTSENT*
 fts_sort(FTS* sp, FTSENT* head, int nitems)
-{ 
+{
     FTSENT **ap, *p;
- 
+
     /*
      * Construct an array of pointers to the structures and call qsort(3).
      * Reassemble the array in the order returned by qsort.  If unable to
@@ -1221,14 +1221,14 @@ fts_sort(FTS* sp, FTSENT* head, int nitems)
     }
     ap[0]->fts_link = nullptr;
     return (head);
-} 
- 
+}
+
 static FTSENT*
 fts_alloc(FTS* sp, const char* name, int namelen)
-{ 
+{
     FTSENT* p;
     size_t len;
- 
+
     /*
      * The file name is a variable length array and no stat structure is
      * necessary if the user has set the nostat bit.  Allocate the FTSENT
@@ -1244,11 +1244,11 @@ fts_alloc(FTS* sp, const char* name, int namelen)
     if ((p = (FTSENT*)malloc(len)) == nullptr) {
         return nullptr;
     }
- 
+
     /* Copy the name and guarantee NUL termination. */
     memmove((void*)p->fts_name, (void*)name, (size_t)namelen);
     p->fts_name[namelen] = '\0';
- 
+
     if (!ISSET(FTS_NOSTAT)) {
         p->fts_statp = (stat_struct*)ALIGN(p->fts_name + namelen + 2);
     }
@@ -1261,34 +1261,34 @@ fts_alloc(FTS* sp, const char* name, int namelen)
     p->fts_pointer = nullptr;
     p->fts_type = FTS_NSOK;
     return (p);
-} 
- 
-static void 
+}
+
+static void
 fts_lfree(FTSENT* head)
-{ 
+{
     FTSENT* p;
- 
+
     /* Free a linked list of structures. */
     while ((p = head) != nullptr) {
         head = head->fts_link;
         free(p);
     }
-} 
- 
-/* 
- * Allow essentially unlimited paths; find, rm, ls should all work on any tree. 
- * Most systems will allow creation of paths much longer than MAXPATHLEN, even 
- * though the kernel won't resolve them.  Add the size (not just what's needed) 
- * plus 256 bytes so don't realloc the path 2 bytes at a time. 
- */ 
-static int 
+}
+
+/*
+ * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
+ * Most systems will allow creation of paths much longer than MAXPATHLEN, even
+ * though the kernel won't resolve them.  Add the size (not just what's needed)
+ * plus 256 bytes so don't realloc the path 2 bytes at a time.
+ */
+static int
 fts_palloc(FTS* sp, size_t more)
-{ 
+{
     sp->fts_pathlen += more + 256;
     sp->fts_path = (char*)yreallocf(sp->fts_path, (size_t)sp->fts_pathlen);
     return (sp->fts_path == nullptr);
-} 
- 
+}
+
 static void
 ADJUST(FTSENT* p, void* addr)
 {
@@ -1307,16 +1307,16 @@ ADJUST(FTSENT* p, void* addr)
     (p)->fts_path = (char*)addr;
 }
 
-/* 
- * When the path is realloc'd, have to fix all of the pointers in structures 
- * already returned. 
- */ 
-static void 
+/*
+ * When the path is realloc'd, have to fix all of the pointers in structures
+ * already returned.
+ */
+static void
 fts_padjust(FTS* sp)
-{ 
+{
     FTSENT* p;
     char* addr = sp->fts_path;
- 
+
 #define ADJUST1(p)                             \
     {                                          \
         if ((p)->fts_accpath == (p)->fts_path) \
@@ -1327,26 +1327,26 @@ fts_padjust(FTS* sp)
     for (p = sp->fts_child; p; p = p->fts_link) {
         ADJUST(p, addr);
     }
- 
+
     /* Adjust the rest of the tree. */
     for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
         ADJUST(p, addr);
         p = p->fts_link ? p->fts_link : p->fts_parent;
     }
-} 
- 
-static size_t 
+}
+
+static size_t
 fts_maxarglen(char* const* argv)
-{ 
+{
     size_t len, max;
- 
+
     for (max = 0; *argv; ++argv) {
         if ((len = strlen(*argv)) > max) {
             max = len;
         }
     }
     return (max + 1);
-} 
+}
 
 /*
  * Change to dir specified by fd or p->fts_accpath without getting
diff --git a/util/folder/fts.h b/util/folder/fts.h
index 02372fd04b..f3c799e8c8 100644
--- a/util/folder/fts.h
+++ b/util/folder/fts.h
@@ -1,5 +1,5 @@
 #pragma once
- 
+
 #include <sys/types.h>
 
 #include <util/system/defaults.h>
@@ -22,7 +22,7 @@ int stat64UTF(dird path, struct _stat64* _Stat);
     #endif
 #endif
 
-typedef struct { 
+typedef struct {
     struct _ftsent* fts_cur;    /* current node */
     struct _ftsent* fts_child;  /* linked list of children */
     struct _ftsent** fts_array; /* sort array */
@@ -33,7 +33,7 @@ typedef struct {
     int fts_nitems;             /* elements in the sort array */
     int(*fts_compar)            /* compare function */
         (const struct _ftsent**, const struct _ftsent**);
- 
+
 #define FTS_COMFOLLOW 0x001  /* follow command line symlinks */
 #define FTS_LOGICAL 0x002    /* logical walk */
 #define FTS_NOCHDIR 0x004    /* don't change directories */
@@ -42,13 +42,13 @@ typedef struct {
 #define FTS_SEEDOT 0x020     /* return dot and dot-dot */
 #define FTS_XDEV 0x040       /* don't cross devices */
 #define FTS_OPTIONMASK 0x0ff /* valid user option mask */
- 
+
 #define FTS_NAMEONLY 0x100 /* (private) child names only */
 #define FTS_STOP 0x200     /* (private) unrecoverable error */
     int fts_options;       /* yfts_open options, global flags */
-} FTS; 
- 
-typedef struct _ftsent { 
+} FTS;
+
+typedef struct _ftsent {
     struct _ftsent* fts_cycle;  /* cycle node */
     struct _ftsent* fts_parent; /* parent directory */
     struct _ftsent* fts_link;   /* next file in directory */
@@ -60,15 +60,15 @@ typedef struct _ftsent {
     dird fts_symfd;             /* fd for symlink */
     u_short fts_pathlen;        /* strlen(fts_path) */
     u_short fts_namelen;        /* strlen(fts_name) */
- 
+
     ino_t fts_ino;     /* inode */
     dev_t fts_dev;     /* device */
     nlink_t fts_nlink; /* link count */
- 
+
 #define FTS_ROOTPARENTLEVEL -1
 #define FTS_ROOTLEVEL 0
     short fts_level; /* depth (-1 to N) */
- 
+
 #define FTS_D 1       /* preorder directory */
 #define FTS_DC 2      /* directory that causes cycles */
 #define FTS_DEFAULT 3 /* none of the above */
@@ -85,22 +85,22 @@ typedef struct _ftsent {
 #define FTS_W 14      /* whiteout object */
     u_short fts_info; /* user flags for FTSENT structure */
     u_short fts_type; /* type of fs node; one of FTS_D, FTS_F, FTS_SL */
- 
+
 #define FTS_DONTCHDIR 0x01 /* don't chdir .. to the parent */
 #define FTS_SYMFOLLOW 0x02 /* followed a symlink to get here */
 #define FTS_ISW 0x04       /* this is a whiteout object */
     u_short fts_flags;     /* private flags for FTSENT structure */
- 
+
 #define FTS_AGAIN 1    /* read node again */
 #define FTS_FOLLOW 2   /* follow symbolic link */
 #define FTS_NOINSTR 3  /* no instructions */
 #define FTS_SKIP 4     /* discard node */
     u_short fts_instr; /* yfts_set() instructions */
- 
+
     stat_struct* fts_statp; /* stat(2) information */
     char fts_name[1];       /* file name */
-} FTSENT; 
- 
+} FTSENT;
+
 FTSENT* yfts_children(FTS*, int);
 int yfts_close(FTS*);
 FTS* yfts_open(char* const*, int, int (*)(const FTSENT**, const FTSENT**));
diff --git a/util/generic/hash_set.h b/util/generic/hash_set.h
index 5511c213a1..e8088cf23b 100644
--- a/util/generic/hash_set.h
+++ b/util/generic/hash_set.h
@@ -15,7 +15,7 @@ private:
     ht rep;
 
     using mutable_iterator = typename ht::iterator;
- 
+
 public:
     using key_type = typename ht::key_type;
     using value_type = typename ht::value_type;
diff --git a/util/generic/string_ut.h b/util/generic/string_ut.h
index 1207777233..44bb10bdeb 100644
--- a/util/generic/string_ut.h
+++ b/util/generic/string_ut.h
@@ -599,49 +599,49 @@ public:
         s = Data._0123456xyz();
         s.prepend(TStringType(Data.abc()));
         UNIT_ASSERT(s == Data.abc0123456xyz());
- 
+
         s.prepend(TStringType(Data.ABC()), 1, 2);
         UNIT_ASSERT(s == Data.BCabc0123456xyz());
- 
+
         s.prepend(Data.qwe());
         UNIT_ASSERT(s == Data.qweBCabc0123456xyz());
- 
+
         s.prepend(*Data._1());
         UNIT_ASSERT(s == Data._1qweBCabc0123456xyz());
- 
+
         // substr
         s = Data.abc0123456xyz();
         s = s.substr(3, 7);
         UNIT_ASSERT(s == Data._0123456());
- 
+
         // insert family
         s.insert(2, Data.abc());
         UNIT_ASSERT(s == Data._01abc23456());
- 
+
         s.insert(2, TStringType(Data.ABC()));
         UNIT_ASSERT(s == Data._01ABCabc23456());
- 
+
         s.insert(0, TStringType(Data.QWE()), 1, 1);
         UNIT_ASSERT(s == Data.W01ABCabc23456());
- 
+
         // replace family
         s = Data._01abc23456();
         s.replace(0, 7, Data.abcd());
         UNIT_ASSERT(s == Data.abcd456());
- 
+
         s.replace(4, 3, TStringType(Data.ABCD()));
         UNIT_ASSERT(s == Data.abcdABCD());
- 
+
         s.replace(7, 10, TStringType(Data._01234()), 1, 3);
         UNIT_ASSERT(s == Data.abcdABC123());
         UNIT_ASSERT(Data.abcdABC123() == s);
- 
+
         // remove, erase
         s.remove(4);
         UNIT_ASSERT(s == Data.abcd());
         s.erase(3);
         UNIT_ASSERT(s == Data.abc());
- 
+
         // Read access
         s = Data._012345();
         UNIT_ASSERT(s.at(1) == *Data._1());
@@ -659,7 +659,7 @@ public:
             // un-protect
             using TStr::RefCount;
         };
- 
+
         TestStroka s1(Data.orig());
         UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true);
         TestStroka s2(s1);
@@ -673,7 +673,7 @@ public:
         UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), false);
     }
 #endif
- 
+
     //  Find family
 
     void TestFind() {
@@ -747,51 +747,51 @@ public:
         // operator +=
         s += TStringType(Data.x());
         UNIT_ASSERT(s == Data._0123456x());
- 
+
         s += Data.y();
         UNIT_ASSERT(s == Data._0123456xy());
- 
+
         s += *Data.z();
         UNIT_ASSERT(s == Data._0123456xyz());
- 
+
         // operator +
         s = Data._0123456();
         s = s + TStringType(Data.x());
         UNIT_ASSERT(s == Data._0123456x());
- 
+
         s = s + Data.y();
         UNIT_ASSERT(s == Data._0123456xy());
- 
+
         s = s + *Data.z();
         UNIT_ASSERT(s == Data._0123456xyz());
- 
+
         // operator !=
         s = Data._012345();
         UNIT_ASSERT(s != TStringType(Data.xyz()));
         UNIT_ASSERT(s != Data.xyz());
         UNIT_ASSERT(Data.xyz() != s);
- 
+
         // operator <
         UNIT_ASSERT_EQUAL(s < TStringType(Data.xyz()), true);
         UNIT_ASSERT_EQUAL(s < Data.xyz(), true);
         UNIT_ASSERT_EQUAL(Data.xyz() < s, false);
- 
+
         // operator <=
         UNIT_ASSERT_EQUAL(s <= TStringType(Data.xyz()), true);
         UNIT_ASSERT_EQUAL(s <= Data.xyz(), true);
         UNIT_ASSERT_EQUAL(Data.xyz() <= s, false);
- 
+
         // operator >
         UNIT_ASSERT_EQUAL(s > TStringType(Data.xyz()), false);
         UNIT_ASSERT_EQUAL(s > Data.xyz(), false);
         UNIT_ASSERT_EQUAL(Data.xyz() > s, true);
- 
+
         // operator >=
         UNIT_ASSERT_EQUAL(s >= TStringType(Data.xyz()), false);
         UNIT_ASSERT_EQUAL(s >= Data.xyz(), false);
         UNIT_ASSERT_EQUAL(Data.xyz() >= s, true);
     }
- 
+
     void TestOperatorsCI() {
         TStringType s(Data.ABCD());
         UNIT_ASSERT(s > Data.abc0123456xyz());
@@ -815,30 +815,30 @@ public:
             UNIT_ASSERT_EQUAL(s, TStringType(Data._00()));
         }
     }
- 
+
     // Test any other functions
 
     void TestFuncs() {
         TStringType s(Data._0123456());
         UNIT_ASSERT(s.c_str() == s.data());
- 
+
         // length()
         UNIT_ASSERT(s.length() == s.size());
         UNIT_ASSERT(s.length() == traits_type::length(s.data()));
- 
+
         // is_null()
         TStringType s1(Data.Empty());
         UNIT_ASSERT(s1.is_null() == true);
         UNIT_ASSERT(s1.is_null() == s1.empty());
         UNIT_ASSERT(s1.is_null() == !s1);
- 
+
         TStringType s2(s);
         UNIT_ASSERT(s2 == s);
- 
+
         // reverse()
         ReverseInPlace(s2);
         UNIT_ASSERT(s2 == Data._6543210());
- 
+
         // to_upper()
         s2 = Data.asdf1234qwer();
         s2.to_upper();
@@ -847,16 +847,16 @@ public:
         // to_lower()
         s2.to_lower();
         UNIT_ASSERT(s2 == Data.asdf1234qwer());
- 
+
         // to_title()
         s2 = Data.asDF1234qWEr();
         s2.to_title();
         UNIT_ASSERT(s2 == Data.Asdf1234qwer());
- 
+
         s2 = Data.AsDF1234qWEr();
         s2.to_title();
         UNIT_ASSERT(s2 == Data.Asdf1234qwer());
- 
+
         // Friend functions
         s2 = Data.asdf1234qwer();
         TStringType s3 = to_upper(s2);
@@ -866,34 +866,34 @@ public:
         s3 = to_title(s2);
         UNIT_ASSERT(s3 == Data.Asdf1234qwer());
         s2 = s3;
- 
+
         // resize family
         s2.resize(s2.size()); // without length change
         UNIT_ASSERT(s2 == Data.Asdf1234qwer());
- 
+
         s2.resize(s2.size() + 4, *Data.W());
         UNIT_ASSERT(s2 == Data.Asdf1234qwerWWWW());
- 
+
         s2.resize(4);
         UNIT_ASSERT(s2 == Data.Asdf());
- 
+
         // assign family
         s2 = Data.asdf1234qwer();
         s2.assign(s, 1, 3);
         UNIT_ASSERT(s2 == Data._123());
- 
+
         s2.assign(Data._0123456(), 4);
         UNIT_ASSERT(s2 == Data._0123());
- 
+
         s2.assign('1');
         UNIT_ASSERT(s2 == Data._1());
 
         s2.assign(Data._0123456());
         UNIT_ASSERT(s2 == Data._0123456());
- 
+
         // hash()
         TStringType sS = s2; // type 'TStringType' is used as is
- 
+
         ComputeHash(sS); /*size_t hash_val = sS.hash();
 
         try {
@@ -902,17 +902,17 @@ public:
             Cerr << hash_val << Endl;
             throw;
         }*/
- 
+
         s2.assign(Data._0123456(), 2, 2);
         UNIT_ASSERT(s2 == Data._23());
- 
+
         //s2.reserve();
 
         TStringType s5(Data.abcde());
         s5.clear();
         UNIT_ASSERT(s5 == Data.Empty());
     }
- 
+
     void TestUtils() {
         TStringType s;
         s = Data._01230123();
@@ -922,7 +922,7 @@ public:
         SubstGlobal(s, from, to);
         UNIT_ASSERT(s == Data.z123z123());
     }
- 
+
     void TestEmpty() {
         TStringType s;
         s = Data._2();
@@ -944,7 +944,7 @@ public:
     void TestCopy() {
         TStringType s(Data.abcd());
         TStringType c = s.copy();
- 
+
         UNIT_ASSERT_EQUAL(s, c);
         UNIT_ASSERT(s.end() != c.end());
     }
@@ -955,7 +955,7 @@ public:
             char_type data[5];
 
             data[4] = 1;
- 
+
             s.strcpy(data, 4);
 
             UNIT_ASSERT_EQUAL(data[0], *Data.a());
diff --git a/util/generic/yexception.h b/util/generic/yexception.h
index cdd24438a4..b0c604e8c4 100644
--- a/util/generic/yexception.h
+++ b/util/generic/yexception.h
@@ -18,7 +18,7 @@
 #include <exception>
 
 #include <cstdio>
- 
+
 class TBackTrace;
 
 namespace NPrivateException {
diff --git a/util/network/poller.cpp b/util/network/poller.cpp
index 66f1abb50a..7954d0e8b5 100644
--- a/util/network/poller.cpp
+++ b/util/network/poller.cpp
@@ -33,7 +33,7 @@ public:
         }
     }
 };
- 
+
 TSocketPoller::TSocketPoller()
     : Impl_(new TImpl())
 {
diff --git a/util/system/atomic.h b/util/system/atomic.h
index 965b6e3fc5..80265babfd 100644
--- a/util/system/atomic.h
+++ b/util/system/atomic.h
@@ -9,7 +9,7 @@ using TAtomic = volatile TAtomicBase;
     #include "atomic_gcc.h"
 #elif defined(_MSC_VER)
     #include "atomic_win.h"
-#else 
+#else
     #error unsupported platform
 #endif
 
diff --git a/util/system/defaults.h b/util/system/defaults.h
index ce6e5706ee..dcd7abea38 100644
--- a/util/system/defaults.h
+++ b/util/system/defaults.h
@@ -77,7 +77,7 @@
 
 #ifdef _win_
     #include <malloc.h>
-#elif defined(_sun_) 
+#elif defined(_sun_)
     #include <alloca.h>
 #endif
 
diff --git a/util/system/err.cpp b/util/system/err.cpp
index a210406239..5573ea1ee9 100644
--- a/util/system/err.cpp
+++ b/util/system/err.cpp
@@ -2,7 +2,7 @@
 #include "progname.h"
 #include "compat.h"
 #include "error.h"
- 
+
 #include <util/generic/scope.h>
 
 #include <util/stream/printf.h>
diff --git a/util/system/mktemp.cpp b/util/system/mktemp.cpp
index 77654f1f2c..505b7b4a4b 100644
--- a/util/system/mktemp.cpp
+++ b/util/system/mktemp.cpp
@@ -36,7 +36,7 @@ TString MakeTempName(const char* wrkDir, const char* prefix, const char* extensi
     }
 
     filePath += "XXXXXX"; // mkstemps requirement
- 
+
     size_t extensionPartLength = 0;
     if (extension && *extension) {
         if (extension[0] != '.') {
@@ -49,7 +49,7 @@ TString MakeTempName(const char* wrkDir, const char* prefix, const char* extensi
 
     int fd = mkstemps(const_cast<char*>(filePath.data()), extensionPartLength);
     if (fd >= 0) {
-        close(fd); 
+        close(fd);
         return filePath;
     }
 #else
diff --git a/util/system/mktemp_system.cpp b/util/system/mktemp_system.cpp
index 31ed1d20bc..32bea2987c 100644
--- a/util/system/mktemp_system.cpp
+++ b/util/system/mktemp_system.cpp
@@ -161,15 +161,15 @@ GetTemp(char* path, int* doopen, int domkdir, int slen)
     }
     /*NOTREACHED*/
 }
- 
+
 extern "C" int mkstemps(char* path, int slen) {
     int fd;
- 
+
     return (GetTemp(path, &fd, 0, slen) ? fd : -1);
-} 
- 
+}
+
 #if defined(_win_)
 char* mkdtemp(char* path) {
     return (GetTemp(path, (int*)nullptr, 1, 0) ? path : (char*)nullptr);
-} 
+}
 #endif
diff --git a/util/system/sem.cpp b/util/system/sem.cpp
index 1adc5b87af..4a93b903b5 100644
--- a/util/system/sem.cpp
+++ b/util/system/sem.cpp
@@ -2,7 +2,7 @@
 
 #ifdef _win_
     #include <malloc.h>
-#elif defined(_sun) 
+#elif defined(_sun)
     #include <alloca.h>
 #endif
 
@@ -166,7 +166,7 @@ namespace {
 #endif
         }
     };
- 
+
 #if defined(_unix_)
     /*
     Disable errors/warnings about deprecated sem_* in Darwin
@@ -209,7 +209,7 @@ namespace {
     #ifdef _darwin_
     Y_PRAGMA_DIAGNOSTIC_POP
     #endif
-#endif 
+#endif
 }
 
 class TSemaphore::TImpl: public TSemaphoreImpl {
@@ -223,7 +223,7 @@ public:
 TSemaphore::TSemaphore(const char* name, ui32 maxFreeCount)
     : Impl_(new TImpl(name, maxFreeCount))
 {
-} 
+}
 
 TSemaphore::~TSemaphore() = default;
 
diff --git a/util/system/spinlock.h b/util/system/spinlock.h
index c88ddf35ce..af2630890a 100644
--- a/util/system/spinlock.h
+++ b/util/system/spinlock.h
@@ -44,7 +44,7 @@ static inline void AcquireSpinLock(TAtomic* l) {
         } while (!AtomicTryAndTryLock(l));
     }
 }
- 
+
 static inline void ReleaseSpinLock(TAtomic* l) {
     AtomicUnlock(l);
 }
diff --git a/util/system/sys_alloc.h b/util/system/sys_alloc.h
index be480742fa..4221a28f8c 100644
--- a/util/system/sys_alloc.h
+++ b/util/system/sys_alloc.h
@@ -13,12 +13,12 @@ inline void* y_allocate(size_t n) {
     }
 
     return r;
-} 
- 
+}
+
 inline void y_deallocate(void* p) {
     free(p);
-} 
- 
+}
+
 /**
  * Behavior of realloc from C++99 to C++11 changed (http://www.cplusplus.com/reference/cstdlib/realloc/).
  *
@@ -40,4 +40,4 @@ inline void* y_reallocate(void* p, size_t new_sz) {
     }
 
     return r;
-} 
+}
diff --git a/util/system/tls.cpp b/util/system/tls.cpp
index 25440a6a3e..c2f1a04a14 100644
--- a/util/system/tls.cpp
+++ b/util/system/tls.cpp
@@ -64,7 +64,7 @@ namespace {
                 void* Data_;
                 TDtor Dtor_;
             };
- 
+
             inline TStoredValue* Value(const TKey* key) {
                 TStoredValue*& ret = *ValuePtr((size_t)key->Key);
 
diff --git a/util/thread/pool.h b/util/thread/pool.h
index 79f7aebdff..d1ea3a67cb 100644
--- a/util/thread/pool.h
+++ b/util/thread/pool.h
@@ -379,8 +379,8 @@ private:
 
 inline void Delete(THolder<IThreadPool> q) {
     if (q.Get()) {
-        q->Stop(); 
-    } 
+        q->Stop();
+    }
 }
 
 /**