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

14 files changed, 505 insertions, 505 deletions

diff --git a/library/cpp/actors/core/events.h b/library/cpp/actors/core/events.h
index 702cf50fad..6aacb096ae 100644
--- a/library/cpp/actors/core/events.h
+++ b/library/cpp/actors/core/events.h
@@ -19,7 +19,7 @@ namespace NActors {
             ES_MON = 7,
             ES_INTERCONNECT_TCP = 8,
             ES_PROFILER = 9,
-            ES_YF = 10,
+            ES_YF = 10, 
             ES_HTTP = 11,
 
             ES_USERSPACE = 4096,
diff --git a/library/cpp/actors/core/log.cpp b/library/cpp/actors/core/log.cpp
index 5f63b5af58..d8a3993916 100644
--- a/library/cpp/actors/core/log.cpp
+++ b/library/cpp/actors/core/log.cpp
@@ -695,7 +695,7 @@ namespace NActors {
             } while (!isOk);
         }
 
-        void ReopenLog() override {
+        void ReopenLog() override { 
         }
 
     private:
diff --git a/library/cpp/actors/core/log.h b/library/cpp/actors/core/log.h
index c11a7cf3c1..a5219b5811 100644
--- a/library/cpp/actors/core/log.h
+++ b/library/cpp/actors/core/log.h
@@ -32,22 +32,22 @@
              0ull)                                                                               \
     )
 
-#define LOG_LOG_SAMPLED_BY(actorCtxOrSystem, priority, component, sampleBy, ...)                                               \
-    do {                                                                                                                       \
-        ::NActors::NLog::TSettings* mSettings = static_cast<::NActors::NLog::TSettings*>((actorCtxOrSystem).LoggerSettings()); \
-        ::NActors::NLog::EPriority mPriority = static_cast<::NActors::NLog::EPriority>(priority);                              \
-        ::NActors::NLog::EComponent mComponent = static_cast<::NActors::NLog::EComponent>(component);                          \
-        if (mSettings && mSettings->Satisfies(mPriority, mComponent, sampleBy)) {                                              \
-            ::NActors::MemLogAdapter(                                                                                          \
-                actorCtxOrSystem, priority, component, __VA_ARGS__);                                                           \
-        }                                                                                                                      \
+#define LOG_LOG_SAMPLED_BY(actorCtxOrSystem, priority, component, sampleBy, ...)                                               \ 
+    do {                                                                                                                       \ 
+        ::NActors::NLog::TSettings* mSettings = static_cast<::NActors::NLog::TSettings*>((actorCtxOrSystem).LoggerSettings()); \ 
+        ::NActors::NLog::EPriority mPriority = static_cast<::NActors::NLog::EPriority>(priority);                              \ 
+        ::NActors::NLog::EComponent mComponent = static_cast<::NActors::NLog::EComponent>(component);                          \ 
+        if (mSettings && mSettings->Satisfies(mPriority, mComponent, sampleBy)) {                                              \ 
+            ::NActors::MemLogAdapter(                                                                                          \ 
+                actorCtxOrSystem, priority, component, __VA_ARGS__);                                                           \ 
+        }                                                                                                                      \ 
     } while (0) /**/
 
 #define LOG_LOG_S_SAMPLED_BY(actorCtxOrSystem, priority, component, sampleBy, stream)  \
     LOG_LOG_SAMPLED_BY(actorCtxOrSystem, priority, component, sampleBy, "%s", [&]() { \
         TStringBuilder logStringBuilder;                                               \
         logStringBuilder << stream;                                                    \
-        return static_cast<TString>(logStringBuilder);                                 \
+        return static_cast<TString>(logStringBuilder);                                 \ 
     }().data())
 
 #define LOG_LOG(actorCtxOrSystem, priority, component, ...) LOG_LOG_SAMPLED_BY(actorCtxOrSystem, priority, component, 0ull, __VA_ARGS__)
diff --git a/library/cpp/actors/dnscachelib/dnscache.h b/library/cpp/actors/dnscachelib/dnscache.h
index 3313a251a1..f34b9003d9 100644
--- a/library/cpp/actors/dnscachelib/dnscache.h
+++ b/library/cpp/actors/dnscachelib/dnscache.h
@@ -55,7 +55,7 @@ private:
     struct THost {
         THost() noexcept {
         }
-
+ 
         TVector<TIpHost> AddrsV4;
         time_t ResolvedV4 = 0;
         time_t NotFoundV4 = 0;
diff --git a/library/cpp/actors/dnscachelib/ya.make b/library/cpp/actors/dnscachelib/ya.make
index e3a6ad6202..60a46cc208 100644
--- a/library/cpp/actors/dnscachelib/ya.make
+++ b/library/cpp/actors/dnscachelib/ya.make
@@ -1,5 +1,5 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     davenger
     fomichev
@@ -8,17 +8,17 @@ OWNER(
     single
 )
 
-SRCS(
-    dnscache.cpp
-    dnscache.h
+SRCS( 
+    dnscache.cpp 
+    dnscache.h 
     probes.cpp
     probes.h
-    timekeeper.h
-)
-
-PEERDIR(
-    contrib/libs/c-ares
+    timekeeper.h 
+) 
+ 
+PEERDIR( 
+    contrib/libs/c-ares 
     library/cpp/lwtrace
-)
-
-END()
+) 
+ 
+END() 
diff --git a/library/cpp/containers/comptrie/comptrie_builder.inl b/library/cpp/containers/comptrie/comptrie_builder.inl
index f273fa6571..ebb00a57af 100644
--- a/library/cpp/containers/comptrie/comptrie_builder.inl
+++ b/library/cpp/containers/comptrie/comptrie_builder.inl
@@ -142,7 +142,7 @@ public:
         const_iterator Find(char ch) const;
         void Add(const TBlob& s, TNode* node);
 
-        bool IsLast() const override {
+        bool IsLast() const override { 
             return this->Empty();
         }
 
@@ -151,7 +151,7 @@ public:
             return Find(key, value, result, packer);
         }
 
-        ui64 Measure(const TBuilderImpl* builder) const override {
+        ui64 Measure(const TBuilderImpl* builder) const override { 
             return MeasureRange(builder, 0, this->size());
         }
 
@@ -200,7 +200,7 @@ public:
             return written;
         }
 
-        void Destroy(TBuilderImpl* builder) override {
+        void Destroy(TBuilderImpl* builder) override { 
             // Delete all nodes down the stream.
             for (iterator it = this->begin(); it != this->end(); ++it) {
                 builder->DestroyNode(it->Node);
@@ -221,7 +221,7 @@ public:
             Y_ASSERT(reinterpret_cast<ISubtree*>(this) == static_cast<void*>(this)); // This assumption is used in TNode::Subtree()
         }
 
-        bool IsLast() const override {
+        bool IsLast() const override { 
             return Buffer.Empty();
         }
 
@@ -251,7 +251,7 @@ public:
             return nullptr;
         }
 
-        ui64 Measure(const TBuilderImpl*) const override {
+        ui64 Measure(const TBuilderImpl*) const override { 
             return Buffer.Size();
         }
 
@@ -287,7 +287,7 @@ public:
             Y_ASSERT(reinterpret_cast<ISubtree*>(this) == static_cast<void*>(this)); // This assumption is used in TNode::Subtree()
         }
 
-        bool IsLast() const override {
+        bool IsLast() const override { 
             return Data->Size == 0;
         }
 
@@ -316,7 +316,7 @@ public:
             return nullptr;
         }
 
-        ui64 Measure(const TBuilderImpl*) const override {
+        ui64 Measure(const TBuilderImpl*) const override { 
             return Data->Size;
         }
 
diff --git a/library/cpp/http/fetch/exthttpcodes.h b/library/cpp/http/fetch/exthttpcodes.h
index 6b525052cd..793d286c23 100644
--- a/library/cpp/http/fetch/exthttpcodes.h
+++ b/library/cpp/http/fetch/exthttpcodes.h
@@ -45,7 +45,7 @@ enum ExtHttpCodes {
     HTTP_PROXY_ERROR = 1036,
     HTTP_SSL_ERROR = 1037,
     HTTP_CACHED_COPY_NOT_FOUND = 1038,
-    HTTP_TIMEDOUT_WHILE_BYTES_RECEIVING = 1039,
+    HTTP_TIMEDOUT_WHILE_BYTES_RECEIVING = 1039, 
     HTTP_FETCHER_BAD_RESPONSE = 1040,
     HTTP_FETCHER_MB_ERROR = 1041,
     HTTP_SSL_CERT_ERROR = 1042,
diff --git a/library/cpp/http/fetch/httpfetcher.h b/library/cpp/http/fetch/httpfetcher.h
index 7fc251afd2..b6bd038a94 100644
--- a/library/cpp/http/fetch/httpfetcher.h
+++ b/library/cpp/http/fetch/httpfetcher.h
@@ -96,12 +96,12 @@ public:
             if ((got = TAgent::read(bufptr, buffree)) < 0) {
                 fetcherr = errno;
                 if (errno == EINTR)
-                    header->error = HTTP_INTERRUPTED;
+                    header->error = HTTP_INTERRUPTED; 
                 else if (errno == ETIMEDOUT)
-                    header->error = HTTP_TIMEDOUT_WHILE_BYTES_RECEIVING;
-                else
-                    header->error = HTTP_CONNECTION_LOST;
-
+                    header->error = HTTP_TIMEDOUT_WHILE_BYTES_RECEIVING; 
+                else 
+                    header->error = HTTP_CONNECTION_LOST; 
+ 
                 break;
             }
 
@@ -111,7 +111,7 @@ public:
             buffree -= got;
 
             THttpParser<TCheck>::Parse(parsebuf, got);
-
+ 
             if (header->error)
                 break; //if ANY error ocurred we will stop download that file or will have unprognosed stream position until MAX size reached
 
@@ -139,20 +139,20 @@ public:
             }
         } while (THttpParser<TCheck>::GetState() > THttpParser<TCheck>::hp_eof);
 
-        i64 Adjustment = 0;
-        if (!header->error) {
+        i64 Adjustment = 0; 
+        if (!header->error) { 
             if (header->transfer_chunked) {
-                Adjustment = header->header_size + header->entity_size - bufsize - 1;
+                Adjustment = header->header_size + header->entity_size - bufsize - 1; 
             } else if (header->content_length >= 0) {
-                Adjustment = header->header_size + header->content_length - bufsize;
-            }
+                Adjustment = header->header_size + header->content_length - bufsize; 
+            } 
             if (Adjustment > 0)
-                Adjustment = 0;
-        }
-
+                Adjustment = 0; 
+        } 
+ 
         if (buf) {
-            TAlloc::Shrink(buf, buflen - buffree + Adjustment);
-
+            TAlloc::Shrink(buf, buflen - buffree + Adjustment); 
+ 
             if (TWriter::Write(buf, buflen - buffree) < 0)
                 ret = EIO;
         }
diff --git a/library/cpp/http/fetch/httpparser.h b/library/cpp/http/fetch/httpparser.h
index 769828e4ae..cd7228055b 100644
--- a/library/cpp/http/fetch/httpparser.h
+++ b/library/cpp/http/fetch/httpparser.h
@@ -174,10 +174,10 @@ protected:
 
                 case hp_read_alive:
                     Header->entity_size += size;
-                    if (Header->entity_size >= Header->content_length) {
+                    if (Header->entity_size >= Header->content_length) { 
                         State = hp_eof;
                     }
-
+ 
                     TCheck::CheckDocPart(buf, size, Header);
                     if (isReader)
                         return size;
@@ -314,8 +314,8 @@ public:
             buf = Ptr;
             Ptr = (char*)Ptr + Chunk;
             Size -= Chunk;
-            if (State == hp_eof) {
-                Size = 0;
+            if (State == hp_eof) { 
+                Size = 0; 
                 Eoferr = 0;
             } else if (State == hp_error)
                 return Eoferr = -1;
diff --git a/library/cpp/int128/ut/int128_old_ut.cpp b/library/cpp/int128/ut/int128_old_ut.cpp
index 2c5b9e9610..20ff30943e 100644
--- a/library/cpp/int128/ut/int128_old_ut.cpp
+++ b/library/cpp/int128/ut/int128_old_ut.cpp
@@ -1,10 +1,10 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/int128/int128.h>
-
+ 
 #include "int128_ut_helpers.h"
 
-class TUInt128Test: public TTestBase {
-    UNIT_TEST_SUITE(TUInt128Test);
+class TUInt128Test: public TTestBase { 
+    UNIT_TEST_SUITE(TUInt128Test); 
     UNIT_TEST(Create);
     UNIT_TEST(Minus);
     UNIT_TEST(Plus);
@@ -16,100 +16,100 @@ class TUInt128Test: public TTestBase {
 #if defined(Y_HAVE_INT128)
     UNIT_TEST(FromSystemUint128);
 #endif
-    UNIT_TEST_SUITE_END();
-
-private:
-    void Create();
-    void Minus();
-    void Plus();
-    void Shift();
-    void Overflow();
-    void Underflow();
+    UNIT_TEST_SUITE_END(); 
+
+private: 
+    void Create(); 
+    void Minus(); 
+    void Plus(); 
+    void Shift(); 
+    void Overflow(); 
+    void Underflow(); 
     void ToStringTest();
     void FromStringTest();
 #if defined(Y_HAVE_INT128)
     void FromSystemUint128();
 #endif
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TUInt128Test);
-
-void TUInt128Test::Create() {
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TUInt128Test); 
+ 
+void TUInt128Test::Create() { 
     const ui128 n1 = 10;
-    UNIT_ASSERT_EQUAL(n1, 10);
-
+    UNIT_ASSERT_EQUAL(n1, 10); 
+ 
     const ui128 n2 = n1;
-    UNIT_ASSERT_EQUAL(n2, 10);
-
+    UNIT_ASSERT_EQUAL(n2, 10); 
+ 
     const ui128 n3(10);
-    UNIT_ASSERT_EQUAL(n3, 10);
-}
-void TUInt128Test::Minus() {
+    UNIT_ASSERT_EQUAL(n3, 10); 
+} 
+void TUInt128Test::Minus() { 
     const ui128 n2 = 20;
     const ui128 n3 = 30;
-
+ 
     ui128 n4 = n3 - n2;
-    UNIT_ASSERT_EQUAL(n4, 10);
-
-    n4 = n4 - 2;
-    UNIT_ASSERT_EQUAL(n4, 8);
-
-    n4 -= 2;
-    UNIT_ASSERT_EQUAL(n4, 6);
-
-    n4 = 10 - n4;
-    UNIT_ASSERT_EQUAL(n4, 4);
-}
-void TUInt128Test::Plus() {
+    UNIT_ASSERT_EQUAL(n4, 10); 
+ 
+    n4 = n4 - 2; 
+    UNIT_ASSERT_EQUAL(n4, 8); 
+ 
+    n4 -= 2; 
+    UNIT_ASSERT_EQUAL(n4, 6); 
+ 
+    n4 = 10 - n4; 
+    UNIT_ASSERT_EQUAL(n4, 4); 
+} 
+void TUInt128Test::Plus() { 
     const ui128 n2 = 20;
     const ui128 n3 = 30;
-
+ 
     ui128 n4 = n3 + n2;
-    UNIT_ASSERT_EQUAL(n4, 50);
-
-    n4 = n4 + 2;
-    UNIT_ASSERT_EQUAL(n4, 52);
-
-    n4 += 2;
-    UNIT_ASSERT_EQUAL(n4, 54);
-
-    n4 = 10 + n4;
-    UNIT_ASSERT_EQUAL(n4, 64);
-}
-void TUInt128Test::Shift() {
+    UNIT_ASSERT_EQUAL(n4, 50); 
+ 
+    n4 = n4 + 2; 
+    UNIT_ASSERT_EQUAL(n4, 52); 
+ 
+    n4 += 2; 
+    UNIT_ASSERT_EQUAL(n4, 54); 
+ 
+    n4 = 10 + n4; 
+    UNIT_ASSERT_EQUAL(n4, 64); 
+} 
+void TUInt128Test::Shift() { 
     ui128 n = 1;
-
+ 
     const ui128 n4 = n << 4;
     UNIT_ASSERT_EQUAL(n4, ui128(0x0, 0x0000000000000010));
-    UNIT_ASSERT_EQUAL(n4 >> 4, 1);
-
+    UNIT_ASSERT_EQUAL(n4 >> 4, 1); 
+ 
     const ui128 n8 = n << 8;
     UNIT_ASSERT_EQUAL(n8, ui128(0x0, 0x0000000000000100));
-    UNIT_ASSERT_EQUAL(n8 >> 8, 1);
-
+    UNIT_ASSERT_EQUAL(n8 >> 8, 1); 
+ 
     const ui128 n60 = n << 60;
     UNIT_ASSERT_EQUAL(n60, ui128(0x0, 0x1000000000000000));
-    UNIT_ASSERT_EQUAL(n60 >> 60, 1);
-
+    UNIT_ASSERT_EQUAL(n60 >> 60, 1); 
+ 
     const ui128 n64 = n << 64;
     UNIT_ASSERT_EQUAL(n64, ui128(0x1, 0x0000000000000000));
-    UNIT_ASSERT_EQUAL(n64 >> 64, 1);
-
+    UNIT_ASSERT_EQUAL(n64 >> 64, 1); 
+ 
     const ui128 n124 = n << 124;
     UNIT_ASSERT_EQUAL(n124, ui128(0x1000000000000000, 0x0000000000000000));
-    UNIT_ASSERT_EQUAL(n124 >> 124, 1);
-}
-
-void TUInt128Test::Overflow() {
+    UNIT_ASSERT_EQUAL(n124 >> 124, 1); 
+} 
+ 
+void TUInt128Test::Overflow() { 
     ui128 n = ui128(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
     const ui128 n2 = n + 2;
-    UNIT_ASSERT_EQUAL(n2, 1);
-}
-void TUInt128Test::Underflow() {
+    UNIT_ASSERT_EQUAL(n2, 1); 
+} 
+void TUInt128Test::Underflow() { 
     ui128 n = 1;
     const ui128 n128 = n - 2;
     UNIT_ASSERT_EQUAL(n128, ui128(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF));
-}
+} 
 
 void TUInt128Test::ToStringTest() {
     ui128 n(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
diff --git a/library/cpp/ipv6_address/ipv6_address.cpp b/library/cpp/ipv6_address/ipv6_address.cpp
index be8fcbae13..adb24cfb36 100644
--- a/library/cpp/ipv6_address/ipv6_address.cpp
+++ b/library/cpp/ipv6_address/ipv6_address.cpp
@@ -1,17 +1,17 @@
-#include "ipv6_address.h"
-#include "ipv6_address_p.h"
-
+#include "ipv6_address.h" 
+#include "ipv6_address_p.h" 
+ 
 #ifdef _unix_
-#include <netinet/in.h>
+#include <netinet/in.h> 
 #endif
-
-#include <util/network/address.h>
-#include <util/network/init.h>
-#include <util/string/cast.h>
-#include <util/string/split.h>
+ 
+#include <util/network/address.h> 
+#include <util/network/init.h> 
+#include <util/string/cast.h> 
+#include <util/string/split.h> 
 #include <util/system/byteorder.h>
-#include <util/ysaveload.h>
-
+#include <util/ysaveload.h> 
+ 
 #include <array>
 
 namespace {
@@ -40,79 +40,79 @@ void TIpv6Address::InitFrom(const in6_addr& addr) {
     const ui64 raw[2] = {SwapBytes(*ui64Ptr), SwapBytes(*(ui64Ptr + 1))};
     Ip = FromMemMSF(reinterpret_cast<const char*>(raw));
     Type_ = Ipv6;
-}
+} 
 void TIpv6Address::InitFrom(const in_addr& addr) {
     unsigned long swapped = SwapBytes(addr.s_addr);
     Ip = ui128{0, swapped};
-    Type_ = Ipv4;
-}
-
+    Type_ = Ipv4; 
+} 
+ 
 void TIpv6Address::InitFrom(const sockaddr_in6& Addr) {
-    InitFrom(Addr.sin6_addr);
-    ScopeId_ = Addr.sin6_scope_id;
-}
+    InitFrom(Addr.sin6_addr); 
+    ScopeId_ = Addr.sin6_scope_id; 
+} 
 void TIpv6Address::InitFrom(const sockaddr_in& Addr) {
-    InitFrom(Addr.sin_addr);
-}
-
+    InitFrom(Addr.sin_addr); 
+} 
+ 
 TIpv6Address::TIpv6Address(const NAddr::IRemoteAddr& addr) {
     if (addr.Addr()->sa_family == AF_INET) { // IPv4
         const sockaddr_in* Tmp = reinterpret_cast<const sockaddr_in*>(addr.Addr());
-        InitFrom(*Tmp);
-    } else { // IPv6
+        InitFrom(*Tmp); 
+    } else { // IPv6 
         const sockaddr_in6* Tmp = reinterpret_cast<const sockaddr_in6*>(addr.Addr());
-        InitFrom(*Tmp);
-    }
-}
+        InitFrom(*Tmp); 
+    } 
+} 
 TIpv6Address::TIpv6Address(const sockaddr_in6& Addr) {
-    InitFrom(Addr);
-}
+    InitFrom(Addr); 
+} 
 TIpv6Address::TIpv6Address(const sockaddr_in& Addr) {
-    InitFrom(Addr);
-}
+    InitFrom(Addr); 
+} 
 TIpv6Address::TIpv6Address(const in6_addr& addr, ui32 Scope) {
-    InitFrom(addr);
-    ScopeId_ = Scope;
-}
+    InitFrom(addr); 
+    ScopeId_ = Scope; 
+} 
 TIpv6Address::TIpv6Address(const in_addr& addr) {
-    InitFrom(addr);
-}
-
+    InitFrom(addr); 
+} 
+ 
 TIpv6Address TIpv6Address::FromString(TStringBuf str, bool& ok) noexcept {
     const TIpType ipType = FigureOutType(str);
-
+ 
     if (ipType == Ipv6) {
         ui32 scopeId = 0;
         if (size_t pos = str.find('%'); pos != TStringBuf::npos) {
             ::TryFromString(str.substr(pos + 1), scopeId);
             str.Trunc(pos);
-        }
-
+        } 
+ 
         const auto buf = AddrBuf<INET6_ADDRSTRLEN>(str);
-        in6_addr addr;
+        in6_addr addr; 
         if (inet_pton(AF_INET6, buf.data(), &addr) != 1) {
-            ok = false;
-            return TIpv6Address();
-        }
+            ok = false; 
+            return TIpv6Address(); 
+        } 
 
-        ok = true;
+        ok = true; 
         return TIpv6Address(addr, scopeId);
-    } else { // if (ipType == Ipv4) {
+    } else { // if (ipType == Ipv4) { 
         const auto buf = AddrBuf<INET_ADDRSTRLEN>(str);
-        in_addr addr;
+        in_addr addr; 
         if (inet_pton(AF_INET, buf.data(), &addr) != 1) {
-            ok = false;
-            return TIpv6Address();
-        }
+            ok = false; 
+            return TIpv6Address(); 
+        } 
 
-        ok = true;
+        ok = true; 
         return TIpv6Address(addr);
-    }
-}
-
+    } 
+} 
+ 
 TString TIpv6Address::ToString(bool* ok) const noexcept {
-    return ToString(true, ok);
-}
+    return ToString(true, ok); 
+} 
 TString TIpv6Address::ToString(bool PrintScopeId, bool* ok) const noexcept {
     TString result;
     bool isOk = true;
@@ -120,17 +120,17 @@ TString TIpv6Address::ToString(bool PrintScopeId, bool* ok) const noexcept {
     if (Type_ == TIpv6Address::Ipv4) {
         result.resize(INET_ADDRSTRLEN + 2);
         in_addr addr;
-        ToInAddr(addr);
+        ToInAddr(addr); 
         isOk = inet_ntop(AF_INET, &addr, result.begin(), INET_ADDRSTRLEN);
         result.resize(result.find('\0'));
     } else if (Type_ == TIpv6Address::Ipv6) {
         result.resize(INET6_ADDRSTRLEN + 2);
         in6_addr addr;
-        ToIn6Addr(addr);
+        ToIn6Addr(addr); 
         isOk = inet_ntop(AF_INET6, &addr, result.begin(), INET6_ADDRSTRLEN);
         result.resize(result.find('\0'));
         if (PrintScopeId)
-            result += "%" + ::ToString(ScopeId_);
+            result += "%" + ::ToString(ScopeId_); 
     } else {
         result = "null";
         isOk = true;
@@ -141,106 +141,106 @@ TString TIpv6Address::ToString(bool PrintScopeId, bool* ok) const noexcept {
     }
 
     return result;
-}
-
+} 
+ 
 void TIpv6Address::ToSockaddrAndSocklen(sockaddr_in& sockAddrIPv4,
                                         sockaddr_in6& sockAddrIPv6, // in
                                         const sockaddr*& sockAddrPtr,
                                         socklen_t& sockAddrSize,
                                         ui16 Port) const { // out
-
+ 
     if (Type_ == Ipv4) {
-        memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));
-        sockAddrIPv4.sin_family = AF_INET;
+        memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4)); 
+        sockAddrIPv4.sin_family = AF_INET; 
         sockAddrIPv4.sin_port = htons(Port);
-        ToInAddr(sockAddrIPv4.sin_addr);
-
-        sockAddrSize = sizeof(sockAddrIPv4);
+        ToInAddr(sockAddrIPv4.sin_addr); 
+ 
+        sockAddrSize = sizeof(sockAddrIPv4); 
         sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv4);
-
+ 
     } else if (Type_ == Ipv6) {
-        memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));
-        sockAddrIPv6.sin6_family = AF_INET6;
+        memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6)); 
+        sockAddrIPv6.sin6_family = AF_INET6; 
         sockAddrIPv6.sin6_port = htons(Port);
-        ToIn6Addr(sockAddrIPv6.sin6_addr);
-        sockAddrIPv6.sin6_scope_id = ScopeId_;
-        sockAddrIPv6.sin6_flowinfo = 0;
-
-        sockAddrSize = sizeof(sockAddrIPv6);
+        ToIn6Addr(sockAddrIPv6.sin6_addr); 
+        sockAddrIPv6.sin6_scope_id = ScopeId_; 
+        sockAddrIPv6.sin6_flowinfo = 0; 
+ 
+        sockAddrSize = sizeof(sockAddrIPv6); 
         sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv6);
-    } else
+    } else 
         Y_VERIFY(false);
-}
-
+} 
+ 
 void TIpv6Address::ToInAddr(in_addr& Addr4) const {
     Y_VERIFY(Type_ == TIpv6Address::Ipv4);
-
-    Zero(Addr4);
+ 
+    Zero(Addr4); 
     ui32 Value = GetLow(Ip);
     Y_VERIFY(Value == GetLow(Ip), " ");
     Y_VERIFY(GetHigh(Ip) == 0, " ");
-    Addr4.s_addr = SwapBytes(Value);
-}
+    Addr4.s_addr = SwapBytes(Value); 
+} 
 void TIpv6Address::ToIn6Addr(in6_addr& Addr6) const {
     Y_VERIFY(Type_ == TIpv6Address::Ipv6);
-
-    Zero(Addr6);
+ 
+    Zero(Addr6); 
     ui64 Raw[2] = {GetHigh(Ip), GetLow(Ip)};
     *Raw = SwapBytes(*Raw);
     Raw[1] = SwapBytes(1 [Raw]);
-    memcpy(&Addr6, Raw, sizeof(Raw));
-}
-
+    memcpy(&Addr6, Raw, sizeof(Raw)); 
+} 
+ 
 void TIpv6Address::Save(IOutputStream* out) const {
     ::Save(out, Ip);
-    ::Save(out, static_cast<ui8>(Type_));
-    ::Save(out, ScopeId_);
-}
+    ::Save(out, static_cast<ui8>(Type_)); 
+    ::Save(out, ScopeId_); 
+} 
 void TIpv6Address::Load(IInputStream* in) {
     ::Load(in, Ip);
-    ui8 num;
-    ::Load(in, num);
-    Type_ = static_cast<TIpType>(num);
-    ::Load(in, ScopeId_);
-}
-
-bool TIpv6Address::Isv4MappedTov6() const noexcept {
-    /// http://en.wikipedia.org/wiki/IPv6
-    /// Hybrid dual-stack IPv6/IPv4 implementations recognize a special class of addresses,
-    /// the IPv4-mapped IPv6 addresses.  In these addresses, the first 80 bits are zero, the next 16 bits are one,
-    /// and the remaining 32 bits are the IPv4 address.
-
+    ui8 num; 
+    ::Load(in, num); 
+    Type_ = static_cast<TIpType>(num); 
+    ::Load(in, ScopeId_); 
+} 
+ 
+bool TIpv6Address::Isv4MappedTov6() const noexcept { 
+    /// http://en.wikipedia.org/wiki/IPv6 
+    /// Hybrid dual-stack IPv6/IPv4 implementations recognize a special class of addresses, 
+    /// the IPv4-mapped IPv6 addresses.  In these addresses, the first 80 bits are zero, the next 16 bits are one, 
+    /// and the remaining 32 bits are the IPv4 address. 
+ 
     if (Type_ != Ipv6)
-        return false;
-
+        return false; 
+ 
     if (GetHigh(Ip) != 0)
-        return false; // First 64 bit are not zero -> it is not ipv4-mapped-ipv6 address
-
+        return false; // First 64 bit are not zero -> it is not ipv4-mapped-ipv6 address 
+ 
     const ui64 Low = GetLow(Ip) >> 32;
     if (Low != 0x0000ffff)
-        return false;
-
-    return true;
-}
-
-TIpv6Address TIpv6Address::TryToExtractIpv4From6() const noexcept {
+        return false; 
+ 
+    return true; 
+} 
+ 
+TIpv6Address TIpv6Address::TryToExtractIpv4From6() const noexcept { 
     if (Isv4MappedTov6() == false)
-        return TIpv6Address();
-
+        return TIpv6Address(); 
+ 
     const ui64 NewLow = GetLow(Ip) & 0x00000000ffffffff;
     TIpv6Address Result(ui128(0, NewLow), Ipv4);
-    return Result;
-}
-
-TIpv6Address TIpv6Address::Normalized() const noexcept {
+    return Result; 
+} 
+ 
+TIpv6Address TIpv6Address::Normalized() const noexcept { 
     if (Isv4MappedTov6() == false)
-        return *this;
-
-    TIpv6Address Result = TryToExtractIpv4From6();
+        return *this; 
+ 
+    TIpv6Address Result = TryToExtractIpv4From6(); 
     Y_VERIFY(Result.IsNull() == false);
-    return Result;
-}
-
+    return Result; 
+} 
+ 
 IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type) noexcept {
     switch (Type) {
     case TIpv6Address::Ipv4:
@@ -250,188 +250,188 @@ IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type)
         Out << "Ipv6";
         return Out;
     default:
-        Out << "UnknownType";
-        return Out;
-    }
-}
-
+        Out << "UnknownType"; 
+        return Out; 
+    } 
+} 
+ 
 IOutputStream& operator<<(IOutputStream& out, const TIpv6Address& ipv6Address) noexcept {
     bool ok;
     const TString& strIp = ipv6Address.ToString(&ok);
     if (!ok) {
         return out << "Can not convert ip to string";
-    } else {
+    } else { 
         return out << strIp;
-    }
-}
-
-TString THostAddressAndPort::ToString() const noexcept {
-    TStringStream Str;
-    Str << *this;
-    return Str.Str();
-}
-
+    } 
+} 
+ 
+TString THostAddressAndPort::ToString() const noexcept { 
+    TStringStream Str; 
+    Str << *this; 
+    return Str.Str(); 
+} 
+ 
 IOutputStream& operator<<(IOutputStream& Out, const THostAddressAndPort& HostAddressAndPort) noexcept {
-    Out << HostAddressAndPort.Ip << ":" << HostAddressAndPort.Port;
-    return Out;
-}
-
-namespace {
+    Out << HostAddressAndPort.Ip << ":" << HostAddressAndPort.Port; 
+    return Out; 
+} 
+ 
+namespace { 
     class TRemoteAddr: public NAddr::IRemoteAddr {
-    public:
+    public: 
         TRemoteAddr(const TIpv6Address& Address, TIpPort Port);
         const sockaddr* Addr() const override;
         socklen_t Len() const override;
-
-    private:
+ 
+    private: 
         sockaddr_in SockAddrIPv4;
         sockaddr_in6 SockAddrIPv6;
         const sockaddr* SockAddrPtr = nullptr;
         socklen_t SockAddrSize = 0;
-    };
-
+    }; 
+ 
     TRemoteAddr::TRemoteAddr(const TIpv6Address& Address, TIpPort Port) {
-        Address.ToSockaddrAndSocklen(SockAddrIPv4, SockAddrIPv6, SockAddrPtr, SockAddrSize, Port);
-    }
+        Address.ToSockaddrAndSocklen(SockAddrIPv4, SockAddrIPv6, SockAddrPtr, SockAddrSize, Port); 
+    } 
     const sockaddr* TRemoteAddr::Addr() const {
-        return SockAddrPtr;
-    }
-    socklen_t TRemoteAddr::Len() const {
-        return SockAddrSize;
-    }
-}
-
+        return SockAddrPtr; 
+    } 
+    socklen_t TRemoteAddr::Len() const { 
+        return SockAddrSize; 
+    } 
+} 
+ 
 NAddr::IRemoteAddr* ToIRemoteAddr(const TIpv6Address& Address, TIpPort Port) {
-    return new TRemoteAddr(Address, Port);
-}
-
+    return new TRemoteAddr(Address, Port); 
+} 
+ 
 std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromString(const TString& RawStr,
                                                                                   TIpPort DefaultPort,
                                                                                   bool& Ok) noexcept {
-    // Cout << "ParseHostAndMayBePortFromString: " << RawStr << ", Port: " << DefaultPort << Endl;
-
+    // Cout << "ParseHostAndMayBePortFromString: " << RawStr << ", Port: " << DefaultPort << Endl; 
+ 
     using TRes = std::tuple<THostAddressAndPort, TString, TIpPort>;
-
-    // ---------------------------------------------------------------------
-
-    const size_t BracketColPos = RawStr.find("]:");
+ 
+    // --------------------------------------------------------------------- 
+ 
+    const size_t BracketColPos = RawStr.find("]:"); 
     if (BracketColPos != TString::npos) {
-        // [ipv6]:port
+        // [ipv6]:port 
         if (!RawStr.StartsWith('[')) {
-            Ok = false;
-            return {};
-        }
+            Ok = false; 
+            return {}; 
+        } 
         const TStringBuf StrIpv6(RawStr.begin() + 1, RawStr.begin() + BracketColPos);
         const TStringBuf StrPort(RawStr.begin() + BracketColPos + 2, RawStr.end());
-
+ 
         bool IpConverted;
-        const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted);
+        const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted); 
         if (!IpConverted) {
-            Ok = false;
-            return {};
-        }
+            Ok = false; 
+            return {}; 
+        } 
         if (Ip.Type() != TIpv6Address::Ipv6) {
-            Ok = false;
-            return {};
-        }
+            Ok = false; 
+            return {}; 
+        } 
         TIpPort Port {};
         if (!::TryFromString(StrPort, Port)) {
-            Ok = false;
-            return {};
-        }
-
-        Ok = true;
-        TRes Res{{Ip, Port}, {}, {}};
-        return Res;
-    }
-
-    // ---------------------------------------------------------------------
-
+            Ok = false; 
+            return {}; 
+        } 
+ 
+        Ok = true; 
+        TRes Res{{Ip, Port}, {}, {}}; 
+        return Res; 
+    } 
+ 
+    // --------------------------------------------------------------------- 
+ 
     if (RawStr.StartsWith('[')) {
-        // [ipv6]
+        // [ipv6] 
         if (!RawStr.EndsWith(']')) {
-            Ok = false;
-            return {};
-        }
+            Ok = false; 
+            return {}; 
+        } 
         const TStringBuf StrIpv6(RawStr.begin() + 1, RawStr.end() - 1);
-
+ 
         bool IpConverted;
-        const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted);
+        const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted); 
         if (!IpConverted || Ip.Type() != TIpv6Address::Ipv6) {
-            Ok = false;
-            return {};
-        }
-
-        Ok = true;
-        TRes Res{{Ip, DefaultPort}, {}, {}};
-        return Res;
-    }
-
-    // ---------------------------------------------------------------------
-
+            Ok = false; 
+            return {}; 
+        } 
+ 
+        Ok = true; 
+        TRes Res{{Ip, DefaultPort}, {}, {}}; 
+        return Res; 
+    } 
+ 
+    // --------------------------------------------------------------------- 
+ 
     const size_t ColPos = RawStr.find(':');
     if (ColPos != TString::npos) {
-        // host:port
-        // ipv4:port
-        // ipv6
-
-        {
+        // host:port 
+        // ipv4:port 
+        // ipv6 
+ 
+        { 
             bool IpConverted;
-            const TIpv6Address Ipv6 = TIpv6Address::FromString(RawStr, IpConverted);
+            const TIpv6Address Ipv6 = TIpv6Address::FromString(RawStr, IpConverted); 
             if (IpConverted && Ipv6.Type() == TIpv6Address::Ipv6) {
-                // ipv6
-                Ok = true;
-                TRes Res{{Ipv6, DefaultPort}, {}, {}};
-                return Res;
-            }
-        }
-
+                // ipv6 
+                Ok = true; 
+                TRes Res{{Ipv6, DefaultPort}, {}, {}}; 
+                return Res; 
+            } 
+        } 
+ 
         const TStringBuf StrPort(RawStr.begin() + ColPos + 1, RawStr.end());
         TIpPort Port {};
         if (!::TryFromString(StrPort, Port)) {
-            Ok = false;
-            return {};
-        }
-
+            Ok = false; 
+            return {}; 
+        } 
+ 
         const TStringBuf StrIpv4OrHost(RawStr.begin(), RawStr.begin() + ColPos);
-        {
+        { 
             bool IpConverted;
-            const TIpv6Address Ipv4 = TIpv6Address::FromString(StrIpv4OrHost, IpConverted);
+            const TIpv6Address Ipv4 = TIpv6Address::FromString(StrIpv4OrHost, IpConverted); 
             if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) {
-                // ipv4:port
-                Ok = true;
-                TRes Res{{Ipv4, Port}, {}, {}};
-                return Res;
-            }
-        }
-
-        {
-            // host:port
-            Ok = true;
+                // ipv4:port 
+                Ok = true; 
+                TRes Res{{Ipv4, Port}, {}, {}}; 
+                return Res; 
+            } 
+        } 
+ 
+        { 
+            // host:port 
+            Ok = true; 
             TRes Res{THostAddressAndPort{}, TString(StrIpv4OrHost), Port};
-            return Res;
-        }
-    }
-
-    // ---------------------------------------------------------------------
-
-    {
-        // ipv4
+            return Res; 
+        } 
+    } 
+ 
+    // --------------------------------------------------------------------- 
+ 
+    { 
+        // ipv4 
         bool IpConverted;
-        const TIpv6Address Ipv4 = TIpv6Address::FromString(RawStr, IpConverted);
+        const TIpv6Address Ipv4 = TIpv6Address::FromString(RawStr, IpConverted); 
         if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) {
-            Ok = true;
-            TRes Res{{Ipv4, DefaultPort}, {}, {}};
-            return Res;
-        }
-    }
-
-    // ---------------------------------------------------------------------
-
-    {
-        // host
-        Ok = true;
+            Ok = true; 
+            TRes Res{{Ipv4, DefaultPort}, {}, {}}; 
+            return Res; 
+        } 
+    } 
+ 
+    // --------------------------------------------------------------------- 
+ 
+    { 
+        // host 
+        Ok = true; 
         TRes Res{THostAddressAndPort{}, TString(RawStr), DefaultPort};
-        return Res;
-    }
-}
+        return Res; 
+    } 
+} 
diff --git a/library/cpp/ipv6_address/ipv6_address.h b/library/cpp/ipv6_address/ipv6_address.h
index 1d7eb0b65f..3852768354 100644
--- a/library/cpp/ipv6_address/ipv6_address.h
+++ b/library/cpp/ipv6_address/ipv6_address.h
@@ -1,37 +1,37 @@
-#pragma once
-
+#pragma once 
+ 
 #include <util/generic/hash_set.h>
-#include <util/network/ip.h>
-#include <util/stream/input.h>
-
+#include <util/network/ip.h> 
+#include <util/stream/input.h> 
+ 
 #include <library/cpp/int128/int128.h>
-
+ 
 #if defined(_freebsd_)
-// #include required to avoid problem with undefined 'socklen_t' on FreeBSD
-#include <sys/socket.h>
+// #include required to avoid problem with undefined 'socklen_t' on FreeBSD 
+#include <sys/socket.h> 
 #endif
 
 #if defined(_win_)
-// #include required to avoid problem with undefined 'socklen_t' on Windows
-#include <util/network/socket.h>
+// #include required to avoid problem with undefined 'socklen_t' on Windows 
+#include <util/network/socket.h> 
 #endif
 
-namespace NAddr {
-    class IRemoteAddr;
-}
+namespace NAddr { 
+    class IRemoteAddr; 
+} 
 struct in6_addr;
 struct in_addr;
-struct sockaddr;
-struct sockaddr_in;
-struct sockaddr_in6;
-
-// TODO (dimanne): rename to something like TIntInetAddress or THostAddress
-class TIpv6Address {
-public:
+struct sockaddr; 
+struct sockaddr_in; 
+struct sockaddr_in6; 
+ 
+// TODO (dimanne): rename to something like TIntInetAddress or THostAddress 
+class TIpv6Address { 
+public: 
     enum TIpType { Ipv6,
                    Ipv4,
                    LAST };
-
+ 
     constexpr TIpv6Address() noexcept = default;
     constexpr TIpv6Address(const TIpv6Address&) noexcept = default;
     constexpr TIpv6Address& operator=(const TIpv6Address&) noexcept = default;
@@ -52,68 +52,68 @@ public:
         auto hi = (ui64(a) << 48) | (ui64(b) << 32) | (ui64(c) << 16) | ui64(d);
         auto lo = (ui64(e) << 48) | (ui64(f) << 32) | (ui64(g) << 16) | ui64(h);
         Ip = {hi, lo};
-    }
-
+    } 
+ 
     explicit TIpv6Address(const NAddr::IRemoteAddr& addr);
     explicit TIpv6Address(const sockaddr_in6& Addr);
     explicit TIpv6Address(const sockaddr_in& Addr);
     explicit TIpv6Address(const in6_addr& addr, ui32 Scope);
     explicit TIpv6Address(const in_addr& addr);
-
+ 
     static TIpv6Address FromString(TStringBuf srcStr, bool& ok) noexcept;
 
     constexpr bool IsNull() const noexcept {
-        return Ip == 0;
-    }
-
+        return Ip == 0; 
+    } 
+ 
     constexpr bool IsValid() const noexcept {
         return Ip != 0 && (Type_ == Ipv6 || Type_ == Ipv4);
     }
-
+ 
     explicit constexpr operator bool() const noexcept {
         return IsValid();
-    }
-
+    } 
+ 
     constexpr bool operator ! () const noexcept {
         return !IsValid();
     }
 
     bool Isv4MappedTov6() const noexcept;
-    TIpv6Address TryToExtractIpv4From6() const noexcept;
-    TIpv6Address Normalized() const noexcept;
-
+    TIpv6Address TryToExtractIpv4From6() const noexcept; 
+    TIpv6Address Normalized() const noexcept; 
+ 
     TString ToString(bool* ok = nullptr) const noexcept;
     TString ToString(bool PrintScopeId, bool* ok = nullptr) const noexcept;
-
+ 
     void ToSockaddrAndSocklen(sockaddr_in& sockAddrIPv4,
                               sockaddr_in6& sockAddrIPv6, // in
                               const sockaddr*& sockAddrPtr,
                               socklen_t& sockAddrSize,
                               ui16 Port) const; // out
-
+ 
     void ToInAddr(in_addr& Addr4) const;
     void ToIn6Addr(in6_addr& Addr6) const;
-    // int SocketFamily() const;
-
+    // int SocketFamily() const; 
+ 
     constexpr bool operator<(const TIpv6Address& other) const noexcept {
         if (Type_ != other.Type_)
             return Type_ > other.Type_;
         else
             return Ip < other.Ip;
-    }
+    } 
     constexpr bool operator>(const TIpv6Address& other) const noexcept {
         if (Type_ != other.Type_)
             return Type_ < other.Type_;
         else
             return Ip > other.Ip;
-    }
+    } 
     constexpr bool operator==(const TIpv6Address& other) const noexcept {
         return Type_ == other.Type_ && Ip == other.Ip;
-    }
+    } 
     constexpr bool operator!=(const TIpv6Address& other) const noexcept {
         return Type_ != other.Type_ || Ip != other.Ip;
-    }
-
+    } 
+ 
     constexpr bool operator<=(const TIpv6Address& other) const noexcept {
         return !(*this > other);
     }
@@ -123,116 +123,116 @@ public:
     }
 
     constexpr operator ui128() const noexcept {
-        return Ip;
-    }
-
+        return Ip; 
+    } 
+ 
     constexpr TIpType Type() const noexcept {
-        return Type_;
-    }
-
+        return Type_; 
+    } 
+ 
     void SetScopeId(ui32 New) noexcept {
-        ScopeId_ = New;
-    }
+        ScopeId_ = New; 
+    } 
     constexpr ui32 ScopeId() const noexcept {
-        return ScopeId_;
-    }
-
+        return ScopeId_; 
+    } 
+ 
     void Save(IOutputStream* out) const;
     void Load(IInputStream* in);
-
-private:
+ 
+private: 
     void InitFrom(const in6_addr& addr);
     void InitFrom(const in_addr& addr);
-
+ 
     void InitFrom(const sockaddr_in6& Addr);
     void InitFrom(const sockaddr_in& Addr);
-
+ 
     ui128 Ip{};
     TIpType Type_ = LAST;
     ui32 ScopeId_ = 0;
-};
+}; 
 IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type) noexcept;
 IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address& ipv6Address) noexcept;
-
+ 
 constexpr TIpv6Address Get127001() noexcept {
     return {127, 0, 0, 1};
-}
+} 
 
 constexpr TIpv6Address Get1() noexcept {
     return {1, TIpv6Address::Ipv6};
-}
-
-struct THostAddressAndPort {
+} 
+ 
+struct THostAddressAndPort { 
     constexpr THostAddressAndPort() noexcept = default;
     constexpr THostAddressAndPort(const TIpv6Address& i, TIpPort p) noexcept {
-        Ip = i;
-        Port = p;
-    }
-
+        Ip = i; 
+        Port = p; 
+    } 
+ 
     constexpr bool operator==(const THostAddressAndPort& Other) const noexcept {
-        return Ip == Other.Ip && Port == Other.Port;
-    }
+        return Ip == Other.Ip && Port == Other.Port; 
+    } 
     constexpr bool operator!=(const THostAddressAndPort& Other) const noexcept {
-        return !(*this == Other);
-    }
+        return !(*this == Other); 
+    } 
     constexpr bool IsValid() const noexcept {
-        return Ip.IsValid() && Port != 0;
-    }
-
-    TString ToString() const noexcept;
-
+        return Ip.IsValid() && Port != 0; 
+    } 
+ 
+    TString ToString() const noexcept; 
+ 
     TIpv6Address Ip {};
     TIpPort Port {0};
-};
+}; 
 IOutputStream& operator<<(IOutputStream& Out, const THostAddressAndPort& HostAddressAndPort) noexcept;
-
-///
-/// Returns
-///   1. either valid THostAddressAndPort
+ 
+/// 
+/// Returns 
+///   1. either valid THostAddressAndPort 
 ///   2. or TString with hostname (which you should resolve) and TIpPort with port
-///   3. or error, if Ok == false
-///
-/// Supported RawStrs are
-///   1.2.3.4          // port wil be equal to DefaultPort
-///   1.2.3.4:80
-///   [2001::7348]     // port wil be equal to DefaultPort
-///   2001::7348       // port wil be equal to DefaultPort
-///   [2001::7348]:80
-///
+///   3. or error, if Ok == false 
+/// 
+/// Supported RawStrs are 
+///   1.2.3.4          // port wil be equal to DefaultPort 
+///   1.2.3.4:80 
+///   [2001::7348]     // port wil be equal to DefaultPort 
+///   2001::7348       // port wil be equal to DefaultPort 
+///   [2001::7348]:80 
+/// 
 std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromString(const TString& RawStr,
                                                                                   TIpPort DefaultPort,
                                                                                   bool& Ok) noexcept;
-
+ 
 using TIpv6AddressesSet = THashSet<TIpv6Address>;
 
-template <>
-struct THash<TIpv6Address> {
+template <> 
+struct THash<TIpv6Address> { 
     inline size_t operator()(const TIpv6Address& ip) const {
         const ui128& Tmp = static_cast<ui128>(ip);
         return CombineHashes(THash<ui128>()(Tmp), THash<ui8>()(static_cast<ui8>(ip.Type())));
-    }
-};
-template <>
-struct THash<THostAddressAndPort> {
+    } 
+}; 
+template <> 
+struct THash<THostAddressAndPort> { 
     inline size_t operator()(const THostAddressAndPort& IpAndPort) const {
-        return CombineHashes(THash<TIpv6Address>()(IpAndPort.Ip), THash<TIpPort>()(IpAndPort.Port));
-    }
-};
-
-namespace std {
-    template <>
-    struct hash<TIpv6Address> {
+        return CombineHashes(THash<TIpv6Address>()(IpAndPort.Ip), THash<TIpPort>()(IpAndPort.Port)); 
+    } 
+}; 
+ 
+namespace std { 
+    template <> 
+    struct hash<TIpv6Address> { 
         std::size_t operator()(const TIpv6Address& Ip) const noexcept {
-            return THash<TIpv6Address>()(Ip);
-        }
-    };
-}
-
+            return THash<TIpv6Address>()(Ip); 
+        } 
+    }; 
+} 
+ 
 NAddr::IRemoteAddr* ToIRemoteAddr(const TIpv6Address& Address, TIpPort Port);
-
-// template <>
-// class TSerializer<TIpv6Address> {
-// public:
+ 
+// template <> 
+// class TSerializer<TIpv6Address> { 
+// public: 
 //    static void Save(IOutputStream *out, const TIpv6Address &ip);
 //    static void Load(IInputStream *in, TIpv6Address &ip);
-//};
+//}; 
diff --git a/library/cpp/ipv6_address/ipv6_address_p.h b/library/cpp/ipv6_address/ipv6_address_p.h
index 44bec74579..1175f07902 100644
--- a/library/cpp/ipv6_address/ipv6_address_p.h
+++ b/library/cpp/ipv6_address/ipv6_address_p.h
@@ -1,7 +1,7 @@
-#pragma once
-
-#include "ipv6_address.h"
-
+#pragma once 
+ 
+#include "ipv6_address.h" 
+ 
 inline TIpv6Address::TIpType FigureOutType(TStringBuf srcStr) noexcept {
     return srcStr.Contains(':') ? TIpv6Address::Ipv6 : TIpv6Address::Ipv4;
-}
+} 
diff --git a/library/cpp/ipv6_address/ut/ipv6_address_ut.cpp b/library/cpp/ipv6_address/ut/ipv6_address_ut.cpp
index 73bb7cffdd..789637cb35 100644
--- a/library/cpp/ipv6_address/ut/ipv6_address_ut.cpp
+++ b/library/cpp/ipv6_address/ut/ipv6_address_ut.cpp
@@ -1,6 +1,6 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/ipv6_address/ipv6_address.h>
-#include <unordered_set>
+#include <unordered_set> 
 
 class TIpv6AddressTest: public TTestBase {
     UNIT_TEST_SUITE(TIpv6AddressTest);
@@ -11,7 +11,7 @@ class TIpv6AddressTest: public TTestBase {
 private:
     void ParseHostAndMayBePortFromString_data();
     void CheckAddressValidity();
-    void HashCompileTest();
+    void HashCompileTest(); 
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TIpv6AddressTest);
@@ -78,7 +78,7 @@ void TIpv6AddressTest::ParseHostAndMayBePortFromString_data() {
 
     CheckIpDefPortAgainstIpPortDefPort("ya.ru", 123, HostRes("ya.ru", 123), true);
 }
-
+ 
 void TIpv6AddressTest::CheckAddressValidity() {
     bool Ok;
 
@@ -106,7 +106,7 @@ void TIpv6AddressTest::CheckAddressValidity() {
     static_assert(Get1() == TIpv6Address(0, 0, 0, 0, 0, 0, 0, 1));
 }
 
-void TIpv6AddressTest::HashCompileTest() {
-    std::unordered_set<TIpv6Address> test;
-    Y_UNUSED(test);
-}
+void TIpv6AddressTest::HashCompileTest() { 
+    std::unordered_set<TIpv6Address> test; 
+    Y_UNUSED(test); 
+}