Restoring authorship annotation for Ruslan Kovalev <ruslan.a.kovalev@gmail.com>. Commit 1 of 2.

8 files changed, 382 insertions, 382 deletions

diff --git a/util/draft/date.h b/util/draft/date.h
index e3eb616fe5..4f7942ed79 100644
--- a/util/draft/date.h
+++ b/util/draft/date.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once 
 
 #include <util/stream/output.h>
 #include <util/stream/input.h>
@@ -7,8 +7,8 @@
 
 #include <ctime>
 
-// XXX: uses system calls for trivial things. may be very slow therefore.
-
+// XXX: uses system calls for trivial things. may be very slow therefore. 
+ 
 time_t GetDateStart(time_t ts);
 
 // Local date (without time zone)
diff --git a/util/draft/datetime.cpp b/util/draft/datetime.cpp
index 5cbe7d8847..401d6eda1e 100644
--- a/util/draft/datetime.cpp
+++ b/util/draft/datetime.cpp
@@ -1,27 +1,27 @@
-#include "datetime.h"
-
+#include "datetime.h" 
+ 
 #include <util/ysaveload.h>
 
-#include <util/system/atomic.h>
-#include <util/system/fasttime.h>
-#include <util/datetime/base.h>
-#include <util/datetime/systime.h>
+#include <util/system/atomic.h> 
+#include <util/system/fasttime.h> 
+#include <util/datetime/base.h> 
+#include <util/datetime/systime.h> 
 #include <util/stream/output.h>
 #include <util/stream/mem.h>
 #include <util/string/cast.h>
 #include <util/string/printf.h>
-
-namespace NDatetime {
-    const ui32 MonthDays[2][12] = {
+ 
+namespace NDatetime { 
+    const ui32 MonthDays[2][12] = { 
         {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, //nleap
         {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}  //leap
-    };
-
+    }; 
+ 
     const ui32 MonthDaysNewYear[2][13] = {
         {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, //nleap
         {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}  //leap
-    };
-
+    }; 
+ 
     void YDayToMonthAndDay(ui32 yday, bool isleap, ui32* month, ui32* mday) {
         const ui32* begin = MonthDaysNewYear[isleap] + 1;
         const ui32* end = begin + 12;
@@ -36,60 +36,60 @@ namespace NDatetime {
         Y_ASSERT((*month < 12) && (1 <= *mday) && (*mday <= MonthDays[isleap][*month]));
     }
 
-    struct TTimeData {
-        i32 IsDst = 0;
-        i32 GMTOff = 0;
-
-        TTimeData(time_t t) {
-            struct ::tm tt;
-            ::localtime_r(&t, &tt);
-#ifndef _win_
-            GMTOff = tt.tm_gmtoff;
+    struct TTimeData { 
+        i32 IsDst = 0; 
+        i32 GMTOff = 0; 
+ 
+        TTimeData(time_t t) { 
+            struct ::tm tt; 
+            ::localtime_r(&t, &tt); 
+#ifndef _win_ 
+            GMTOff = tt.tm_gmtoff; 
 #else
-            TIME_ZONE_INFORMATION tz;
-            switch (GetTimeZoneInformation(&tz)) {
-                case TIME_ZONE_ID_UNKNOWN:
-                    GMTOff = tz.Bias * -60;
-                    break;
-                case TIME_ZONE_ID_STANDARD:
-                    GMTOff = (tz.Bias + tz.StandardBias) * -60;
-                    break;
-                case TIME_ZONE_ID_DAYLIGHT:
-                    GMTOff = (tz.Bias + tz.DaylightBias) * -60;
-                    break;
-                default:
-                    break;
-            }
+            TIME_ZONE_INFORMATION tz; 
+            switch (GetTimeZoneInformation(&tz)) { 
+                case TIME_ZONE_ID_UNKNOWN: 
+                    GMTOff = tz.Bias * -60; 
+                    break; 
+                case TIME_ZONE_ID_STANDARD: 
+                    GMTOff = (tz.Bias + tz.StandardBias) * -60; 
+                    break; 
+                case TIME_ZONE_ID_DAYLIGHT: 
+                    GMTOff = (tz.Bias + tz.DaylightBias) * -60; 
+                    break; 
+                default: 
+                    break; 
+            } 
 #endif
-            IsDst = tt.tm_isdst;
+            IsDst = tt.tm_isdst; 
         }
     };
 
-    TSimpleTM TSimpleTM::CurrentUTC() {
-        return New((time_t)TInstant::MicroSeconds(InterpolatedMicroSeconds()).Seconds());
+    TSimpleTM TSimpleTM::CurrentUTC() { 
+        return New((time_t)TInstant::MicroSeconds(InterpolatedMicroSeconds()).Seconds()); 
+    } 
+ 
+    TSimpleTM TSimpleTM::New(time_t t, i32 gmtoff, i8 isdst) { 
+        time_t tt = t + gmtoff + isdst * 3600; 
+        struct tm tmSys; 
+        Zero(tmSys); 
+        GmTimeR(&tt, &tmSys); 
+        tmSys.tm_isdst = isdst; 
+#ifndef _win_ 
+        tmSys.tm_gmtoff = gmtoff; 
+#endif 
+ 
+        return New(tmSys); 
     }
-
-    TSimpleTM TSimpleTM::New(time_t t, i32 gmtoff, i8 isdst) {
-        time_t tt = t + gmtoff + isdst * 3600;
-        struct tm tmSys;
-        Zero(tmSys);
-        GmTimeR(&tt, &tmSys);
-        tmSys.tm_isdst = isdst;
-#ifndef _win_
-        tmSys.tm_gmtoff = gmtoff;
-#endif
-
-        return New(tmSys);
-    }
-
-    TSimpleTM TSimpleTM::NewLocal(time_t t) {
-        TTimeData d(t);
-        return New(t, d.GMTOff, d.IsDst);
+ 
+    TSimpleTM TSimpleTM::NewLocal(time_t t) { 
+        TTimeData d(t); 
+        return New(t, d.GMTOff, d.IsDst); 
     }
-
+ 
     TSimpleTM TSimpleTM::New(const struct tm& t) {
         TSimpleTM res;
-        res.IsDst = t.tm_isdst;
+        res.IsDst = t.tm_isdst; 
         res.Sec = t.tm_sec;
         res.Min = t.tm_min;
         res.Hour = t.tm_hour;
@@ -98,39 +98,39 @@ namespace NDatetime {
         res.MDay = t.tm_mday;
         res.Year = t.tm_year;
         res.YDay = t.tm_yday;
-        res.IsLeap = LeapYearAD(res.Year + 1900);
-#ifndef _win_
+        res.IsLeap = LeapYearAD(res.Year + 1900); 
+#ifndef _win_ 
         res.GMTOff = t.tm_gmtoff;
-#endif
+#endif 
         return res;
     }
-
-    TSimpleTM& TSimpleTM::SetRealDate(ui32 year, ui32 mon, ui32 mday, ui32 hour, ui32 min, ui32 sec, i32 isdst) {
-        mday = ::Max<ui32>(mday, 1);
-        mon = ::Min<ui32>(::Max<ui32>(mon, 1), 12);
-        year = ::Max<ui32>(year, 1900);
-
-        IsLeap = LeapYearAD(year);
-        Year = year - 1900;
-        Mon = mon - 1;
-        MDay = ::Min<ui32>(mday, MonthDays[IsLeap][Mon]);
-        Hour = Max<ui32>() == hour ? Hour : ::Min<ui32>(hour, 23);
-        Min = Max<ui32>() == min ? Min : ::Min<ui32>(min, 59);
-        Sec = Max<ui32>() == sec ? Sec : ::Min<ui32>(sec, 60);
-        IsDst = isdst;
-
-        return RegenerateFields();
-    }
-
-    TSimpleTM& TSimpleTM::RegenerateFields() {
+ 
+    TSimpleTM& TSimpleTM::SetRealDate(ui32 year, ui32 mon, ui32 mday, ui32 hour, ui32 min, ui32 sec, i32 isdst) { 
+        mday = ::Max<ui32>(mday, 1); 
+        mon = ::Min<ui32>(::Max<ui32>(mon, 1), 12); 
+        year = ::Max<ui32>(year, 1900); 
+ 
+        IsLeap = LeapYearAD(year); 
+        Year = year - 1900; 
+        Mon = mon - 1; 
+        MDay = ::Min<ui32>(mday, MonthDays[IsLeap][Mon]); 
+        Hour = Max<ui32>() == hour ? Hour : ::Min<ui32>(hour, 23); 
+        Min = Max<ui32>() == min ? Min : ::Min<ui32>(min, 59); 
+        Sec = Max<ui32>() == sec ? Sec : ::Min<ui32>(sec, 60); 
+        IsDst = isdst; 
+ 
+        return RegenerateFields(); 
+    } 
+ 
+    TSimpleTM& TSimpleTM::RegenerateFields() { 
         return *this = New(AsTimeT(), GMTOff, IsDst);
-    }
-
+    } 
+ 
     TSimpleTM& TSimpleTM::Add(EField f, i32 amount) {
         if (!amount) {
             return *this;
         }
-
+ 
         switch (f) {
             default:
                 return *this;
@@ -143,59 +143,59 @@ namespace NDatetime {
             case F_MIN:
                 amount *= 60;
                 [[fallthrough]];
-            case F_SEC: {
+            case F_SEC: { 
                 return *this = New(AsTimeT() + amount, GMTOff, IsDst);
-            }
+            } 
             case F_YEAR: {
                 i32 y = amount + (i32)Year;
                 y = ::Min<i32>(Max<i32>(y, 0), 255 /*max year*/);
-
+ 
                 // YDay may correspond to different MDay if it's March or greater and the years have different leap status
                 if (Mon > 1) {
-                    YDay += (i32)LeapYearAD(RealYear()) - (i32)LeapYearAD(RealYear());
+                    YDay += (i32)LeapYearAD(RealYear()) - (i32)LeapYearAD(RealYear()); 
                 }
-
+ 
                 Year = y;
-                IsLeap = LeapYearAD(RealYear());
-                return RegenerateFields();
+                IsLeap = LeapYearAD(RealYear()); 
+                return RegenerateFields(); 
             }
             case F_MON: {
                 i32 m = amount + Mon;
                 i32 y = (m < 0 ? (-12 + m) : m) / 12;
                 m = m - y * 12;
-
-                if (y) {
+ 
+                if (y) { 
                     Add(F_YEAR, y);
-                }
-
+                } 
+ 
                 if (m >= 0 && m < 12) {
                     MDay = ::Min<ui32>(MonthDays[IsLeap][m], MDay);
-                    Mon = m;
+                    Mon = m; 
                 }
 
-                return RegenerateFields();
+                return RegenerateFields(); 
             }
-        }
-    }
+        } 
+    } 
 
     TString TSimpleTM::ToString(const char* fmt) const {
         struct tm t = *this;
-        return Strftime(fmt, &t);
+        return Strftime(fmt, &t); 
+    } 
+ 
+    time_t TSimpleTM::AsTimeT() const { 
+        struct tm t = AsStructTmLocal(); 
+        return TimeGM(&t) - GMTOff - IsDst * 3600; 
     }
-
-    time_t TSimpleTM::AsTimeT() const {
-        struct tm t = AsStructTmLocal();
-        return TimeGM(&t) - GMTOff - IsDst * 3600;
-    }
-
-    struct tm TSimpleTM::AsStructTmUTC() const {
-        struct tm res;
-        Zero(res);
-        time_t t = AsTimeT();
-        return *GmTimeR(&t, &res);
-    }
-
-    struct tm TSimpleTM::AsStructTmLocal() const {
+ 
+    struct tm TSimpleTM::AsStructTmUTC() const { 
+        struct tm res; 
+        Zero(res); 
+        time_t t = AsTimeT(); 
+        return *GmTimeR(&t, &res); 
+    } 
+ 
+    struct tm TSimpleTM::AsStructTmLocal() const { 
         struct tm t;
         Zero(t);
         t.tm_isdst = IsDst;
@@ -207,12 +207,12 @@ namespace NDatetime {
         t.tm_mday = MDay;
         t.tm_year = Year;
         t.tm_yday = YDay;
-#ifndef _win_
+#ifndef _win_ 
         t.tm_gmtoff = GMTOff;
-#endif
+#endif 
         return t;
     }
-}
+} 
 
 template <>
 void In<TMonth>(IInputStream& in, TMonth& t) {
diff --git a/util/draft/datetime.h b/util/draft/datetime.h
index 8a387ea6f1..58a64b16ee 100644
--- a/util/draft/datetime.h
+++ b/util/draft/datetime.h
@@ -1,32 +1,32 @@
-#pragma once
-
-#include <util/generic/algorithm.h>
+#pragma once 
+ 
+#include <util/generic/algorithm.h> 
 #include <util/generic/string.h>
-#include <util/generic/yexception.h>
+#include <util/generic/yexception.h> 
 #include <util/generic/ymath.h>
 #include <util/datetime/base.h>
-
+ 
 #include <cstdlib>
 
 #include <time.h>
 
-namespace NDatetime {
+namespace NDatetime { 
     extern const ui32 MonthDays[2][12];        // !leapYear; !!leapYear
     extern const ui32 MonthDaysNewYear[2][13]; // !leapYear; !!leapYear
-
+ 
     inline ui32 YearDaysAD(ui32 year) {
         year = Max<ui32>(year, 1) - 1; //1 AD comes straight after 1 BC, no 0 AD
         return year * 365 + year / 4 - year / 100 + year / 400;
     }
-
+ 
     inline bool LeapYearAD(ui32 year) {
-        return (!(year % 4) && (year % 100)) || !(year % 400);
+        return (!(year % 4) && (year % 100)) || !(year % 400); 
     }
-
+ 
     inline ui32 YDayFromMonthAndDay(ui32 month /*0 - based*/, ui32 mday /*1 - based*/, bool isleap) {
         return MonthDaysNewYear[isleap][Min(month, (ui32)11u)] + mday - 1;
     }
-
+ 
     void YDayToMonthAndDay(ui32 yday /*0 - based*/, bool isleap, ui32* month /*0 - based*/, ui32* mday /*1 - based*/);
 
     struct TSimpleTM {
@@ -39,111 +39,111 @@ namespace NDatetime {
             F_MON,
             F_YEAR
         };
-
-        i32 GMTOff = 0; // -43200 - 50400 seconds
-        ui16 Year = 0;  // from 1900
-        ui16 YDay = 0;  // 0-365
-        ui8 Mon = 0;    // 0-11
-        ui8 MDay = 0;   // 1-31
-        ui8 WDay = 0;   // 0-6
-        ui8 Hour = 0;   // 0-23
-        ui8 Min = 0;    // 0-59
-        ui8 Sec = 0;    // 0-60 - doesn't care for leap seconds. Most of the time it's ok.
-        i8 IsDst = 0;   // -1/0/1
-        bool IsLeap = false;
-
-    public:
-        static TSimpleTM New(time_t t = 0, i32 gmtoff = 0, i8 isdst = 0);
-        static TSimpleTM NewLocal(time_t = 0);
-
+ 
+        i32 GMTOff = 0; // -43200 - 50400 seconds 
+        ui16 Year = 0;  // from 1900 
+        ui16 YDay = 0;  // 0-365 
+        ui8 Mon = 0;    // 0-11 
+        ui8 MDay = 0;   // 1-31 
+        ui8 WDay = 0;   // 0-6 
+        ui8 Hour = 0;   // 0-23 
+        ui8 Min = 0;    // 0-59 
+        ui8 Sec = 0;    // 0-60 - doesn't care for leap seconds. Most of the time it's ok. 
+        i8 IsDst = 0;   // -1/0/1 
+        bool IsLeap = false; 
+ 
+    public: 
+        static TSimpleTM New(time_t t = 0, i32 gmtoff = 0, i8 isdst = 0); 
+        static TSimpleTM NewLocal(time_t = 0); 
+ 
         static TSimpleTM New(const struct tm&);
-
-        static TSimpleTM CurrentUTC();
-
-        TSimpleTM() = default;
-
+ 
+        static TSimpleTM CurrentUTC(); 
+ 
+        TSimpleTM() = default; 
+ 
         TSimpleTM(ui32 year, ui32 mon, ui32 day, ui32 h = 0, ui32 m = 0, ui32 s = 0) {
             Zero(*this);
             SetRealDate(year, mon, day, h, m, s);
         }
-
+ 
         // keeps the object consistent
         TSimpleTM& Add(EField f, i32 amount = 1);
-
+ 
         TString ToString(const char* fmt = "%a, %d %b %Y %H:%M:%S %z") const;
-
-        TSimpleTM& ToUTC() {
+ 
+        TSimpleTM& ToUTC() { 
             return *this = New(AsTimeT());
-        }
-
-        bool IsUTC() const {
-            return !IsDst && !GMTOff;
-        }
-
-        time_t AsTimeT() const;
-
-        operator time_t() const {
-            return AsTimeT();
-        };
-
-        struct tm AsStructTmLocal() const;
-
-        struct tm AsStructTmUTC() const;
-
-        operator struct tm() const {
-            return AsStructTmLocal();
-        }
-
+        } 
+ 
+        bool IsUTC() const { 
+            return !IsDst && !GMTOff; 
+        } 
+ 
+        time_t AsTimeT() const; 
+ 
+        operator time_t() const { 
+            return AsTimeT(); 
+        }; 
+ 
+        struct tm AsStructTmLocal() const; 
+ 
+        struct tm AsStructTmUTC() const; 
+ 
+        operator struct tm() const { 
+            return AsStructTmLocal(); 
+        } 
+ 
         ui32 RealYear() const {
             return ui32(Year + 1900);
         }
-
+ 
         ui32 RealMonth() const {
             return ui32(Mon + 1);
         }
-
-        TSimpleTM& SetRealDate(ui32 year, ui32 mon, ui32 mday, ui32 hour = -1, ui32 min = -1, ui32 sec = -1, i32 isdst = 0);
-
-        // regenerates all fields from Year, MDay, Hour, Min, Sec, IsDst, GMTOffset
-        TSimpleTM& RegenerateFields();
-
+ 
+        TSimpleTM& SetRealDate(ui32 year, ui32 mon, ui32 mday, ui32 hour = -1, ui32 min = -1, ui32 sec = -1, i32 isdst = 0); 
+ 
+        // regenerates all fields from Year, MDay, Hour, Min, Sec, IsDst, GMTOffset 
+        TSimpleTM& RegenerateFields(); 
+ 
         friend bool operator==(const TSimpleTM& a, const TSimpleTM& b) {
-            return a.AsTimeT() == b.AsTimeT();
+            return a.AsTimeT() == b.AsTimeT(); 
         }
-
+ 
         friend bool operator==(const TSimpleTM& s, const struct tm& t) {
             return s == New(t);
         }
-
+ 
         friend bool operator==(const struct tm& t, const TSimpleTM& s) {
             return s == t;
         }
-
+ 
         friend bool operator!=(const TSimpleTM& a, const TSimpleTM& b) {
             return !(a == b);
         }
-
+ 
         friend bool operator!=(const TSimpleTM& s, const struct tm& t) {
             return !(s == t);
         }
-
+ 
         friend bool operator!=(const struct tm& t, const TSimpleTM& s) {
             return s != t;
         }
     };
-}
+} 
 
 inline TString date2str(const time_t date) {
-    struct tm dateTm;
-    memset(&dateTm, 0, sizeof(dateTm));
-    localtime_r(&date, &dateTm);
+    struct tm dateTm; 
+    memset(&dateTm, 0, sizeof(dateTm)); 
+    localtime_r(&date, &dateTm); 
     char buf[9];
     strftime(buf, sizeof(buf), "%Y%m%d", &dateTm);
     return TString(buf);
 }
 
 inline time_t str2date(const TString& dateStr) {
-    struct tm dateTm;
+    struct tm dateTm; 
     memset(&dateTm, 0, sizeof(tm));
     strptime(dateStr.data(), "%Y%m%d", &dateTm);
     return mktime(&dateTm);
diff --git a/util/draft/datetime_ut.cpp b/util/draft/datetime_ut.cpp
index a5e065ef6e..f959848d5e 100644
--- a/util/draft/datetime_ut.cpp
+++ b/util/draft/datetime_ut.cpp
@@ -1,66 +1,66 @@
 #include "datetime.h"
 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #include <util/string/builder.h>
 
 Y_UNIT_TEST_SUITE(TSimpleTMTest) {
     TString PrintMarker(const TString& test, int line) {
         return TStringBuilder() << "test " << test << " at line " << line;
-    }
-
+    } 
+ 
     TString JoinMarker(const TString& marker, time_t t) {
         return TStringBuilder() << marker << " (tstamp=" << t << ")";
-    }
-
+    } 
+ 
     TString PrintMarker(const TString& test, int line, time_t t) {
-        return JoinMarker(PrintMarker(test, line), t);
-    }
-
+        return JoinMarker(PrintMarker(test, line), t); 
+    } 
+ 
     void AssertStructTmEqual(const TString& marker, const struct tm& tmt, const NDatetime::TSimpleTM& tms) {
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Sec, tmt.tm_sec, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Min, tmt.tm_min, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Hour, tmt.tm_hour, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.WDay, tmt.tm_wday, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.MDay, tmt.tm_mday, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Mon, tmt.tm_mon, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.YDay, tmt.tm_yday, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Year, tmt.tm_year, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.IsDst, tmt.tm_isdst, marker);
-#ifndef _win_
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.GMTOff, tmt.tm_gmtoff, marker);
-#endif
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Sec, tmt.tm_sec, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Min, tmt.tm_min, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Hour, tmt.tm_hour, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.WDay, tmt.tm_wday, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.MDay, tmt.tm_mday, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Mon, tmt.tm_mon, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.YDay, tmt.tm_yday, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Year, tmt.tm_year, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.IsDst, tmt.tm_isdst, marker); 
+#ifndef _win_ 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.GMTOff, tmt.tm_gmtoff, marker); 
+#endif 
+    } 
+ 
     void AssertSimpleTM(const TString& mark,
-                        const NDatetime::TSimpleTM& tms,
-                        time_t tstamp, ui32 year, ui32 mon, ui32 mday, ui32 hour, ui32 minu, ui32 sec) {
+                        const NDatetime::TSimpleTM& tms, 
+                        time_t tstamp, ui32 year, ui32 mon, ui32 mday, ui32 hour, ui32 minu, ui32 sec) { 
         TString marker = JoinMarker(mark, tstamp);
-        struct tm tmt;
-        Zero(tmt);
-        GmTimeR(&tstamp, &tmt);
-        AssertStructTmEqual(marker, tmt, tms);
-        tmt = tms.AsStructTmUTC();
-        time_t tstamp1 = TimeGM(&tmt);
-        UNIT_ASSERT_VALUES_EQUAL_C(tstamp, tstamp1, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C(tstamp, tms.AsTimeT(), marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.RealYear(), year, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.RealMonth(), mon, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.MDay, mday, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Hour, hour, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Min, minu, marker);
-        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Sec, sec, marker);
-    }
-
+        struct tm tmt; 
+        Zero(tmt); 
+        GmTimeR(&tstamp, &tmt); 
+        AssertStructTmEqual(marker, tmt, tms); 
+        tmt = tms.AsStructTmUTC(); 
+        time_t tstamp1 = TimeGM(&tmt); 
+        UNIT_ASSERT_VALUES_EQUAL_C(tstamp, tstamp1, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C(tstamp, tms.AsTimeT(), marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.RealYear(), year, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.RealMonth(), mon, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.MDay, mday, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Hour, hour, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Min, minu, marker); 
+        UNIT_ASSERT_VALUES_EQUAL_C((int)tms.Sec, sec, marker); 
+    } 
+ 
     Y_UNIT_TEST(TestLeap) {
-        using namespace NDatetime;
+        using namespace NDatetime; 
         UNIT_ASSERT(LeapYearAD(2000));
         UNIT_ASSERT(LeapYearAD(2012));
         UNIT_ASSERT(!LeapYearAD(1999));
         UNIT_ASSERT(LeapYearAD(2004));
         UNIT_ASSERT(!LeapYearAD(1900));
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestYDayConversion) {
         using namespace NDatetime;
         ui32 month;
@@ -81,151 +81,151 @@ Y_UNIT_TEST_SUITE(TSimpleTMTest) {
 
     Y_UNIT_TEST(SimpleTMTest) {
         using namespace NDatetime;
-
-        tzset();
-
-        TSimpleTM::New(-1); //should not die here
-
-        UNIT_ASSERT_VALUES_EQUAL((ui32)0, (ui32)TSimpleTM::New(0));
-        UNIT_ASSERT((ui32)TSimpleTM::New(0).IsUTC());
+ 
+        tzset(); 
+ 
+        TSimpleTM::New(-1); //should not die here 
+ 
+        UNIT_ASSERT_VALUES_EQUAL((ui32)0, (ui32)TSimpleTM::New(0)); 
+        UNIT_ASSERT((ui32)TSimpleTM::New(0).IsUTC()); 
         time_t t = time(nullptr);
-
+ 
         {
-            struct tm tmt;
-            Zero(tmt);
-            gmtime_r(&t, &tmt);
+            struct tm tmt; 
+            Zero(tmt); 
+            gmtime_r(&t, &tmt); 
             UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(t).AsTimeT(), ToString(t));   // time_t ->   gmt tm -> time_t
-            UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT(), ToString(t)); //   gmt tm -> time_t
-            AssertStructTmEqual(PrintMarker("UTC:time_t", __LINE__, t),
-                                tmt, TSimpleTM::New(t));
-            AssertStructTmEqual(PrintMarker("UTC:tm", __LINE__, t),
-                                tmt, TSimpleTM::New(tmt));
-            UNIT_ASSERT(TSimpleTM::New(t).IsUTC());
-            UNIT_ASSERT(TSimpleTM::New(tmt).IsUTC());
+            UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT(), ToString(t)); //   gmt tm -> time_t 
+            AssertStructTmEqual(PrintMarker("UTC:time_t", __LINE__, t), 
+                                tmt, TSimpleTM::New(t)); 
+            AssertStructTmEqual(PrintMarker("UTC:tm", __LINE__, t), 
+                                tmt, TSimpleTM::New(tmt)); 
+            UNIT_ASSERT(TSimpleTM::New(t).IsUTC()); 
+            UNIT_ASSERT(TSimpleTM::New(tmt).IsUTC()); 
         }
-
-        {
-            struct tm tmt;
-            Zero(tmt);
-            localtime_r(&t, &tmt);
-
-            UNIT_ASSERT_VALUES_EQUAL((i64)t, (i64)TSimpleTM::NewLocal(t).AsTimeT()); // time_t -> local tm -> time_t
-            UNIT_ASSERT_VALUES_EQUAL((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT());
-            AssertStructTmEqual(PrintMarker("local:time_t", __LINE__, t),
-                                tmt, TSimpleTM::NewLocal(t));
-            AssertStructTmEqual(PrintMarker("local:tm", __LINE__, t),
-                                tmt, TSimpleTM::New(tmt));
-            AssertStructTmEqual(PrintMarker("local:tm:RegenerateFields", __LINE__, t),
-                                tmt, TSimpleTM::New(tmt).RegenerateFields());
-            AssertStructTmEqual(PrintMarker("local:time_t:SetRealDate", __LINE__, t),
+ 
+        { 
+            struct tm tmt; 
+            Zero(tmt); 
+            localtime_r(&t, &tmt); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL((i64)t, (i64)TSimpleTM::NewLocal(t).AsTimeT()); // time_t -> local tm -> time_t 
+            UNIT_ASSERT_VALUES_EQUAL((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT()); 
+            AssertStructTmEqual(PrintMarker("local:time_t", __LINE__, t), 
+                                tmt, TSimpleTM::NewLocal(t)); 
+            AssertStructTmEqual(PrintMarker("local:tm", __LINE__, t), 
+                                tmt, TSimpleTM::New(tmt)); 
+            AssertStructTmEqual(PrintMarker("local:tm:RegenerateFields", __LINE__, t), 
+                                tmt, TSimpleTM::New(tmt).RegenerateFields()); 
+            AssertStructTmEqual(PrintMarker("local:time_t:SetRealDate", __LINE__, t), 
                                 tmt, TSimpleTM::NewLocal(t).SetRealDate(tmt.tm_year + 1900, tmt.tm_mon + 1, tmt.tm_mday, tmt.tm_hour, tmt.tm_min, tmt.tm_sec, tmt.tm_isdst));
-        }
-
-        {
-            TSimpleTM tt = TSimpleTM::New(0);
-
-            tt.SetRealDate(2012, 3, 30, 5, 6, 7);
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1333083967, 2012, 3, 30, 5, 6, 7);
-
-            tt.SetRealDate(2012, 3, 8, 5, 6, 7);
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1331183167, 2012, 3, 8, 5, 6, 7);
-
-            tt.SetRealDate(2010, 10, 4, 5, 6, 7);
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1286168767, 2010, 10, 4, 5, 6, 7);
-
-            tt.Add(TSimpleTM::F_MON);
-            AssertSimpleTM(PrintMarker("UTC:AddMonth", __LINE__),
-                           tt, 1288847167, 2010, 11, 4, 5, 6, 7);
-
-            tt.Add(TSimpleTM::F_DAY);
-            AssertSimpleTM(PrintMarker("UTC:AddDay", __LINE__),
-                           tt, 1288933567, 2010, 11, 5, 5, 6, 7);
-
-            tt.Add(TSimpleTM::F_YEAR);
-            AssertSimpleTM(PrintMarker("UTC:AddYear", __LINE__),
-                           tt, 1320469567, 2011, 11, 5, 5, 6, 7);
-
+        } 
+ 
+        { 
+            TSimpleTM tt = TSimpleTM::New(0); 
+ 
+            tt.SetRealDate(2012, 3, 30, 5, 6, 7); 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1333083967, 2012, 3, 30, 5, 6, 7); 
+ 
+            tt.SetRealDate(2012, 3, 8, 5, 6, 7); 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1331183167, 2012, 3, 8, 5, 6, 7); 
+ 
+            tt.SetRealDate(2010, 10, 4, 5, 6, 7); 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1286168767, 2010, 10, 4, 5, 6, 7); 
+ 
+            tt.Add(TSimpleTM::F_MON); 
+            AssertSimpleTM(PrintMarker("UTC:AddMonth", __LINE__), 
+                           tt, 1288847167, 2010, 11, 4, 5, 6, 7); 
+ 
+            tt.Add(TSimpleTM::F_DAY); 
+            AssertSimpleTM(PrintMarker("UTC:AddDay", __LINE__), 
+                           tt, 1288933567, 2010, 11, 5, 5, 6, 7); 
+ 
+            tt.Add(TSimpleTM::F_YEAR); 
+            AssertSimpleTM(PrintMarker("UTC:AddYear", __LINE__), 
+                           tt, 1320469567, 2011, 11, 5, 5, 6, 7); 
+ 
             for (ui32 i = 0; i < 365; ++i) {
-                tt.Add(TSimpleTM::F_DAY);
+                tt.Add(TSimpleTM::F_DAY); 
             }
-
-            AssertSimpleTM(PrintMarker("UTC:365*AddDay", __LINE__),
-                           tt, 1352005567, 2012, 11, 4, 5, 6, 7);
-
-            tt.Add(TSimpleTM::F_MON, -10);
-            AssertSimpleTM(PrintMarker("UTC:AddMonth(-10)", __LINE__),
-                           tt, 1325653567, 2012, 1, 4, 5, 6, 7);
-
-            tt.Add(TSimpleTM::F_HOUR, -24 * 4 - 6);
-            AssertSimpleTM(PrintMarker("UTC:AddHour(-102)", __LINE__),
-                           tt, 1325286367, 2011, 12, 30, 23, 6, 7);
-        }
-
-        {
-            TSimpleTM tt = TSimpleTM::New();
-
-            tt.SetRealDate(2012, 2, 29);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1330473600, 2012, 2, 29, 0, 0, 0);
-
-            tt.SetRealDate(2012, 2, 29);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1330473600, 2012, 2, 29, 0, 0, 0);
-
-            tt.SetRealDate(2013, 12, 28);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1388188800, 2013, 12, 28, 0, 0, 0);
-
-            tt.SetRealDate(2012, 10, 23);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1350950400, 2012, 10, 23, 0, 0, 0);
-
-            tt.SetRealDate(2013, 3, 16);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1363392000, 2013, 3, 16, 0, 0, 0);
-
-            tt.SetRealDate(2013, 2, 17);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1361059200, 2013, 2, 17, 0, 0, 0);
-
-            tt.SetRealDate(2012, 12, 23);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1356220800, 2012, 12, 23, 0, 0, 0);
-
-            tt.SetRealDate(2012, 5, 17);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1337212800, 2012, 5, 17, 0, 0, 0);
-
-            tt.SetRealDate(2012, 6, 15);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1339718400, 2012, 6, 15, 0, 0, 0);
-
-            tt.SetRealDate(2009, 3, 17);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1237248000, 2009, 3, 17, 0, 0, 0);
-
-            tt.SetRealDate(2013, 8, 12);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1376265600, 2013, 8, 12, 0, 0, 0);
-
-            tt.SetRealDate(2015, 12, 11, 10, 9, 8);
-
-            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__),
-                           tt, 1449828548, 2015, 12, 11, 10, 9, 8);
-        }
-    }
-}
+ 
+            AssertSimpleTM(PrintMarker("UTC:365*AddDay", __LINE__), 
+                           tt, 1352005567, 2012, 11, 4, 5, 6, 7); 
+ 
+            tt.Add(TSimpleTM::F_MON, -10); 
+            AssertSimpleTM(PrintMarker("UTC:AddMonth(-10)", __LINE__), 
+                           tt, 1325653567, 2012, 1, 4, 5, 6, 7); 
+ 
+            tt.Add(TSimpleTM::F_HOUR, -24 * 4 - 6); 
+            AssertSimpleTM(PrintMarker("UTC:AddHour(-102)", __LINE__), 
+                           tt, 1325286367, 2011, 12, 30, 23, 6, 7); 
+        } 
+ 
+        { 
+            TSimpleTM tt = TSimpleTM::New(); 
+ 
+            tt.SetRealDate(2012, 2, 29); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1330473600, 2012, 2, 29, 0, 0, 0); 
+ 
+            tt.SetRealDate(2012, 2, 29); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1330473600, 2012, 2, 29, 0, 0, 0); 
+ 
+            tt.SetRealDate(2013, 12, 28); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1388188800, 2013, 12, 28, 0, 0, 0); 
+ 
+            tt.SetRealDate(2012, 10, 23); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1350950400, 2012, 10, 23, 0, 0, 0); 
+ 
+            tt.SetRealDate(2013, 3, 16); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1363392000, 2013, 3, 16, 0, 0, 0); 
+ 
+            tt.SetRealDate(2013, 2, 17); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1361059200, 2013, 2, 17, 0, 0, 0); 
+ 
+            tt.SetRealDate(2012, 12, 23); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1356220800, 2012, 12, 23, 0, 0, 0); 
+ 
+            tt.SetRealDate(2012, 5, 17); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1337212800, 2012, 5, 17, 0, 0, 0); 
+ 
+            tt.SetRealDate(2012, 6, 15); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1339718400, 2012, 6, 15, 0, 0, 0); 
+ 
+            tt.SetRealDate(2009, 3, 17); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1237248000, 2009, 3, 17, 0, 0, 0); 
+ 
+            tt.SetRealDate(2013, 8, 12); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1376265600, 2013, 8, 12, 0, 0, 0); 
+ 
+            tt.SetRealDate(2015, 12, 11, 10, 9, 8); 
+ 
+            AssertSimpleTM(PrintMarker("UTC:SetRealDate", __LINE__), 
+                           tt, 1449828548, 2015, 12, 11, 10, 9, 8); 
+        } 
+    } 
+} 
diff --git a/util/draft/enum.h b/util/draft/enum.h
index 18002b7df2..f1a80d4640 100644
--- a/util/draft/enum.h
+++ b/util/draft/enum.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once 
 
 #include <bitset>
 
diff --git a/util/draft/holder_vector.h b/util/draft/holder_vector.h
index 1c62055bd9..9b8c0db7eb 100644
--- a/util/draft/holder_vector.h
+++ b/util/draft/holder_vector.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once 
 
 #include <util/generic/ptr.h>
 #include <util/generic/vector.h>
diff --git a/util/draft/matrix.h b/util/draft/matrix.h
index 154d00b35e..8ffc439393 100644
--- a/util/draft/matrix.h
+++ b/util/draft/matrix.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once 
 
 #include <util/generic/noncopyable.h>
 #include <util/system/yassert.h>
diff --git a/util/draft/ya.make b/util/draft/ya.make
index e00674b682..3201221981 100644
--- a/util/draft/ya.make
+++ b/util/draft/ya.make
@@ -11,7 +11,7 @@ ENDIF()
 
 SRCS(
     date.cpp
-    datetime.cpp
+    datetime.cpp 
     enum.cpp
     holder_vector.cpp
     ip.cpp