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

35 files changed, 779 insertions, 779 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/time/civil_time.cc b/contrib/restricted/abseil-cpp/absl/time/civil_time.cc
index 6a231edb2d..b03132c959 100644
--- a/contrib/restricted/abseil-cpp/absl/time/civil_time.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/civil_time.cc
@@ -21,7 +21,7 @@
 #include "absl/time/time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 namespace {
 
@@ -45,7 +45,7 @@ template <typename CivilT>
 bool ParseYearAnd(string_view fmt, string_view s, CivilT* c) {
   // Civil times support a larger year range than absl::Time, so we need to
   // parse the year separately, normalize it, then use absl::ParseTime on the
-  // normalized string.
+  // normalized string. 
   const std::string ss = std::string(s);  // TODO(absl-team): Avoid conversion.
   const char* const np = ss.c_str();
   char* endp;
@@ -80,7 +80,7 @@ bool ParseAs(string_view s, CivilT2* c) {
 
 template <typename CivilT>
 bool ParseLenient(string_view s, CivilT* c) {
-  // A fastpath for when the given string data parses exactly into the given
+  // A fastpath for when the given string data parses exactly into the given 
   // type T (e.g., s="YYYY-MM-DD" and CivilT=CivilDay).
   if (ParseCivilTime(s, c)) return true;
   // Try parsing as each of the 6 types, trying the most common types first
@@ -96,26 +96,26 @@ bool ParseLenient(string_view s, CivilT* c) {
 }  // namespace
 
 std::string FormatCivilTime(CivilSecond c) {
-  return FormatYearAnd("-%m-%d%ET%H:%M:%S", c);
+  return FormatYearAnd("-%m-%d%ET%H:%M:%S", c); 
 }
 std::string FormatCivilTime(CivilMinute c) {
-  return FormatYearAnd("-%m-%d%ET%H:%M", c);
+  return FormatYearAnd("-%m-%d%ET%H:%M", c); 
 }
 std::string FormatCivilTime(CivilHour c) {
-  return FormatYearAnd("-%m-%d%ET%H", c);
+  return FormatYearAnd("-%m-%d%ET%H", c); 
 }
 std::string FormatCivilTime(CivilDay c) { return FormatYearAnd("-%m-%d", c); }
 std::string FormatCivilTime(CivilMonth c) { return FormatYearAnd("-%m", c); }
 std::string FormatCivilTime(CivilYear c) { return FormatYearAnd("", c); }
 
 bool ParseCivilTime(string_view s, CivilSecond* c) {
-  return ParseYearAnd("-%m-%d%ET%H:%M:%S", s, c);
+  return ParseYearAnd("-%m-%d%ET%H:%M:%S", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilMinute* c) {
-  return ParseYearAnd("-%m-%d%ET%H:%M", s, c);
+  return ParseYearAnd("-%m-%d%ET%H:%M", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilHour* c) {
-  return ParseYearAnd("-%m-%d%ET%H", s, c);
+  return ParseYearAnd("-%m-%d%ET%H", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilDay* c) {
   return ParseYearAnd("-%m-%d", s, c);
@@ -169,5 +169,5 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s) {
 
 }  // namespace time_internal
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/civil_time.h b/contrib/restricted/abseil-cpp/absl/time/civil_time.h
index bb46004434..bced90191f 100644
--- a/contrib/restricted/abseil-cpp/absl/time/civil_time.h
+++ b/contrib/restricted/abseil-cpp/absl/time/civil_time.h
@@ -76,7 +76,7 @@
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 namespace time_internal {
 struct second_tag : cctz::detail::second_tag {};
@@ -532,7 +532,7 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s);
 
 }  // namespace time_internal
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_CIVIL_TIME_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/civil_time/ya.make b/contrib/restricted/abseil-cpp/absl/time/civil_time/ya.make
index d6d6000692..5797933193 100644
--- a/contrib/restricted/abseil-cpp/absl/time/civil_time/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/time/civil_time/ya.make
@@ -16,10 +16,10 @@ NO_COMPILER_WARNINGS()
 
 NO_UTIL()
 
-CFLAGS(
-    -DNOMINMAX
-)
-
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCDIR(contrib/restricted/abseil-cpp/absl/time/internal/cctz/src)
 
 SRCS(
diff --git a/contrib/restricted/abseil-cpp/absl/time/clock.cc b/contrib/restricted/abseil-cpp/absl/time/clock.cc
index 7b204c4ee0..40ac6e7a54 100644
--- a/contrib/restricted/abseil-cpp/absl/time/clock.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/clock.cc
@@ -35,7 +35,7 @@
 #include "absl/base/thread_annotations.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 Time Now() {
   // TODO(bww): Get a timespec instead so we don't have to divide.
   int64_t n = absl::GetCurrentTimeNanos();
@@ -45,7 +45,7 @@ Time Now() {
   }
   return time_internal::FromUnixDuration(absl::Nanoseconds(n));
 }
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 // Decide if we should use the fast GetCurrentTimeNanos() algorithm
@@ -74,9 +74,9 @@ ABSL_NAMESPACE_END
 
 #if !ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
 namespace absl {
-ABSL_NAMESPACE_BEGIN
-int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_BEGIN 
+int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); } 
+ABSL_NAMESPACE_END 
 }  // namespace absl
 #else  // Use the cyclecounter-based implementation below.
 
@@ -87,7 +87,7 @@ ABSL_NAMESPACE_END
 #endif
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 // This is a friend wrapper around UnscaledCycleClock::Now()
 // (needed to access UnscaledCycleClock).
@@ -535,12 +535,12 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
 
   return estimated_base_ns;
 }
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 #endif  // ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace {
 
 // Returns the maximum duration that SleepOnce() can sleep for.
@@ -568,7 +568,7 @@ void SleepOnce(absl::Duration to_sleep) {
 }
 
 }  // namespace
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 extern "C" {
diff --git a/contrib/restricted/abseil-cpp/absl/time/clock.h b/contrib/restricted/abseil-cpp/absl/time/clock.h
index 5fe244d638..0f9b555800 100644
--- a/contrib/restricted/abseil-cpp/absl/time/clock.h
+++ b/contrib/restricted/abseil-cpp/absl/time/clock.h
@@ -26,7 +26,7 @@
 #include "absl/time/time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 // Now()
 //
@@ -50,7 +50,7 @@ int64_t GetCurrentTimeNanos();
 // * Returns immediately when passed a nonpositive duration.
 void SleepFor(absl::Duration duration);
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 // -----------------------------------------------------------------------------
diff --git a/contrib/restricted/abseil-cpp/absl/time/duration.cc b/contrib/restricted/abseil-cpp/absl/time/duration.cc
index 4443109a51..4aae128bad 100644
--- a/contrib/restricted/abseil-cpp/absl/time/duration.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/duration.cc
@@ -67,14 +67,14 @@
 #include <string>
 
 #include "absl/base/casts.h"
-#include "absl/base/macros.h"
+#include "absl/base/macros.h" 
 #include "absl/numeric/int128.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
+#include "absl/strings/string_view.h" 
+#include "absl/strings/strip.h" 
 #include "absl/time/time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 namespace {
 
@@ -356,7 +356,7 @@ namespace time_internal {
 // the remainder.  If it does not saturate, the remainder remain accurate,
 // but the returned quotient will over/underflow int64_t and should not be used.
 int64_t IDivDuration(bool satq, const Duration num, const Duration den,
-                     Duration* rem) {
+                     Duration* rem) { 
   int64_t q = 0;
   if (IDivFastPath(num, den, &q, rem)) {
     return q;
@@ -711,17 +711,17 @@ char* Format64(char* ep, int width, int64_t v) {
 // fractional digits, because it is in the noise of what a Duration can
 // represent.
 struct DisplayUnit {
-  absl::string_view abbr;
+  absl::string_view abbr; 
   int prec;
   double pow10;
 };
-ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2};
-ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5};
-ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8};
-ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11};
-ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored
-ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1,
-                                                  0.0};  // prec ignored
+ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8}; 
+ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored 
+ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1, 
+                                                  0.0};  // prec ignored 
 
 void AppendNumberUnit(std::string* out, int64_t n, DisplayUnit unit) {
   char buf[sizeof("2562047788015216")];  // hours in max duration
@@ -729,16 +729,16 @@ void AppendNumberUnit(std::string* out, int64_t n, DisplayUnit unit) {
   char* bp = Format64(ep, 0, n);
   if (*bp != '0' || bp + 1 != ep) {
     out->append(bp, ep - bp);
-    out->append(unit.abbr.data(), unit.abbr.size());
+    out->append(unit.abbr.data(), unit.abbr.size()); 
   }
 }
 
 // Note: unit.prec is limited to double's digits10 value (typically 15) so it
 // always fits in buf[].
 void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
-  constexpr int kBufferSize = std::numeric_limits<double>::digits10;
-  const int prec = std::min(kBufferSize, unit.prec);
-  char buf[kBufferSize];  // also large enough to hold integer part
+  constexpr int kBufferSize = std::numeric_limits<double>::digits10; 
+  const int prec = std::min(kBufferSize, unit.prec); 
+  char buf[kBufferSize];  // also large enough to hold integer part 
   char* ep = buf + sizeof(buf);
   double d = 0;
   int64_t frac_part = Round(std::modf(n, &d) * unit.pow10);
@@ -752,7 +752,7 @@ void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
       while (ep[-1] == '0') --ep;
       out->append(bp, ep - bp);
     }
-    out->append(unit.abbr.data(), unit.abbr.size());
+    out->append(unit.abbr.data(), unit.abbr.size()); 
   }
 }
 
@@ -763,8 +763,8 @@ void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
 //   form "72h3m0.5s". Leading zero units are omitted.  As a special
 //   case, durations less than one second format use a smaller unit
 //   (milli-, micro-, or nanoseconds) to ensure that the leading digit
-//   is non-zero.
-// Unlike Go, we format the zero duration as 0, with no unit.
+//   is non-zero. 
+// Unlike Go, we format the zero duration as 0, with no unit. 
 std::string FormatDuration(Duration d) {
   const Duration min_duration = Seconds(kint64min);
   if (d == min_duration) {
@@ -805,27 +805,27 @@ namespace {
 // A helper for ParseDuration() that parses a leading number from the given
 // string and stores the result in *int_part/*frac_part/*frac_scale.  The
 // given string pointer is modified to point to the first unconsumed char.
-bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part,
+bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part, 
                            int64_t* frac_part, int64_t* frac_scale) {
   *int_part = 0;
   *frac_part = 0;
   *frac_scale = 1;  // invariant: *frac_part < *frac_scale
   const char* start = *dpp;
-  for (; *dpp != ep; *dpp += 1) {
+  for (; *dpp != ep; *dpp += 1) { 
     const int d = **dpp - '0';  // contiguous digits
-    if (d < 0 || 10 <= d) break;
-
+    if (d < 0 || 10 <= d) break; 
+ 
     if (*int_part > kint64max / 10) return false;
     *int_part *= 10;
     if (*int_part > kint64max - d) return false;
     *int_part += d;
   }
   const bool int_part_empty = (*dpp == start);
-  if (*dpp == ep || **dpp != '.') return !int_part_empty;
-
-  for (*dpp += 1; *dpp != ep; *dpp += 1) {
+  if (*dpp == ep || **dpp != '.') return !int_part_empty; 
+ 
+  for (*dpp += 1; *dpp != ep; *dpp += 1) { 
     const int d = **dpp - '0';  // contiguous digits
-    if (d < 0 || 10 <= d) break;
+    if (d < 0 || 10 <= d) break; 
     if (*frac_scale <= kint64max / 10) {
       *frac_part *= 10;
       *frac_part += d;
@@ -839,55 +839,55 @@ bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part,
 // ns, us, ms, s, m, h) from the given string and stores the resulting unit
 // in "*unit".  The given string pointer is modified to point to the first
 // unconsumed char.
-bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) {
-  size_t size = end - *start;
-  switch (size) {
-    case 0:
-      return false;
-    default:
-      switch (**start) {
-        case 'n':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Nanoseconds(1);
-            return true;
-          }
-          break;
-        case 'u':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Microseconds(1);
-            return true;
-          }
-          break;
-        case 'm':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Milliseconds(1);
-            return true;
-          }
-          break;
-        default:
-          break;
-      }
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      switch (**start) {
-        case 's':
-          *unit = Seconds(1);
-          *start += 1;
-          return true;
-        case 'm':
-          *unit = Minutes(1);
-          *start += 1;
-          return true;
-        case 'h':
-          *unit = Hours(1);
-          *start += 1;
-          return true;
-        default:
-          return false;
-      }
+bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) { 
+  size_t size = end - *start; 
+  switch (size) { 
+    case 0: 
+      return false; 
+    default: 
+      switch (**start) { 
+        case 'n': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Nanoseconds(1); 
+            return true; 
+          } 
+          break; 
+        case 'u': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Microseconds(1); 
+            return true; 
+          } 
+          break; 
+        case 'm': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Milliseconds(1); 
+            return true; 
+          } 
+          break; 
+        default: 
+          break; 
+      } 
+      ABSL_FALLTHROUGH_INTENDED; 
+    case 1: 
+      switch (**start) { 
+        case 's': 
+          *unit = Seconds(1); 
+          *start += 1; 
+          return true; 
+        case 'm': 
+          *unit = Minutes(1); 
+          *start += 1; 
+          return true; 
+        case 'h': 
+          *unit = Hours(1); 
+          *start += 1; 
+          return true; 
+        default: 
+          return false; 
+      } 
   }
 }
 
@@ -898,38 +898,38 @@ bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) {
 //   a possibly signed sequence of decimal numbers, each with optional
 //   fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
 //   Valid time units are "ns", "us" "ms", "s", "m", "h".
-bool ParseDuration(absl::string_view dur_sv, Duration* d) {
+bool ParseDuration(absl::string_view dur_sv, Duration* d) { 
   int sign = 1;
-  if (absl::ConsumePrefix(&dur_sv, "-")) {
-    sign = -1;
-  } else {
-    absl::ConsumePrefix(&dur_sv, "+");
+  if (absl::ConsumePrefix(&dur_sv, "-")) { 
+    sign = -1; 
+  } else { 
+    absl::ConsumePrefix(&dur_sv, "+"); 
   }
-  if (dur_sv.empty()) return false;
+  if (dur_sv.empty()) return false; 
 
-  // Special case for a string of "0".
-  if (dur_sv == "0") {
+  // Special case for a string of "0". 
+  if (dur_sv == "0") { 
     *d = ZeroDuration();
     return true;
   }
 
-  if (dur_sv == "inf") {
+  if (dur_sv == "inf") { 
     *d = sign * InfiniteDuration();
     return true;
   }
 
-  const char* start = dur_sv.data();
-  const char* end = start + dur_sv.size();
-
+  const char* start = dur_sv.data(); 
+  const char* end = start + dur_sv.size(); 
+ 
   Duration dur;
-  while (start != end) {
+  while (start != end) { 
     int64_t int_part;
     int64_t frac_part;
     int64_t frac_scale;
     Duration unit;
-    if (!ConsumeDurationNumber(&start, end, &int_part, &frac_part,
-                               &frac_scale) ||
-        !ConsumeDurationUnit(&start, end, &unit)) {
+    if (!ConsumeDurationNumber(&start, end, &int_part, &frac_part, 
+                               &frac_scale) || 
+        !ConsumeDurationUnit(&start, end, &unit)) { 
       return false;
     }
     if (int_part != 0) dur += sign * int_part * unit;
@@ -940,7 +940,7 @@ bool ParseDuration(absl::string_view dur_sv, Duration* d) {
 }
 
 bool AbslParseFlag(absl::string_view text, Duration* dst, std::string*) {
-  return ParseDuration(text, dst);
+  return ParseDuration(text, dst); 
 }
 
 std::string AbslUnparseFlag(Duration d) { return FormatDuration(d); }
@@ -950,5 +950,5 @@ bool ParseFlag(const std::string& text, Duration* dst, std::string* ) {
 
 std::string UnparseFlag(Duration d) { return FormatDuration(d); }
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/format.cc b/contrib/restricted/abseil-cpp/absl/time/format.cc
index 4005fb704c..7a3e8fe1e1 100644
--- a/contrib/restricted/abseil-cpp/absl/time/format.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/format.cc
@@ -13,25 +13,25 @@
 // limitations under the License.
 
 #include <string.h>
-
+ 
 #include <cctype>
 #include <cstdint>
 
-#include "absl/strings/match.h"
-#include "absl/strings/string_view.h"
+#include "absl/strings/match.h" 
+#include "absl/strings/string_view.h" 
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 #include "absl/time/time.h"
 
 namespace cctz = absl::time_internal::cctz;
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
-ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez";
-ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez";
+ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez"; 
+ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez"; 
 
-ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z";
-ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z";
+ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z"; 
+ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z"; 
 
 namespace {
 
@@ -71,12 +71,12 @@ absl::Time Join(const cctz_parts& parts) {
 
 }  // namespace
 
-std::string FormatTime(absl::string_view format, absl::Time t,
+std::string FormatTime(absl::string_view format, absl::Time t, 
                        absl::TimeZone tz) {
-  if (t == absl::InfiniteFuture()) return std::string(kInfiniteFutureStr);
-  if (t == absl::InfinitePast()) return std::string(kInfinitePastStr);
+  if (t == absl::InfiniteFuture()) return std::string(kInfiniteFutureStr); 
+  if (t == absl::InfinitePast()) return std::string(kInfinitePastStr); 
   const auto parts = Split(t);
-  return cctz::detail::format(std::string(format), parts.sec, parts.fem,
+  return cctz::detail::format(std::string(format), parts.sec, parts.fem, 
                               cctz::time_zone(tz));
 }
 
@@ -88,50 +88,50 @@ std::string FormatTime(absl::Time t) {
   return absl::FormatTime(RFC3339_full, t, absl::LocalTimeZone());
 }
 
-bool ParseTime(absl::string_view format, absl::string_view input,
+bool ParseTime(absl::string_view format, absl::string_view input, 
                absl::Time* time, std::string* err) {
   return absl::ParseTime(format, input, absl::UTCTimeZone(), time, err);
 }
 
 // If the input string does not contain an explicit UTC offset, interpret
 // the fields with respect to the given TimeZone.
-bool ParseTime(absl::string_view format, absl::string_view input,
+bool ParseTime(absl::string_view format, absl::string_view input, 
                absl::TimeZone tz, absl::Time* time, std::string* err) {
-  auto strip_leading_space = [](absl::string_view* sv) {
-    while (!sv->empty()) {
-      if (!std::isspace(sv->front())) return;
-      sv->remove_prefix(1);
+  auto strip_leading_space = [](absl::string_view* sv) { 
+    while (!sv->empty()) { 
+      if (!std::isspace(sv->front())) return; 
+      sv->remove_prefix(1); 
     }
-  };
-
-  // Portable toolchains means we don't get nice constexpr here.
-  struct Literal {
-    const char* name;
-    size_t size;
-    absl::Time value;
-  };
-  static Literal literals[] = {
-      {kInfiniteFutureStr, strlen(kInfiniteFutureStr), InfiniteFuture()},
-      {kInfinitePastStr, strlen(kInfinitePastStr), InfinitePast()},
-  };
-  strip_leading_space(&input);
-  for (const auto& lit : literals) {
-    if (absl::StartsWith(input, absl::string_view(lit.name, lit.size))) {
-      absl::string_view tail = input;
-      tail.remove_prefix(lit.size);
-      strip_leading_space(&tail);
-      if (tail.empty()) {
-        *time = lit.value;
-        return true;
-      }
+  }; 
+
+  // Portable toolchains means we don't get nice constexpr here. 
+  struct Literal { 
+    const char* name; 
+    size_t size; 
+    absl::Time value; 
+  }; 
+  static Literal literals[] = { 
+      {kInfiniteFutureStr, strlen(kInfiniteFutureStr), InfiniteFuture()}, 
+      {kInfinitePastStr, strlen(kInfinitePastStr), InfinitePast()}, 
+  }; 
+  strip_leading_space(&input); 
+  for (const auto& lit : literals) { 
+    if (absl::StartsWith(input, absl::string_view(lit.name, lit.size))) { 
+      absl::string_view tail = input; 
+      tail.remove_prefix(lit.size); 
+      strip_leading_space(&tail); 
+      if (tail.empty()) { 
+        *time = lit.value; 
+        return true; 
+      } 
     }
   }
 
   std::string error;
   cctz_parts parts;
-  const bool b =
-      cctz::detail::parse(std::string(format), std::string(input),
-                          cctz::time_zone(tz), &parts.sec, &parts.fem, &error);
+  const bool b = 
+      cctz::detail::parse(std::string(format), std::string(input), 
+                          cctz::time_zone(tz), &parts.sec, &parts.fem, &error); 
   if (b) {
     *time = Join(parts);
   } else if (err != nullptr) {
@@ -142,7 +142,7 @@ bool ParseTime(absl::string_view format, absl::string_view input,
 
 // Functions required to support absl::Time flags.
 bool AbslParseFlag(absl::string_view text, absl::Time* t, std::string* error) {
-  return absl::ParseTime(RFC3339_full, text, absl::UTCTimeZone(), t, error);
+  return absl::ParseTime(RFC3339_full, text, absl::UTCTimeZone(), t, error); 
 }
 
 std::string AbslUnparseFlag(absl::Time t) {
@@ -156,5 +156,5 @@ std::string UnparseFlag(absl::Time t) {
   return absl::FormatTime(RFC3339_full, t, absl::UTCTimeZone());
 }
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time.h
index d47ff86fe4..18bf6230ba 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time.h
@@ -15,11 +15,11 @@
 #ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
 #define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time_detail.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -326,7 +326,7 @@ using detail::get_yearday;
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
index 8aadde57ca..a27ed73a96 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -20,8 +20,8 @@
 #include <ostream>
 #include <type_traits>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 // Disable constexpr support unless we are in C++14 mode.
 #if __cpp_constexpr >= 201304 || (defined(_MSC_VER) && _MSC_VER >= 1910)
 #define CONSTEXPR_D constexpr  // data
@@ -34,7 +34,7 @@
 #endif
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -56,8 +56,8 @@ using second_t = std::int_fast8_t;  // [0:59]
 
 // Normalized civil-time fields: Y-M-D HH:MM:SS.
 struct fields {
-  CONSTEXPR_M fields(year_t year, month_t month, day_t day, hour_t hour,
-                     minute_t minute, second_t second)
+  CONSTEXPR_M fields(year_t year, month_t month, day_t day, hour_t hour, 
+                     minute_t minute, second_t second) 
       : y(year), m(month), d(day), hh(hour), mm(minute), ss(second) {}
   std::int_least64_t y;
   std::int_least8_t m;
@@ -104,69 +104,69 @@ CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
   return k_days_per_month[m] + (m == 2 && is_leap_year(y));
 }
 
-CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh,
-                         minute_t mm, second_t ss) noexcept {
-  year_t ey = y % 400;
-  const year_t oey = ey;
-  ey += (cd / 146097) * 400;
+CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh, 
+                         minute_t mm, second_t ss) noexcept { 
+  year_t ey = y % 400; 
+  const year_t oey = ey; 
+  ey += (cd / 146097) * 400; 
   cd %= 146097;
   if (cd < 0) {
-    ey -= 400;
+    ey -= 400; 
     cd += 146097;
   }
-  ey += (d / 146097) * 400;
+  ey += (d / 146097) * 400; 
   d = d % 146097 + cd;
   if (d > 0) {
     if (d > 146097) {
-      ey += 400;
+      ey += 400; 
       d -= 146097;
     }
   } else {
     if (d > -365) {
       // We often hit the previous year when stepping a civil time backwards,
       // so special case it to avoid counting up by 100/4/1-year chunks.
-      ey -= 1;
-      d += days_per_year(ey, m);
+      ey -= 1; 
+      d += days_per_year(ey, m); 
     } else {
-      ey -= 400;
+      ey -= 400; 
       d += 146097;
     }
   }
   if (d > 365) {
-    for (;;) {
-      int n = days_per_century(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_century(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ey += 100;
+      ey += 100; 
     }
-    for (;;) {
-      int n = days_per_4years(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_4years(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ey += 4;
+      ey += 4; 
     }
-    for (;;) {
-      int n = days_per_year(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_year(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ++ey;
+      ++ey; 
     }
   }
   if (d > 28) {
-    for (;;) {
-      int n = days_per_month(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_month(ey, m); 
+      if (d <= n) break; 
       d -= n;
       if (++m > 12) {
-        ++ey;
+        ++ey; 
         m = 1;
       }
     }
   }
-  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss);
+  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss); 
 }
-CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh,
-                         minute_t mm, second_t ss) noexcept {
+CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh, 
+                         minute_t mm, second_t ss) noexcept { 
   if (m != 12) {
     y += m / 12;
     m %= 12;
@@ -177,8 +177,8 @@ CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh,
   }
   return n_day(y, static_cast<month_t>(m), d, cd, hh, mm, ss);
 }
-CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd, diff_t hh,
-                          minute_t mm, second_t ss) noexcept {
+CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd, diff_t hh, 
+                          minute_t mm, second_t ss) noexcept { 
   cd += hh / 24;
   hh %= 24;
   if (hh < 0) {
@@ -277,8 +277,8 @@ CONSTEXPR_F diff_t ymd_ord(year_t y, month_t m, day_t d) noexcept {
 // yet the difference between two such extreme values may actually be
 // small, so we take a little care to avoid overflow when possible by
 // exploiting the 146097-day cycle.
-CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1, year_t y2,
-                                  month_t m2, day_t d2) noexcept {
+CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1, year_t y2, 
+                                  month_t m2, day_t d2) noexcept { 
   const diff_t a_c4_off = y1 % 400;
   const diff_t b_c4_off = y2 % 400;
   diff_t c4_diff = (y1 - a_c4_off) - (y2 - b_c4_off);
@@ -318,7 +318,7 @@ CONSTEXPR_F diff_t difference(second_tag, fields f1, fields f2) noexcept {
 ////////////////////////////////////////////////////////////////////////
 
 // Aligns the (normalized) fields struct to the indicated field.
-CONSTEXPR_F fields align(second_tag, fields f) noexcept { return f; }
+CONSTEXPR_F fields align(second_tag, fields f) noexcept { return f; } 
 CONSTEXPR_F fields align(minute_tag, fields f) noexcept {
   return fields{f.y, f.m, f.d, f.hh, f.mm, 0};
 }
@@ -397,11 +397,11 @@ class civil_time {
       : civil_time(ct.f_) {}
 
   // Factories for the maximum/minimum representable civil_time.
-  static CONSTEXPR_F civil_time(max)() {
+  static CONSTEXPR_F civil_time(max)() { 
     const auto max_year = (std::numeric_limits<std::int_least64_t>::max)();
     return civil_time(max_year, 12, 31, 23, 59, 59);
   }
-  static CONSTEXPR_F civil_time(min)() {
+  static CONSTEXPR_F civil_time(min)() { 
     const auto min_year = (std::numeric_limits<std::int_least64_t>::min)();
     return civil_time(min_year, 1, 1, 0, 0, 0);
   }
@@ -421,13 +421,13 @@ class civil_time {
   CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept {
     return *this = *this - n;
   }
-  CONSTEXPR_M civil_time& operator++() noexcept { return *this += 1; }
+  CONSTEXPR_M civil_time& operator++() noexcept { return *this += 1; } 
   CONSTEXPR_M civil_time operator++(int) noexcept {
     const civil_time a = *this;
     ++*this;
     return a;
   }
-  CONSTEXPR_M civil_time& operator--() noexcept { return *this -= 1; }
+  CONSTEXPR_M civil_time& operator--() noexcept { return *this -= 1; } 
   CONSTEXPR_M civil_time operator--(int) noexcept {
     const civil_time a = *this;
     --*this;
@@ -486,17 +486,17 @@ using civil_second = civil_time<second_tag>;
 template <typename T1, typename T2>
 CONSTEXPR_F bool operator<(const civil_time<T1>& lhs,
                            const civil_time<T2>& rhs) noexcept {
-  return (
-      lhs.year() < rhs.year() ||
-      (lhs.year() == rhs.year() &&
-       (lhs.month() < rhs.month() ||
-        (lhs.month() == rhs.month() &&
-         (lhs.day() < rhs.day() || (lhs.day() == rhs.day() &&
-                                    (lhs.hour() < rhs.hour() ||
-                                     (lhs.hour() == rhs.hour() &&
-                                      (lhs.minute() < rhs.minute() ||
-                                       (lhs.minute() == rhs.minute() &&
-                                        (lhs.second() < rhs.second())))))))))));
+  return ( 
+      lhs.year() < rhs.year() || 
+      (lhs.year() == rhs.year() && 
+       (lhs.month() < rhs.month() || 
+        (lhs.month() == rhs.month() && 
+         (lhs.day() < rhs.day() || (lhs.day() == rhs.day() && 
+                                    (lhs.hour() < rhs.hour() || 
+                                     (lhs.hour() == rhs.hour() && 
+                                      (lhs.minute() < rhs.minute() || 
+                                       (lhs.minute() == rhs.minute() && 
+                                        (lhs.second() < rhs.second()))))))))))); 
 }
 template <typename T1, typename T2>
 CONSTEXPR_F bool operator<=(const civil_time<T1>& lhs,
@@ -618,7 +618,7 @@ std::ostream& operator<<(std::ostream& os, weekday wd);
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #undef CONSTEXPR_M
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h
index 6e382dc6c9..bef00a51f1 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h
@@ -26,11 +26,11 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -186,20 +186,20 @@ class time_zone {
   bool next_transition(const time_point<seconds>& tp,
                        civil_transition* trans) const;
   template <typename D>
-  bool next_transition(const time_point<D>& tp, civil_transition* trans) const {
+  bool next_transition(const time_point<D>& tp, civil_transition* trans) const { 
     return next_transition(detail::split_seconds(tp).first, trans);
   }
   bool prev_transition(const time_point<seconds>& tp,
                        civil_transition* trans) const;
   template <typename D>
-  bool prev_transition(const time_point<D>& tp, civil_transition* trans) const {
+  bool prev_transition(const time_point<D>& tp, civil_transition* trans) const { 
     return prev_transition(detail::split_seconds(tp).first, trans);
   }
 
   // version() and description() provide additional information about the
   // time zone. The content of each of the returned strings is unspecified,
   // however, when the IANA Time Zone Database is the underlying data source
-  // the version() string will be in the familar form (e.g, "2018e") or
+  // the version() string will be in the familar form (e.g, "2018e") or 
   // empty when unavailable.
   //
   // Note: These functions are for informational or testing purposes only.
@@ -210,7 +210,7 @@ class time_zone {
   friend bool operator==(time_zone lhs, time_zone rhs) {
     return &lhs.effective_impl() == &rhs.effective_impl();
   }
-  friend bool operator!=(time_zone lhs, time_zone rhs) { return !(lhs == rhs); }
+  friend bool operator!=(time_zone lhs, time_zone rhs) { return !(lhs == rhs); } 
 
   template <typename H>
   friend H AbslHashValue(H h, time_zone tz) {
@@ -296,7 +296,7 @@ bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
 //   - %E#f - Fractional seconds with # digits of precision
 //   - %E*f - Fractional seconds with full precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // Note that %E0S behaves like %S, and %E0f produces no characters. In
 // contrast %E*f always produces at least one digit, which may be '0'.
@@ -326,8 +326,8 @@ inline std::string format(const std::string& fmt, const time_point<D>& tp,
 // returns the corresponding time_point. Uses strftime()-like formatting
 // options, with the same extensions as cctz::format(), but with the
 // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+// and %E*z also accept the same inputs, which (along with %z) includes 
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'. 
 //
 // %Y consumes as many numeric characters as it can, so the matching data
 // should always be terminated with a non-numeric. %E4Y always consumes
@@ -453,7 +453,7 @@ inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/zone_info_source.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/zone_info_source.h
index 012eb4ec30..558d5c1fcd 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/zone_info_source.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -20,10 +20,10 @@
 #include <memory>
 #include <string>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -33,21 +33,21 @@ class ZoneInfoSource {
   virtual ~ZoneInfoSource();
 
   virtual std::size_t Read(void* ptr, std::size_t size) = 0;  // like fread()
-  virtual int Skip(std::size_t offset) = 0;                   // like fseek()
+  virtual int Skip(std::size_t offset) = 0;                   // like fseek() 
 
   // Until the zoneinfo data supports versioning information, we provide
   // a way for a ZoneInfoSource to indicate it out-of-band.  The default
-  // implementation returns an empty string.
+  // implementation returns an empty string. 
   virtual std::string Version() const;
 };
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz_extension {
 
@@ -57,8 +57,8 @@ namespace cctz_extension {
 using ZoneInfoSourceFactory =
     std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> (*)(
         const std::string&,
-        const std::function<std::unique_ptr<
-            absl::time_internal::cctz::ZoneInfoSource>(const std::string&)>&);
+        const std::function<std::unique_ptr< 
+            absl::time_internal::cctz::ZoneInfoSource>(const std::string&)>&); 
 
 // The user can control the mapping of zone names to zoneinfo data by
 // providing a definition for cctz_extension::zone_info_source_factory.
@@ -96,7 +96,7 @@ extern ZoneInfoSourceFactory zone_info_source_factory;
 
 }  // namespace cctz_extension
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc
index 0b07e397e5..94f06f9e03 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc
@@ -18,10 +18,10 @@
 #include <ostream>
 #include <sstream>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 namespace detail {
@@ -90,5 +90,5 @@ std::ostream& operator<<(std::ostream& os, weekday wd) {
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc
index f2b3294ef7..a8fd9c71cd 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc
@@ -20,10 +20,10 @@
 #include <cstring>
 #include <string>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -62,9 +62,9 @@ bool FixedOffsetFromName(const std::string& name, seconds* offset) {
   const char* const ep = kFixedZonePrefix + prefix_len;
   if (name.size() != prefix_len + 9)  // <prefix>+99:99:99
     return false;
-  if (!std::equal(kFixedZonePrefix, ep, name.begin())) return false;
+  if (!std::equal(kFixedZonePrefix, ep, name.begin())) return false; 
   const char* np = name.data() + prefix_len;
-  if (np[0] != '+' && np[0] != '-') return false;
+  if (np[0] != '+' && np[0] != '-') return false; 
   if (np[3] != ':' || np[6] != ':')  // see note below about large offsets
     return false;
 
@@ -89,29 +89,29 @@ std::string FixedOffsetToName(const seconds& offset) {
     // offsets and to (somewhat) limit the total number of zones.
     return "UTC";
   }
-  int offset_seconds = static_cast<int>(offset.count());
-  const char sign = (offset_seconds < 0 ? '-' : '+');
-  int offset_minutes = offset_seconds / 60;
-  offset_seconds %= 60;
+  int offset_seconds = static_cast<int>(offset.count()); 
+  const char sign = (offset_seconds < 0 ? '-' : '+'); 
+  int offset_minutes = offset_seconds / 60; 
+  offset_seconds %= 60; 
   if (sign == '-') {
-    if (offset_seconds > 0) {
-      offset_seconds -= 60;
-      offset_minutes += 1;
+    if (offset_seconds > 0) { 
+      offset_seconds -= 60; 
+      offset_minutes += 1; 
     }
-    offset_seconds = -offset_seconds;
-    offset_minutes = -offset_minutes;
+    offset_seconds = -offset_seconds; 
+    offset_minutes = -offset_minutes; 
   }
-  int offset_hours = offset_minutes / 60;
-  offset_minutes %= 60;
+  int offset_hours = offset_minutes / 60; 
+  offset_minutes %= 60; 
   const std::size_t prefix_len = sizeof(kFixedZonePrefix) - 1;
   char buf[prefix_len + sizeof("-24:00:00")];
   char* ep = std::copy(kFixedZonePrefix, kFixedZonePrefix + prefix_len, buf);
   *ep++ = sign;
-  ep = Format02d(ep, offset_hours);
+  ep = Format02d(ep, offset_hours); 
   *ep++ = ':';
-  ep = Format02d(ep, offset_minutes);
+  ep = Format02d(ep, offset_minutes); 
   *ep++ = ':';
-  ep = Format02d(ep, offset_seconds);
+  ep = Format02d(ep, offset_seconds); 
   *ep++ = '\0';
   assert(ep == buf + sizeof(buf));
   return buf;
@@ -136,5 +136,5 @@ std::string FixedOffsetToAbbr(const seconds& offset) {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.h
index e74a0bbd9d..d237a7bce6 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.h
@@ -17,11 +17,11 @@
 
 #include <string>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -46,7 +46,7 @@ std::string FixedOffsetToAbbr(const seconds& offset);
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc
index d8cb047425..4dc047560e 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc
@@ -13,18 +13,18 @@
 //   limitations under the License.
 
 #if !defined(HAS_STRPTIME)
-#if !defined(_MSC_VER) && !defined(__MINGW32__)
-#define HAS_STRPTIME 1  // assume everyone has strptime() except windows
-#endif
+#if !defined(_MSC_VER) && !defined(__MINGW32__) 
+#define HAS_STRPTIME 1  // assume everyone has strptime() except windows 
 #endif
+#endif 
 
 #if defined(HAS_STRPTIME) && HAS_STRPTIME
-#if !defined(_XOPEN_SOURCE)
-#define _XOPEN_SOURCE  // Definedness suffices for strptime.
-#endif
+#if !defined(_XOPEN_SOURCE) 
+#define _XOPEN_SOURCE  // Definedness suffices for strptime. 
 #endif
+#endif 
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 // Include time.h directly since, by C++ standards, ctime doesn't have to
@@ -49,7 +49,7 @@
 #include "time_zone_if.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 namespace detail {
@@ -67,48 +67,48 @@ char* strptime(const char* s, const char* fmt, std::tm* tm) {
 }
 #endif
 
-// Convert a cctz::weekday to a tm_wday value (0-6, Sunday = 0).
-int ToTmWday(weekday wd) {
-  switch (wd) {
-    case weekday::sunday:
-      return 0;
-    case weekday::monday:
-      return 1;
-    case weekday::tuesday:
-      return 2;
-    case weekday::wednesday:
-      return 3;
-    case weekday::thursday:
-      return 4;
-    case weekday::friday:
-      return 5;
-    case weekday::saturday:
-      return 6;
-  }
-  return 0; /*NOTREACHED*/
-}
-
-// Convert a tm_wday value (0-6, Sunday = 0) to a cctz::weekday.
-weekday FromTmWday(int tm_wday) {
-  switch (tm_wday) {
-    case 0:
-      return weekday::sunday;
-    case 1:
-      return weekday::monday;
-    case 2:
-      return weekday::tuesday;
-    case 3:
-      return weekday::wednesday;
-    case 4:
-      return weekday::thursday;
-    case 5:
-      return weekday::friday;
-    case 6:
-      return weekday::saturday;
-  }
-  return weekday::sunday; /*NOTREACHED*/
-}
-
+// Convert a cctz::weekday to a tm_wday value (0-6, Sunday = 0). 
+int ToTmWday(weekday wd) { 
+  switch (wd) { 
+    case weekday::sunday: 
+      return 0; 
+    case weekday::monday: 
+      return 1; 
+    case weekday::tuesday: 
+      return 2; 
+    case weekday::wednesday: 
+      return 3; 
+    case weekday::thursday: 
+      return 4; 
+    case weekday::friday: 
+      return 5; 
+    case weekday::saturday: 
+      return 6; 
+  } 
+  return 0; /*NOTREACHED*/ 
+} 
+ 
+// Convert a tm_wday value (0-6, Sunday = 0) to a cctz::weekday. 
+weekday FromTmWday(int tm_wday) { 
+  switch (tm_wday) { 
+    case 0: 
+      return weekday::sunday; 
+    case 1: 
+      return weekday::monday; 
+    case 2: 
+      return weekday::tuesday; 
+    case 3: 
+      return weekday::wednesday; 
+    case 4: 
+      return weekday::thursday; 
+    case 5: 
+      return weekday::friday; 
+    case 6: 
+      return weekday::saturday; 
+  } 
+  return weekday::sunday; /*NOTREACHED*/ 
+} 
+ 
 std::tm ToTM(const time_zone::absolute_lookup& al) {
   std::tm tm{};
   tm.tm_sec = al.cs.second();
@@ -126,19 +126,19 @@ std::tm ToTM(const time_zone::absolute_lookup& al) {
     tm.tm_year = static_cast<int>(al.cs.year() - 1900);
   }
 
-  tm.tm_wday = ToTmWday(get_weekday(al.cs));
+  tm.tm_wday = ToTmWday(get_weekday(al.cs)); 
   tm.tm_yday = get_yearday(al.cs) - 1;
   tm.tm_isdst = al.is_dst ? 1 : 0;
   return tm;
 }
 
-// Returns the week of the year [0:53] given a civil day and the day on
-// which weeks are defined to start.
-int ToWeek(const civil_day& cd, weekday week_start) {
-  const civil_day d(cd.year() % 400, cd.month(), cd.day());
-  return static_cast<int>((d - prev_weekday(civil_year(d), week_start)) / 7);
-}
-
+// Returns the week of the year [0:53] given a civil day and the day on 
+// which weeks are defined to start. 
+int ToWeek(const civil_day& cd, weekday week_start) { 
+  const civil_day d(cd.year() % 400, cd.month(), cd.day()); 
+  return static_cast<int>((d - prev_weekday(civil_year(d), week_start)) / 7); 
+} 
+ 
 const char kDigits[] = "0123456789";
 
 // Formats a 64-bit integer in the given field width.  Note that it is up
@@ -216,7 +216,7 @@ void FormatTM(std::string* out, const std::string& fmt, const std::tm& tm) {
   // strftime(3) returns the number of characters placed in the output
   // array (which may be 0 characters).  It also returns 0 to indicate
   // an error, like the array wasn't large enough.  To accommodate this,
-  // the following code grows the buffer size from 2x the format string
+  // the following code grows the buffer size from 2x the format string 
   // length up to 32x.
   for (std::size_t i = 2; i != 32; i *= 2) {
     std::size_t buf_size = fmt.size() * i;
@@ -317,7 +317,7 @@ const std::int_fast64_t kExp10[kDigits10_64 + 1] = {
 //   - %E#S - Seconds with # digits of fractional precision
 //   - %E*S - Seconds with full fractional precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
 // handled internally for performance reasons.  strftime(3) is slow due to
@@ -382,7 +382,7 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
     if (cur == end || (cur - percent) % 2 == 0) continue;
 
     // Simple specifiers that we handle ourselves.
-    if (strchr("YmdeUuWwHMSzZs%", *cur)) {
+    if (strchr("YmdeUuWwHMSzZs%", *cur)) { 
       if (cur - 1 != pending) {
         FormatTM(&result, std::string(pending, cur - 1), tm);
       }
@@ -403,22 +403,22 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
           if (*cur == 'e' && *bp == '0') *bp = ' ';  // for Windows
           result.append(bp, static_cast<std::size_t>(ep - bp));
           break;
-        case 'U':
-          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::sunday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'u':
-          bp = Format64(ep, 0, tm.tm_wday ? tm.tm_wday : 7);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'W':
-          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::monday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'w':
-          bp = Format64(ep, 0, tm.tm_wday);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
+        case 'U': 
+          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::sunday)); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'u': 
+          bp = Format64(ep, 0, tm.tm_wday ? tm.tm_wday : 7); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'W': 
+          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::monday)); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'w': 
+          bp = Format64(ep, 0, tm.tm_wday); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
         case 'H':
           bp = Format02d(ep, al.cs.hour());
           result.append(bp, static_cast<std::size_t>(ep - bp));
@@ -492,14 +492,14 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
     if (*cur != 'E' || ++cur == end) continue;
 
     // Format our extensions.
-    if (*cur == 'T') {
-      // Formats %ET.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
-      result.append("T");
-      pending = ++cur;
-    } else if (*cur == 'z') {
+    if (*cur == 'T') { 
+      // Formats %ET. 
+      if (cur - 2 != pending) { 
+        FormatTM(&result, std::string(pending, cur - 2), tm); 
+      } 
+      result.append("T"); 
+      pending = ++cur; 
+    } else if (*cur == 'z') { 
       // Formats %Ez.
       if (cur - 2 != pending) {
         FormatTM(&result, std::string(pending, cur - 2), tm);
@@ -555,9 +555,9 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
           bp = ep;
           if (n > 0) {
             if (n > kDigits10_64) n = kDigits10_64;
-            bp = Format64(bp, n,
-                          (n > 15) ? fs.count() * kExp10[n - 15]
-                                   : fs.count() / kExp10[15 - n]);
+            bp = Format64(bp, n, 
+                          (n > 15) ? fs.count() * kExp10[n - 15] 
+                                   : fs.count() / kExp10[15 - n]); 
             if (*np == 'S') *--bp = '.';
           }
           if (*np == 'S') bp = Format02d(bp, al.cs.second());
@@ -602,7 +602,7 @@ const char* ParseOffset(const char* dp, const char* mode, int* offset) {
       } else {
         dp = nullptr;
       }
-    } else if (first == 'Z' || first == 'z') {  // Zulu
+    } else if (first == 'Z' || first == 'z') {  // Zulu 
       *offset = 0;
     } else {
       dp = nullptr;
@@ -653,32 +653,32 @@ const char* ParseTM(const char* dp, const char* fmt, std::tm* tm) {
   return dp;
 }
 
-// Sets year, tm_mon and tm_mday given the year, week_num, and tm_wday,
-// and the day on which weeks are defined to start.  Returns false if year
-// would need to move outside its bounds.
-bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) {
-  const civil_year y(*year % 400);
-  civil_day cd = prev_weekday(y, week_start);  // week 0
-  cd = next_weekday(cd - 1, FromTmWday(tm->tm_wday)) + (week_num * 7);
-  if (const year_t shift = cd.year() - y.year()) {
-    if (shift > 0) {
-      if (*year > std::numeric_limits<year_t>::max() - shift) return false;
-    } else {
-      if (*year < std::numeric_limits<year_t>::min() - shift) return false;
-    }
-    *year += shift;
-  }
-  tm->tm_mon = cd.month() - 1;
-  tm->tm_mday = cd.day();
-  return true;
-}
-
+// Sets year, tm_mon and tm_mday given the year, week_num, and tm_wday, 
+// and the day on which weeks are defined to start.  Returns false if year 
+// would need to move outside its bounds. 
+bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) { 
+  const civil_year y(*year % 400); 
+  civil_day cd = prev_weekday(y, week_start);  // week 0 
+  cd = next_weekday(cd - 1, FromTmWday(tm->tm_wday)) + (week_num * 7); 
+  if (const year_t shift = cd.year() - y.year()) { 
+    if (shift > 0) { 
+      if (*year > std::numeric_limits<year_t>::max() - shift) return false; 
+    } else { 
+      if (*year < std::numeric_limits<year_t>::min() - shift) return false; 
+    } 
+    *year += shift; 
+  } 
+  tm->tm_mon = cd.month() - 1; 
+  tm->tm_mday = cd.day(); 
+  return true; 
+} 
+ 
 }  // namespace
 
 // Uses strptime(3) to parse the given input.  Supports the same extended
 // format specifiers as format(), although %E#S and %E*S are treated
 // identically (and similarly for %E#f and %E*f).  %Ez and %E*z also accept
-// the same inputs. %ET accepts either 'T' or 't'.
+// the same inputs. %ET accepts either 'T' or 't'. 
 //
 // The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
 // handled internally so that we can normally avoid strptime() altogether
@@ -722,8 +722,8 @@ bool parse(const std::string& format, const std::string& input,
   const char* fmt = format.c_str();  // NUL terminated
   bool twelve_hour = false;
   bool afternoon = false;
-  int week_num = -1;
-  weekday week_start = weekday::sunday;
+  int week_num = -1; 
+  weekday week_start = weekday::sunday; 
 
   bool saw_percent_s = false;
   std::int_fast64_t percent_s = 0;
@@ -762,28 +762,28 @@ bool parse(const std::string& format, const std::string& input,
       case 'm':
         data = ParseInt(data, 2, 1, 12, &tm.tm_mon);
         if (data != nullptr) tm.tm_mon -= 1;
-        week_num = -1;
+        week_num = -1; 
         continue;
       case 'd':
       case 'e':
         data = ParseInt(data, 2, 1, 31, &tm.tm_mday);
-        week_num = -1;
-        continue;
-      case 'U':
-        data = ParseInt(data, 0, 0, 53, &week_num);
-        week_start = weekday::sunday;
-        continue;
-      case 'W':
-        data = ParseInt(data, 0, 0, 53, &week_num);
-        week_start = weekday::monday;
-        continue;
-      case 'u':
-        data = ParseInt(data, 0, 1, 7, &tm.tm_wday);
-        if (data != nullptr) tm.tm_wday %= 7;
-        continue;
-      case 'w':
-        data = ParseInt(data, 0, 0, 6, &tm.tm_wday);
+        week_num = -1; 
         continue;
+      case 'U': 
+        data = ParseInt(data, 0, 0, 53, &week_num); 
+        week_start = weekday::sunday; 
+        continue; 
+      case 'W': 
+        data = ParseInt(data, 0, 0, 53, &week_num); 
+        week_start = weekday::monday; 
+        continue; 
+      case 'u': 
+        data = ParseInt(data, 0, 1, 7, &tm.tm_wday); 
+        if (data != nullptr) tm.tm_wday %= 7; 
+        continue; 
+      case 'w': 
+        data = ParseInt(data, 0, 0, 6, &tm.tm_wday); 
+        continue; 
       case 'H':
         data = ParseInt(data, 2, 0, 23, &tm.tm_hour);
         twelve_hour = false;
@@ -813,9 +813,9 @@ bool parse(const std::string& format, const std::string& input,
         data = ParseZone(data, &zone);
         continue;
       case 's':
-        data =
-            ParseInt(data, 0, std::numeric_limits<std::int_fast64_t>::min(),
-                     std::numeric_limits<std::int_fast64_t>::max(), &percent_s);
+        data = 
+            ParseInt(data, 0, std::numeric_limits<std::int_fast64_t>::min(), 
+                     std::numeric_limits<std::int_fast64_t>::max(), &percent_s); 
         if (data != nullptr) saw_percent_s = true;
         continue;
       case ':':
@@ -832,15 +832,15 @@ bool parse(const std::string& format, const std::string& input,
         data = (*data == '%' ? data + 1 : nullptr);
         continue;
       case 'E':
-        if (fmt[0] == 'T') {
-          if (*data == 'T' || *data == 't') {
-            ++data;
-            ++fmt;
-          } else {
-            data = nullptr;
-          }
-          continue;
-        }
+        if (fmt[0] == 'T') { 
+          if (*data == 'T' || *data == 't') { 
+            ++data; 
+            ++fmt; 
+          } else { 
+            data = nullptr; 
+          } 
+          continue; 
+        } 
         if (fmt[0] == 'z' || (fmt[0] == '*' && fmt[1] == 'z')) {
           data = ParseOffset(data, ":", &offset);
           if (data != nullptr) saw_offset = true;
@@ -938,7 +938,7 @@ bool parse(const std::string& format, const std::string& input,
   // Skip any remaining whitespace.
   while (std::isspace(*data)) ++data;
 
-  // parse() must consume the entire input string.
+  // parse() must consume the entire input string. 
   if (*data != '\0') {
     if (err != nullptr) *err = "Illegal trailing data in input string";
     return false;
@@ -973,14 +973,14 @@ bool parse(const std::string& format, const std::string& input,
     year += 1900;
   }
 
-  // Compute year, tm.tm_mon and tm.tm_mday if we parsed a week number.
-  if (week_num != -1) {
-    if (!FromWeek(week_num, week_start, &year, &tm)) {
-      if (err != nullptr) *err = "Out-of-range field";
-      return false;
-    }
-  }
-
+  // Compute year, tm.tm_mon and tm.tm_mday if we parsed a week number. 
+  if (week_num != -1) { 
+    if (!FromWeek(week_num, week_start, &year, &tm)) { 
+      if (err != nullptr) *err = "Out-of-range field"; 
+      return false; 
+    } 
+  } 
+ 
   const int month = tm.tm_mon + 1;
   civil_second cs(year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
 
@@ -1025,5 +1025,5 @@ bool parse(const std::string& format, const std::string& input,
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.cc
index 0319b2f98e..6b985b588d 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.cc
@@ -13,13 +13,13 @@
 //   limitations under the License.
 
 #include "time_zone_if.h"
-
-#include "absl/base/config.h"
+ 
+#include "absl/base/config.h" 
 #include "time_zone_info.h"
 #include "time_zone_libc.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -41,5 +41,5 @@ TimeZoneIf::~TimeZoneIf() {}
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.h
index 7d3e42d3cd..79d71f09c2 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.h
@@ -20,12 +20,12 @@
 #include <memory>
 #include <string>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -40,7 +40,7 @@ class TimeZoneIf {
 
   virtual time_zone::absolute_lookup BreakTime(
       const time_point<seconds>& tp) const = 0;
-  virtual time_zone::civil_lookup MakeTime(const civil_second& cs) const = 0;
+  virtual time_zone::civil_lookup MakeTime(const civil_second& cs) const = 0; 
 
   virtual bool NextTransition(const time_point<seconds>& tp,
                               time_zone::civil_transition* trans) const = 0;
@@ -60,18 +60,18 @@ class TimeZoneIf {
 // (That is, that they share an epoch, which is required since C++20.)
 inline std::int_fast64_t ToUnixSeconds(const time_point<seconds>& tp) {
   return (tp - std::chrono::time_point_cast<seconds>(
-                   std::chrono::system_clock::from_time_t(0)))
-      .count();
+                   std::chrono::system_clock::from_time_t(0))) 
+      .count(); 
 }
 inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t) {
   return std::chrono::time_point_cast<seconds>(
-             std::chrono::system_clock::from_time_t(0)) +
-         seconds(t);
+             std::chrono::system_clock::from_time_t(0)) + 
+         seconds(t); 
 }
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.cc
index f34e3aec84..f40b0220a1 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.cc
@@ -15,17 +15,17 @@
 #include "time_zone_impl.h"
 
 #include <deque>
-#include <memory>
+#include <memory> 
 #include <mutex>
 #include <string>
 #include <unordered_map>
 #include <utility>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "time_zone_fixed.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -46,19 +46,19 @@ std::mutex& TimeZoneMutex() {
 
 }  // namespace
 
-time_zone time_zone::Impl::UTC() { return time_zone(UTCImpl()); }
+time_zone time_zone::Impl::UTC() { return time_zone(UTCImpl()); } 
 
 bool time_zone::Impl::LoadTimeZone(const std::string& name, time_zone* tz) {
-  const Impl* const utc_impl = UTCImpl();
+  const Impl* const utc_impl = UTCImpl(); 
 
-  // Check for UTC (which is never a key in time_zone_map).
+  // Check for UTC (which is never a key in time_zone_map). 
   auto offset = seconds::zero();
   if (FixedOffsetFromName(name, &offset) && offset == seconds::zero()) {
     *tz = time_zone(utc_impl);
     return true;
   }
 
-  // Check whether the time zone has already been loaded.
+  // Check whether the time zone has already been loaded. 
   {
     std::lock_guard<std::mutex> lock(TimeZoneMutex());
     if (time_zone_map != nullptr) {
@@ -70,15 +70,15 @@ bool time_zone::Impl::LoadTimeZone(const std::string& name, time_zone* tz) {
     }
   }
 
-  // Load the new time zone (outside the lock).
-  std::unique_ptr<const Impl> new_impl(new Impl(name));
-
-  // Add the new time zone to the map.
+  // Load the new time zone (outside the lock). 
+  std::unique_ptr<const Impl> new_impl(new Impl(name)); 
+ 
+  // Add the new time zone to the map. 
   std::lock_guard<std::mutex> lock(TimeZoneMutex());
   if (time_zone_map == nullptr) time_zone_map = new TimeZoneImplByName;
   const Impl*& impl = (*time_zone_map)[name];
-  if (impl == nullptr) {  // this thread won any load race
-    impl = new_impl->zone_ ? new_impl.release() : utc_impl;
+  if (impl == nullptr) {  // this thread won any load race 
+    impl = new_impl->zone_ ? new_impl.release() : utc_impl; 
   }
   *tz = time_zone(impl);
   return impl != utc_impl;
@@ -99,15 +99,15 @@ void time_zone::Impl::ClearTimeZoneMapTestOnly() {
   }
 }
 
-time_zone::Impl::Impl(const std::string& name)
-    : name_(name), zone_(TimeZoneIf::Load(name_)) {}
+time_zone::Impl::Impl(const std::string& name) 
+    : name_(name), zone_(TimeZoneIf::Load(name_)) {} 
 
 const time_zone::Impl* time_zone::Impl::UTCImpl() {
-  static const Impl* utc_impl = new Impl("UTC");  // never fails
+  static const Impl* utc_impl = new Impl("UTC");  // never fails 
   return utc_impl;
 }
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.h
index 7d747ba966..356ed93581 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.h
@@ -18,14 +18,14 @@
 #include <memory>
 #include <string>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 #include "time_zone_if.h"
 #include "time_zone_info.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -71,7 +71,7 @@ class time_zone::Impl {
     return zone_->PrevTransition(tp, trans);
   }
 
-  // Returns an implementation-defined version string for this time zone.
+  // Returns an implementation-defined version string for this time zone. 
   std::string Version() const { return zone_->Version(); }
 
   // Returns an implementation-defined description of this time zone.
@@ -87,7 +87,7 @@ class time_zone::Impl {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.cc
index 4f175d95fc..596df5a834 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.cc
@@ -46,13 +46,13 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "time_zone_fixed.h"
 #include "time_zone_posix.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -68,8 +68,8 @@ const std::int_least32_t kDaysPerYear[2] = {365, 366};
 // The day offsets of the beginning of each (1-based) month in non-leap and
 // leap years respectively (e.g., 335 days before December in a leap year).
 const std::int_least16_t kMonthOffsets[2][1 + 12 + 1] = {
-    {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
-    {-1, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366},
+    {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, 
+    {-1, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}, 
 };
 
 // We reject leap-second encoded zoneinfo and so assume 60-second minutes.
@@ -80,31 +80,31 @@ const std::int_least64_t kSecsPer400Years = 146097LL * kSecsPerDay;
 
 // Like kDaysPerYear[] but scaled up by a factor of kSecsPerDay.
 const std::int_least32_t kSecsPerYear[2] = {
-    365 * kSecsPerDay,
-    366 * kSecsPerDay,
+    365 * kSecsPerDay, 
+    366 * kSecsPerDay, 
 };
 
-// Convert a cctz::weekday to a POSIX TZ weekday number (0==Sun, ..., 6=Sat).
-inline int ToPosixWeekday(weekday wd) {
-  switch (wd) {
-    case weekday::sunday:
-      return 0;
-    case weekday::monday:
-      return 1;
-    case weekday::tuesday:
-      return 2;
-    case weekday::wednesday:
-      return 3;
-    case weekday::thursday:
-      return 4;
-    case weekday::friday:
-      return 5;
-    case weekday::saturday:
-      return 6;
-  }
-  return 0; /*NOTREACHED*/
-}
-
+// Convert a cctz::weekday to a POSIX TZ weekday number (0==Sun, ..., 6=Sat). 
+inline int ToPosixWeekday(weekday wd) { 
+  switch (wd) { 
+    case weekday::sunday: 
+      return 0; 
+    case weekday::monday: 
+      return 1; 
+    case weekday::tuesday: 
+      return 2; 
+    case weekday::wednesday: 
+      return 3; 
+    case weekday::thursday: 
+      return 4; 
+    case weekday::friday: 
+      return 5; 
+    case weekday::saturday: 
+      return 6; 
+  } 
+  return 0; /*NOTREACHED*/ 
+} 
+ 
 // Single-byte, unsigned numeric values are encoded directly.
 inline std::uint_fast8_t Decode8(const char* cp) {
   return static_cast<std::uint_fast8_t>(*cp) & 0xff;
@@ -196,8 +196,8 @@ inline time_zone::civil_lookup MakeRepeated(const Transition& tr,
 }
 
 inline civil_second YearShift(const civil_second& cs, year_t shift) {
-  return civil_second(cs.year() + shift, cs.month(), cs.day(), cs.hour(),
-                      cs.minute(), cs.second());
+  return civil_second(cs.year() + shift, cs.month(), cs.day(), cs.hour(), 
+                      cs.minute(), cs.second()); 
 }
 
 }  // namespace
@@ -210,13 +210,13 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
   tt.is_dst = false;
   tt.abbr_index = 0;
 
-  // We temporarily add some redundant, contemporary (2015 through 2025)
+  // We temporarily add some redundant, contemporary (2015 through 2025) 
   // transitions for performance reasons.  See TimeZoneInfo::LocalTime().
   // TODO: Fix the performance issue and remove the extra transitions.
   transitions_.clear();
   transitions_.reserve(12);
   for (const std::int_fast64_t unix_time : {
-           -(1LL << 59),  // a "first half" transition
+           -(1LL << 59),  // a "first half" transition 
            1420070400LL,  // 2015-01-01T00:00:00+00:00
            1451606400LL,  // 2016-01-01T00:00:00+00:00
            1483228800LL,  // 2017-01-01T00:00:00+00:00
@@ -226,8 +226,8 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
            1609459200LL,  // 2021-01-01T00:00:00+00:00
            1640995200LL,  // 2022-01-01T00:00:00+00:00
            1672531200LL,  // 2023-01-01T00:00:00+00:00
-           1704067200LL,  // 2024-01-01T00:00:00+00:00
-           1735689600LL,  // 2025-01-01T00:00:00+00:00
+           1704067200LL,  // 2024-01-01T00:00:00+00:00 
+           1735689600LL,  // 2025-01-01T00:00:00+00:00 
        }) {
     Transition& tr(*transitions_.emplace(transitions_.end()));
     tr.unix_time = unix_time;
@@ -238,7 +238,7 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
 
   default_transition_type_ = 0;
   abbreviations_ = FixedOffsetToAbbr(offset);
-  abbreviations_.append(1, '\0');
+  abbreviations_.append(1, '\0'); 
   future_spec_.clear();  // never needed for a fixed-offset zone
   extended_ = false;
 
@@ -288,128 +288,128 @@ bool TimeZoneInfo::EquivTransitions(std::uint_fast8_t tt1_index,
   if (tt1_index == tt2_index) return true;
   const TransitionType& tt1(transition_types_[tt1_index]);
   const TransitionType& tt2(transition_types_[tt2_index]);
-  if (tt1.utc_offset != tt2.utc_offset) return false;
+  if (tt1.utc_offset != tt2.utc_offset) return false; 
   if (tt1.is_dst != tt2.is_dst) return false;
   if (tt1.abbr_index != tt2.abbr_index) return false;
   return true;
 }
 
-// Find/make a transition type with these attributes.
-bool TimeZoneInfo::GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                                     const std::string& abbr,
-                                     std::uint_least8_t* index) {
-  std::size_t type_index = 0;
-  std::size_t abbr_index = abbreviations_.size();
-  for (; type_index != transition_types_.size(); ++type_index) {
-    const TransitionType& tt(transition_types_[type_index]);
-    const char* tt_abbr = &abbreviations_[tt.abbr_index];
-    if (tt_abbr == abbr) abbr_index = tt.abbr_index;
-    if (tt.utc_offset == utc_offset && tt.is_dst == is_dst) {
-      if (abbr_index == tt.abbr_index) break;  // reuse
-    }
-  }
-  if (type_index > 255 || abbr_index > 255) {
-    // No index space (8 bits) available for a new type or abbreviation.
-    return false;
-  }
-  if (type_index == transition_types_.size()) {
-    TransitionType& tt(*transition_types_.emplace(transition_types_.end()));
-    tt.utc_offset = static_cast<std::int_least32_t>(utc_offset);
-    tt.is_dst = is_dst;
-    if (abbr_index == abbreviations_.size()) {
-      abbreviations_.append(abbr);
-      abbreviations_.append(1, '\0');
-    }
-    tt.abbr_index = static_cast<std::uint_least8_t>(abbr_index);
-  }
-  *index = static_cast<std::uint_least8_t>(type_index);
-  return true;
-}
-
+// Find/make a transition type with these attributes. 
+bool TimeZoneInfo::GetTransitionType(std::int_fast32_t utc_offset, bool is_dst, 
+                                     const std::string& abbr, 
+                                     std::uint_least8_t* index) { 
+  std::size_t type_index = 0; 
+  std::size_t abbr_index = abbreviations_.size(); 
+  for (; type_index != transition_types_.size(); ++type_index) { 
+    const TransitionType& tt(transition_types_[type_index]); 
+    const char* tt_abbr = &abbreviations_[tt.abbr_index]; 
+    if (tt_abbr == abbr) abbr_index = tt.abbr_index; 
+    if (tt.utc_offset == utc_offset && tt.is_dst == is_dst) { 
+      if (abbr_index == tt.abbr_index) break;  // reuse 
+    } 
+  } 
+  if (type_index > 255 || abbr_index > 255) { 
+    // No index space (8 bits) available for a new type or abbreviation. 
+    return false; 
+  } 
+  if (type_index == transition_types_.size()) { 
+    TransitionType& tt(*transition_types_.emplace(transition_types_.end())); 
+    tt.utc_offset = static_cast<std::int_least32_t>(utc_offset); 
+    tt.is_dst = is_dst; 
+    if (abbr_index == abbreviations_.size()) { 
+      abbreviations_.append(abbr); 
+      abbreviations_.append(1, '\0'); 
+    } 
+    tt.abbr_index = static_cast<std::uint_least8_t>(abbr_index); 
+  } 
+  *index = static_cast<std::uint_least8_t>(type_index); 
+  return true; 
+} 
+ 
 // Use the POSIX-TZ-environment-variable-style string to handle times
 // in years after the last transition stored in the zoneinfo data.
-bool TimeZoneInfo::ExtendTransitions() {
+bool TimeZoneInfo::ExtendTransitions() { 
   extended_ = false;
-  if (future_spec_.empty()) return true;  // last transition prevails
+  if (future_spec_.empty()) return true;  // last transition prevails 
 
   PosixTimeZone posix;
-  if (!ParsePosixSpec(future_spec_, &posix)) return false;
+  if (!ParsePosixSpec(future_spec_, &posix)) return false; 
 
-  // Find transition type for the future std specification.
-  std::uint_least8_t std_ti;
-  if (!GetTransitionType(posix.std_offset, false, posix.std_abbr, &std_ti))
-    return false;
+  // Find transition type for the future std specification. 
+  std::uint_least8_t std_ti; 
+  if (!GetTransitionType(posix.std_offset, false, posix.std_abbr, &std_ti)) 
+    return false; 
 
-  if (posix.dst_abbr.empty()) {  // std only
-    // The future specification should match the last transition, and
-    // that means that handling the future will fall out naturally.
-    return EquivTransitions(transitions_.back().type_index, std_ti);
+  if (posix.dst_abbr.empty()) {  // std only 
+    // The future specification should match the last transition, and 
+    // that means that handling the future will fall out naturally. 
+    return EquivTransitions(transitions_.back().type_index, std_ti); 
   }
 
-  // Find transition type for the future dst specification.
-  std::uint_least8_t dst_ti;
-  if (!GetTransitionType(posix.dst_offset, true, posix.dst_abbr, &dst_ti))
-    return false;
+  // Find transition type for the future dst specification. 
+  std::uint_least8_t dst_ti; 
+  if (!GetTransitionType(posix.dst_offset, true, posix.dst_abbr, &dst_ti)) 
+    return false; 
 
   // Extend the transitions for an additional 400 years using the
   // future specification. Years beyond those can be handled by
   // mapping back to a cycle-equivalent year within that range.
-  // We may need two additional transitions for the current year.
-  transitions_.reserve(transitions_.size() + 400 * 2 + 2);
+  // We may need two additional transitions for the current year. 
+  transitions_.reserve(transitions_.size() + 400 * 2 + 2); 
   extended_ = true;
 
-  const Transition& last(transitions_.back());
-  const std::int_fast64_t last_time = last.unix_time;
-  const TransitionType& last_tt(transition_types_[last.type_index]);
-  last_year_ = LocalTime(last_time, last_tt).cs.year();
-  bool leap_year = IsLeap(last_year_);
-  const civil_second jan1(last_year_);
-  std::int_fast64_t jan1_time = jan1 - civil_second();
-  int jan1_weekday = ToPosixWeekday(get_weekday(jan1));
-
-  Transition dst = {0, dst_ti, civil_second(), civil_second()};
-  Transition std = {0, std_ti, civil_second(), civil_second()};
-  for (const year_t limit = last_year_ + 400;; ++last_year_) {
-    auto dst_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_start);
-    auto std_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_end);
-    dst.unix_time = jan1_time + dst_trans_off - posix.std_offset;
-    std.unix_time = jan1_time + std_trans_off - posix.dst_offset;
-    const auto* ta = dst.unix_time < std.unix_time ? &dst : &std;
-    const auto* tb = dst.unix_time < std.unix_time ? &std : &dst;
-    if (last_time < tb->unix_time) {
-      if (last_time < ta->unix_time) transitions_.push_back(*ta);
-      transitions_.push_back(*tb);
-    }
-    if (last_year_ == limit) break;
+  const Transition& last(transitions_.back()); 
+  const std::int_fast64_t last_time = last.unix_time; 
+  const TransitionType& last_tt(transition_types_[last.type_index]); 
+  last_year_ = LocalTime(last_time, last_tt).cs.year(); 
+  bool leap_year = IsLeap(last_year_); 
+  const civil_second jan1(last_year_); 
+  std::int_fast64_t jan1_time = jan1 - civil_second(); 
+  int jan1_weekday = ToPosixWeekday(get_weekday(jan1)); 
+
+  Transition dst = {0, dst_ti, civil_second(), civil_second()}; 
+  Transition std = {0, std_ti, civil_second(), civil_second()}; 
+  for (const year_t limit = last_year_ + 400;; ++last_year_) { 
+    auto dst_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_start); 
+    auto std_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_end); 
+    dst.unix_time = jan1_time + dst_trans_off - posix.std_offset; 
+    std.unix_time = jan1_time + std_trans_off - posix.dst_offset; 
+    const auto* ta = dst.unix_time < std.unix_time ? &dst : &std; 
+    const auto* tb = dst.unix_time < std.unix_time ? &std : &dst; 
+    if (last_time < tb->unix_time) { 
+      if (last_time < ta->unix_time) transitions_.push_back(*ta); 
+      transitions_.push_back(*tb); 
+    } 
+    if (last_year_ == limit) break; 
     jan1_time += kSecsPerYear[leap_year];
     jan1_weekday = (jan1_weekday + kDaysPerYear[leap_year]) % 7;
-    leap_year = !leap_year && IsLeap(last_year_ + 1);
+    leap_year = !leap_year && IsLeap(last_year_ + 1); 
   }
-
-  return true;
+ 
+  return true; 
 }
 
-bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
+bool TimeZoneInfo::Load(ZoneInfoSource* zip) { 
   // Read and validate the header.
   tzhead tzh;
-  if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh)) return false;
+  if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh)) return false; 
   if (strncmp(tzh.tzh_magic, TZ_MAGIC, sizeof(tzh.tzh_magic)) != 0)
     return false;
   Header hdr;
-  if (!hdr.Build(tzh)) return false;
+  if (!hdr.Build(tzh)) return false; 
   std::size_t time_len = 4;
   if (tzh.tzh_version[0] != '\0') {
     // Skip the 4-byte data.
-    if (zip->Skip(hdr.DataLength(time_len)) != 0) return false;
+    if (zip->Skip(hdr.DataLength(time_len)) != 0) return false; 
     // Read and validate the header for the 8-byte data.
-    if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh)) return false;
+    if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh)) return false; 
     if (strncmp(tzh.tzh_magic, TZ_MAGIC, sizeof(tzh.tzh_magic)) != 0)
       return false;
-    if (tzh.tzh_version[0] == '\0') return false;
-    if (!hdr.Build(tzh)) return false;
+    if (tzh.tzh_version[0] == '\0') return false; 
+    if (!hdr.Build(tzh)) return false; 
     time_len = 8;
   }
-  if (hdr.typecnt == 0) return false;
+  if (hdr.typecnt == 0) return false; 
   if (hdr.leapcnt != 0) {
     // This code assumes 60-second minutes so we do not want
     // the leap-second encoded zoneinfo. We could reverse the
@@ -417,17 +417,17 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
     // so currently we simply reject such data.
     return false;
   }
-  if (hdr.ttisstdcnt != 0 && hdr.ttisstdcnt != hdr.typecnt) return false;
-  if (hdr.ttisutcnt != 0 && hdr.ttisutcnt != hdr.typecnt) return false;
+  if (hdr.ttisstdcnt != 0 && hdr.ttisstdcnt != hdr.typecnt) return false; 
+  if (hdr.ttisutcnt != 0 && hdr.ttisutcnt != hdr.typecnt) return false; 
 
   // Read the data into a local buffer.
   std::size_t len = hdr.DataLength(time_len);
   std::vector<char> tbuf(len);
-  if (zip->Read(tbuf.data(), len) != len) return false;
+  if (zip->Read(tbuf.data(), len) != len) return false; 
   const char* bp = tbuf.data();
 
   // Decode and validate the transitions.
-  transitions_.reserve(hdr.timecnt + 2);
+  transitions_.reserve(hdr.timecnt + 2); 
   transitions_.resize(hdr.timecnt);
   for (std::size_t i = 0; i != hdr.timecnt; ++i) {
     transitions_[i].unix_time = (time_len == 4) ? Decode32(bp) : Decode64(bp);
@@ -441,12 +441,12 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   bool seen_type_0 = false;
   for (std::size_t i = 0; i != hdr.timecnt; ++i) {
     transitions_[i].type_index = Decode8(bp++);
-    if (transitions_[i].type_index >= hdr.typecnt) return false;
-    if (transitions_[i].type_index == 0) seen_type_0 = true;
+    if (transitions_[i].type_index >= hdr.typecnt) return false; 
+    if (transitions_[i].type_index == 0) seen_type_0 = true; 
   }
 
   // Decode and validate the transition types.
-  transition_types_.reserve(hdr.typecnt + 2);
+  transition_types_.reserve(hdr.typecnt + 2); 
   transition_types_.resize(hdr.typecnt);
   for (std::size_t i = 0; i != hdr.typecnt; ++i) {
     transition_types_[i].utc_offset =
@@ -457,7 +457,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
     bp += 4;
     transition_types_[i].is_dst = (Decode8(bp++) != 0);
     transition_types_[i].abbr_index = Decode8(bp++);
-    if (transition_types_[i].abbr_index >= hdr.charcnt) return false;
+    if (transition_types_[i].abbr_index >= hdr.charcnt) return false; 
   }
 
   // Determine the before-first-transition type.
@@ -466,14 +466,14 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
     std::uint_fast8_t index = 0;
     if (transition_types_[0].is_dst) {
       index = transitions_[0].type_index;
-      while (index != 0 && transition_types_[index].is_dst) --index;
+      while (index != 0 && transition_types_[index].is_dst) --index; 
     }
-    while (index != hdr.typecnt && transition_types_[index].is_dst) ++index;
-    if (index != hdr.typecnt) default_transition_type_ = index;
+    while (index != hdr.typecnt && transition_types_[index].is_dst) ++index; 
+    if (index != hdr.typecnt) default_transition_type_ = index; 
   }
 
   // Copy all the abbreviations.
-  abbreviations_.reserve(hdr.charcnt + 10);
+  abbreviations_.reserve(hdr.charcnt + 10); 
   abbreviations_.assign(bp, hdr.charcnt);
   bp += hdr.charcnt;
 
@@ -494,9 +494,9 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
       unsigned char ch;  // all non-EOF results are positive
       return (azip->Read(&ch, 1) == 1) ? ch : EOF;
     };
-    if (get_char(zip) != '\n') return false;
+    if (get_char(zip) != '\n') return false; 
     for (int c = get_char(zip); c != '\n'; c = get_char(zip)) {
-      if (c == EOF) return false;
+      if (c == EOF) return false; 
       future_spec_.push_back(static_cast<char>(c));
     }
   }
@@ -505,7 +505,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
 
   // If we did not find version information during the standard loading
   // process (as of tzh_version '3' that is unsupported), then ask the
-  // ZoneInfoSource for any out-of-bound version string it may be privy to.
+  // ZoneInfoSource for any out-of-bound version string it may be privy to. 
   if (version_.empty()) {
     version_ = zip->Version();
   }
@@ -524,30 +524,30 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   transitions_.resize(hdr.timecnt);
 
   // Ensure that there is always a transition in the first half of the
-  // time line (the second half is handled below) so that the signed
-  // difference between a civil_second and the civil_second of its
-  // previous transition is always representable, without overflow.
+  // time line (the second half is handled below) so that the signed 
+  // difference between a civil_second and the civil_second of its 
+  // previous transition is always representable, without overflow. 
   if (transitions_.empty() || transitions_.front().unix_time >= 0) {
     Transition& tr(*transitions_.emplace(transitions_.begin()));
-    tr.unix_time = -(1LL << 59);  // -18267312070-10-26T17:01:52+00:00
+    tr.unix_time = -(1LL << 59);  // -18267312070-10-26T17:01:52+00:00 
     tr.type_index = default_transition_type_;
   }
 
   // Extend the transitions using the future specification.
-  if (!ExtendTransitions()) return false;
-
-  // Ensure that there is always a transition in the second half of the
-  // time line (the first half is handled above) so that the signed
-  // difference between a civil_second and the civil_second of its
-  // previous transition is always representable, without overflow.
-  const Transition& last(transitions_.back());
-  if (last.unix_time < 0) {
-    const std::uint_fast8_t type_index = last.type_index;
-    Transition& tr(*transitions_.emplace(transitions_.end()));
-    tr.unix_time = 2147483647;  // 2038-01-19T03:14:07+00:00
-    tr.type_index = type_index;
-  }
-
+  if (!ExtendTransitions()) return false; 
+
+  // Ensure that there is always a transition in the second half of the 
+  // time line (the first half is handled above) so that the signed 
+  // difference between a civil_second and the civil_second of its 
+  // previous transition is always representable, without overflow. 
+  const Transition& last(transitions_.back()); 
+  if (last.unix_time < 0) { 
+    const std::uint_fast8_t type_index = last.type_index; 
+    Transition& tr(*transitions_.emplace(transitions_.end())); 
+    tr.unix_time = 2147483647;  // 2038-01-19T03:14:07+00:00 
+    tr.type_index = type_index; 
+  } 
+ 
   // Compute the local civil time for each transition and the preceding
   // second. These will be used for reverse conversions in MakeTime().
   const TransitionType* ttp = &transition_types_[default_transition_type_];
@@ -786,13 +786,13 @@ bool TimeZoneInfo::Load(const std::string& name) {
 
   // Find and use a ZoneInfoSource to load the named zone.
   auto zip = cctz_extension::zone_info_source_factory(
-      name, [](const std::string& n) -> std::unique_ptr<ZoneInfoSource> {
-        if (auto z = FileZoneInfoSource::Open(n)) return z;
-        if (auto z = AndroidZoneInfoSource::Open(n)) return z;
+      name, [](const std::string& n) -> std::unique_ptr<ZoneInfoSource> { 
+        if (auto z = FileZoneInfoSource::Open(n)) return z; 
+        if (auto z = AndroidZoneInfoSource::Open(n)) return z; 
         if (auto z = FuchsiaZoneInfoSource::Open(n)) return z;
         return nullptr;
       });
-  return zip != nullptr && Load(zip.get());
+  return zip != nullptr && Load(zip.get()); 
 }
 
 // BreakTime() translation for a particular transition type.
@@ -801,13 +801,13 @@ time_zone::absolute_lookup TimeZoneInfo::LocalTime(
   // A civil time in "+offset" looks like (time+offset) in UTC.
   // Note: We perform two additions in the civil_second domain to
   // sidestep the chance of overflow in (unix_time + tt.utc_offset).
-  return {(civil_second() + unix_time) + tt.utc_offset, tt.utc_offset,
-          tt.is_dst, &abbreviations_[tt.abbr_index]};
+  return {(civil_second() + unix_time) + tt.utc_offset, tt.utc_offset, 
+          tt.is_dst, &abbreviations_[tt.abbr_index]}; 
 }
 
 // BreakTime() translation for a particular transition.
-time_zone::absolute_lookup TimeZoneInfo::LocalTime(std::int_fast64_t unix_time,
-                                                   const Transition& tr) const {
+time_zone::absolute_lookup TimeZoneInfo::LocalTime(std::int_fast64_t unix_time, 
+                                                   const Transition& tr) const { 
   const TransitionType& tt = transition_types_[tr.type_index];
   // Note: (unix_time - tr.unix_time) will never overflow as we
   // have ensured that there is always a "nearby" transition.
@@ -950,7 +950,7 @@ time_zone::civil_lookup TimeZoneInfo::MakeTime(const civil_second& cs) const {
   return MakeUnique(tr->unix_time + (cs - tr->civil_sec));
 }
 
-std::string TimeZoneInfo::Version() const { return version_; }
+std::string TimeZoneInfo::Version() const { return version_; } 
 
 std::string TimeZoneInfo::Description() const {
   std::ostringstream oss;
@@ -966,14 +966,14 @@ bool TimeZoneInfo::NextTransition(const time_point<seconds>& tp,
   const Transition* begin = &transitions_[0];
   const Transition* end = begin + transitions_.size();
   if (begin->unix_time <= -(1LL << 59)) {
-    // Do not report the BIG_BANG found in some zoneinfo data as it is
-    // really a sentinel, not a transition.  See pre-2018f tz/zic.c.
+    // Do not report the BIG_BANG found in some zoneinfo data as it is 
+    // really a sentinel, not a transition.  See pre-2018f tz/zic.c. 
     ++begin;
   }
   std::int_fast64_t unix_time = ToUnixSeconds(tp);
   const Transition target = {unix_time, 0, civil_second(), civil_second()};
-  const Transition* tr =
-      std::upper_bound(begin, end, target, Transition::ByUnixTime());
+  const Transition* tr = 
+      std::upper_bound(begin, end, target, Transition::ByUnixTime()); 
   for (; tr != end; ++tr) {  // skip no-op transitions
     std::uint_fast8_t prev_type_index =
         (tr == begin) ? default_transition_type_ : tr[-1].type_index;
@@ -992,8 +992,8 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp,
   const Transition* begin = &transitions_[0];
   const Transition* end = begin + transitions_.size();
   if (begin->unix_time <= -(1LL << 59)) {
-    // Do not report the BIG_BANG found in some zoneinfo data as it is
-    // really a sentinel, not a transition.  See pre-2018f tz/zic.c.
+    // Do not report the BIG_BANG found in some zoneinfo data as it is 
+    // really a sentinel, not a transition.  See pre-2018f tz/zic.c. 
     ++begin;
   }
   std::int_fast64_t unix_time = ToUnixSeconds(tp);
@@ -1007,8 +1007,8 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp,
     unix_time += 1;  // ceils
   }
   const Transition target = {unix_time, 0, civil_second(), civil_second()};
-  const Transition* tr =
-      std::lower_bound(begin, end, target, Transition::ByUnixTime());
+  const Transition* tr = 
+      std::lower_bound(begin, end, target, Transition::ByUnixTime()); 
   for (; tr != begin; --tr) {  // skip no-op transitions
     std::uint_fast8_t prev_type_index =
         (tr - 1 == begin) ? default_transition_type_ : tr[-2].type_index;
@@ -1023,5 +1023,5 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp,
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h
index 2467ff559d..63b958a7e2 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h
@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 #include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
@@ -29,7 +29,7 @@
 #include "tzfile.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -74,7 +74,7 @@ class TimeZoneInfo : public TimeZoneIf {
   // TimeZoneIf implementations.
   time_zone::absolute_lookup BreakTime(
       const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+  time_zone::civil_lookup MakeTime(const civil_second& cs) const override; 
   bool NextTransition(const time_point<seconds>& tp,
                       time_zone::civil_transition* trans) const override;
   bool PrevTransition(const time_point<seconds>& tp,
@@ -83,7 +83,7 @@ class TimeZoneInfo : public TimeZoneIf {
   std::string Description() const override;
 
  private:
-  struct Header {            // counts of:
+  struct Header {            // counts of: 
     std::size_t timecnt;     // transition times
     std::size_t typecnt;     // transition types
     std::size_t charcnt;     // zone abbreviation characters
@@ -95,14 +95,14 @@ class TimeZoneInfo : public TimeZoneIf {
     std::size_t DataLength(std::size_t time_len) const;
   };
 
-  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                         const std::string& abbr, std::uint_least8_t* index);
+  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst, 
+                         const std::string& abbr, std::uint_least8_t* index); 
   bool EquivTransitions(std::uint_fast8_t tt1_index,
                         std::uint_fast8_t tt2_index) const;
-  bool ExtendTransitions();
+  bool ExtendTransitions(); 
 
   bool ResetToBuiltinUTC(const seconds& offset);
-  bool Load(ZoneInfoSource* zip);
+  bool Load(ZoneInfoSource* zip); 
 
   // Helpers for BreakTime() and MakeTime().
   time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
@@ -114,7 +114,7 @@ class TimeZoneInfo : public TimeZoneIf {
 
   std::vector<Transition> transitions_;  // ordered by unix_time and civil_sec
   std::vector<TransitionType> transition_types_;  // distinct transition types
-  std::uint_fast8_t default_transition_type_;     // for before first transition
+  std::uint_fast8_t default_transition_type_;     // for before first transition 
   std::string abbreviations_;  // all the NUL-terminated abbreviations
 
   std::string version_;      // the tzdata version if available
@@ -131,7 +131,7 @@ class TimeZoneInfo : public TimeZoneIf {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
index 887dd097c6..3148f2b4af 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
@@ -23,7 +23,7 @@
 #include <limits>
 #include <utility>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
@@ -34,7 +34,7 @@ extern long altzone;
 #endif
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -92,7 +92,7 @@ auto tm_gmtoff(const T& tm) -> decltype(tm.__tm_gmtoff) {
 }
 #endif  // tm_gmtoff
 #if defined(tm_zone)
-auto tm_zone(const std::tm& tm) -> decltype(tm.tm_zone) { return tm.tm_zone; }
+auto tm_zone(const std::tm& tm) -> decltype(tm.tm_zone) { return tm.tm_zone; } 
 #elif defined(__tm_zone)
 auto tm_zone(const std::tm& tm) -> decltype(tm.__tm_zone) {
   return tm.__tm_zone;
@@ -109,19 +109,19 @@ auto tm_zone(const T& tm) -> decltype(tm.__tm_zone) {
 #endif  // tm_zone
 #endif
 
-inline std::tm* gm_time(const std::time_t* timep, std::tm* result) {
+inline std::tm* gm_time(const std::time_t* timep, std::tm* result) { 
 #if defined(_WIN32) || defined(_WIN64)
-  return gmtime_s(result, timep) ? nullptr : result;
+  return gmtime_s(result, timep) ? nullptr : result; 
 #else
-  return gmtime_r(timep, result);
+  return gmtime_r(timep, result); 
 #endif
 }
 
-inline std::tm* local_time(const std::time_t* timep, std::tm* result) {
+inline std::tm* local_time(const std::time_t* timep, std::tm* result) { 
 #if defined(_WIN32) || defined(_WIN64)
-  return localtime_s(result, timep) ? nullptr : result;
+  return localtime_s(result, timep) ? nullptr : result; 
 #else
-  return localtime_r(timep, result);
+  return localtime_r(timep, result); 
 #endif
 }
 
@@ -159,8 +159,8 @@ std::time_t find_trans(std::time_t lo, std::time_t hi, int offset) {
   std::tm tm;
   while (lo + 1 != hi) {
     const std::time_t mid = lo + (hi - lo) / 2;
-    std::tm* tmp = local_time(&mid, &tm);
-    if (tmp != nullptr) {
+    std::tm* tmp = local_time(&mid, &tm); 
+    if (tmp != nullptr) { 
       if (tm_gmtoff(*tmp) == offset) {
         hi = mid;
       } else {
@@ -170,8 +170,8 @@ std::time_t find_trans(std::time_t lo, std::time_t hi, int offset) {
       // If std::tm cannot hold some result we resort to a linear search,
       // ignoring all failed conversions.  Slow, but never really happens.
       while (++lo != hi) {
-        tmp = local_time(&lo, &tm);
-        if (tmp != nullptr) {
+        tmp = local_time(&lo, &tm); 
+        if (tmp != nullptr) { 
           if (tm_gmtoff(*tmp) == offset) break;
         }
       }
@@ -216,8 +216,8 @@ time_zone::absolute_lookup TimeZoneLibC::BreakTime(
   }
 
   const year_t year = tmp->tm_year + year_t{1900};
-  al.cs = civil_second(year, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour,
-                       tmp->tm_min, tmp->tm_sec);
+  al.cs = civil_second(year, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour, 
+                       tmp->tm_min, tmp->tm_sec); 
   al.offset = static_cast<int>(tm_gmtoff(*tmp));
   al.abbr = local_ ? tm_zone(*tmp) : "UTC";  // as expected by cctz
   al.is_dst = tmp->tm_isdst > 0;
@@ -231,10 +231,10 @@ time_zone::civil_lookup TimeZoneLibC::MakeTime(const civil_second& cs) const {
         civil_second() + ToUnixSeconds(time_point<seconds>::min());
     static const civil_second max_tp_cs =
         civil_second() + ToUnixSeconds(time_point<seconds>::max());
-    const time_point<seconds> tp = (cs < min_tp_cs) ? time_point<seconds>::min()
-                                   : (cs > max_tp_cs)
-                                       ? time_point<seconds>::max()
-                                       : FromUnixSeconds(cs - civil_second());
+    const time_point<seconds> tp = (cs < min_tp_cs) ? time_point<seconds>::min() 
+                                   : (cs > max_tp_cs) 
+                                       ? time_point<seconds>::max() 
+                                       : FromUnixSeconds(cs - civil_second()); 
     return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
   }
 
@@ -311,5 +311,5 @@ std::string TimeZoneLibC::Description() const {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h
index 1da9039a15..191d617d67 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h
@@ -17,11 +17,11 @@
 
 #include <string>
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "time_zone_if.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -35,7 +35,7 @@ class TimeZoneLibC : public TimeZoneIf {
   // TimeZoneIf implementations.
   time_zone::absolute_lookup BreakTime(
       const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+  time_zone::civil_lookup MakeTime(const civil_second& cs) const override; 
   bool NextTransition(const time_point<seconds>& tp,
                       time_zone::civil_transition* trans) const override;
   bool PrevTransition(const time_point<seconds>& tp,
@@ -49,7 +49,7 @@ class TimeZoneLibC : public TimeZoneIf {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc
index 55843c5e5b..a336f5b615 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc
@@ -12,7 +12,7 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#include "absl/base/config.h"
+#include "absl/base/config.h" 
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 #if defined(__ANDROID__)
@@ -24,7 +24,7 @@
 
 #if defined(__APPLE__)
 #include <CoreFoundation/CFTimeZone.h>
-
+ 
 #include <vector>
 #endif
 
@@ -43,7 +43,7 @@
 #include "time_zone_impl.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -76,7 +76,7 @@ int __system_property_get(const char* name, char* value) {
 }  // namespace
 #endif
 
-std::string time_zone::name() const { return effective_impl().Name(); }
+std::string time_zone::name() const { return effective_impl().Name(); } 
 
 time_zone::absolute_lookup time_zone::lookup(
     const time_point<seconds>& tp) const {
@@ -97,7 +97,7 @@ bool time_zone::prev_transition(const time_point<seconds>& tp,
   return effective_impl().PrevTransition(tp, trans);
 }
 
-std::string time_zone::version() const { return effective_impl().Version(); }
+std::string time_zone::version() const { return effective_impl().Version(); } 
 
 std::string time_zone::description() const {
   return effective_impl().Description();
@@ -232,5 +232,5 @@ time_zone local_time_zone() {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc
index 5cdd09e89d..efb73f9698 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc
@@ -19,10 +19,10 @@
 #include <limits>
 #include <string>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -155,5 +155,5 @@ bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res) {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.h
index 0cf29055f5..63903230a6 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.h
@@ -55,10 +55,10 @@
 #include <cstdint>
 #include <string>
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -126,7 +126,7 @@ bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res);
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
index 31e8598257..1581e02940 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
@@ -22,15 +22,15 @@
 */
 
 #ifndef TZDIR
-#define TZDIR "/usr/share/zoneinfo" /* Time zone object file directory */
-#endif                              /* !defined TZDIR */
+#define TZDIR "/usr/share/zoneinfo" /* Time zone object file directory */ 
+#endif                              /* !defined TZDIR */ 
 
 #ifndef TZDEFAULT
-#define TZDEFAULT "/etc/localtime"
+#define TZDEFAULT "/etc/localtime" 
 #endif /* !defined TZDEFAULT */
 
 #ifndef TZDEFRULES
-#define TZDEFRULES "posixrules"
+#define TZDEFRULES "posixrules" 
 #endif /* !defined TZDEFRULES */
 
 /* See Internet RFC 8536 for more details about the following format.  */
@@ -39,18 +39,18 @@
 ** Each file begins with. . .
 */
 
-#define TZ_MAGIC "TZif"
+#define TZ_MAGIC "TZif" 
 
 struct tzhead {
-  char tzh_magic[4];      /* TZ_MAGIC */
+  char tzh_magic[4];      /* TZ_MAGIC */ 
   char tzh_version[1];    /* '\0' or '2'-'4' as of 2021 */
-  char tzh_reserved[15];  /* reserved; must be zero */
-  char tzh_ttisutcnt[4];  /* coded number of trans. time flags */
-  char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
-  char tzh_leapcnt[4];    /* coded number of leap seconds */
-  char tzh_timecnt[4];    /* coded number of transition times */
-  char tzh_typecnt[4];    /* coded number of local time types */
-  char tzh_charcnt[4];    /* coded number of abbr. chars */
+  char tzh_reserved[15];  /* reserved; must be zero */ 
+  char tzh_ttisutcnt[4];  /* coded number of trans. time flags */ 
+  char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */ 
+  char tzh_leapcnt[4];    /* coded number of leap seconds */ 
+  char tzh_timecnt[4];    /* coded number of transition times */ 
+  char tzh_typecnt[4];    /* coded number of local time types */ 
+  char tzh_charcnt[4];    /* coded number of abbr. chars */ 
 };
 
 /*
@@ -83,13 +83,13 @@ struct tzhead {
 ** If tzh_version is '2' or greater, the above is followed by a second instance
 ** of tzhead and a second instance of the data in which each coded transition
 ** time uses 8 rather than 4 chars,
-** then a POSIX-TZ-environment-variable-style string for use in handling
+** then a POSIX-TZ-environment-variable-style string for use in handling 
 ** instants after the last transition time stored in the file
 ** (with nothing between the newlines if there is no POSIX representation for
 ** such instants).
 **
 ** If tz_version is '3' or greater, the above is extended as follows.
-** First, the POSIX TZ string's hour offset may range from -167
+** First, the POSIX TZ string's hour offset may range from -167 
 ** through 167 as compared to the POSIX-required 0 through 24.
 ** Second, its DST start time may be January 1 at 00:00 and its stop
 ** time December 31 at 24:00 plus the difference between DST and
@@ -102,21 +102,21 @@ struct tzhead {
 */
 
 #ifndef TZ_MAX_TIMES
-#define TZ_MAX_TIMES 2000
+#define TZ_MAX_TIMES 2000 
 #endif /* !defined TZ_MAX_TIMES */
 
 #ifndef TZ_MAX_TYPES
 /* This must be at least 17 for Europe/Samara and Europe/Vilnius.  */
-#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
+#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */ 
 #endif                   /* !defined TZ_MAX_TYPES */
 
 #ifndef TZ_MAX_CHARS
-#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
+#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */ 
                         /* (limited by what unsigned chars can hold) */
 #endif                  /* !defined TZ_MAX_CHARS */
 
 #ifndef TZ_MAX_LEAPS
-#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
+#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */ 
 #endif                  /* !defined TZ_MAX_LEAPS */
 
 #endif /* !defined TZFILE_H */
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc
index 5ab5a59ecf..840e968aad 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc
@@ -14,10 +14,10 @@
 
 #include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz {
 
@@ -27,11 +27,11 @@ std::string ZoneInfoSource::Version() const { return std::string(); }
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 namespace cctz_extension {
 
@@ -41,9 +41,9 @@ namespace {
 // defers to the fallback factory.
 std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> DefaultFactory(
     const std::string& name,
-    const std::function<
-        std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource>(
-            const std::string& name)>& fallback_factory) {
+    const std::function< 
+        std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource>( 
+            const std::string& name)>& fallback_factory) { 
   return fallback_factory(name);
 }
 
@@ -59,48 +59,48 @@ std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> DefaultFactory(
 // Windows linker cannot handle that. Nor does the MinGW compiler know how to
 // pass "#pragma comment(linker, ...)" to the Windows linker.
 #if (__has_attribute(weak) || defined(__GNUC__)) && !defined(__MINGW32__)
-ZoneInfoSourceFactory zone_info_source_factory __attribute__((weak)) =
-    DefaultFactory;
+ZoneInfoSourceFactory zone_info_source_factory __attribute__((weak)) = 
+    DefaultFactory; 
 #elif defined(_MSC_VER) && !defined(__MINGW32__) && !defined(_LIBCPP_VERSION)
 extern ZoneInfoSourceFactory zone_info_source_factory;
 extern ZoneInfoSourceFactory default_factory;
 ZoneInfoSourceFactory default_factory = DefaultFactory;
 #if defined(_M_IX86) || defined(_M_ARM)
-#pragma comment(                                                                                                         \
-    linker,                                                                                                              \
-    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                    \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZA")
+#pragma comment(                                                                                                         \ 
+    linker,                                                                                                              \ 
+    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                    \ 
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \ 
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \ 
+    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \ 
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \ 
+    "@@ZA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \ 
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \ 
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \ 
+    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \ 
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \ 
+    "@@ZA") 
 #elif defined(_M_IA_64) || defined(_M_AMD64) || defined(_M_ARM64)
-#pragma comment(                                                                                                          \
-    linker,                                                                                                               \
-    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                     \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZEA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZEA")
+#pragma comment(                                                                                                          \ 
+    linker,                                                                                                               \ 
+    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                     \ 
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \ 
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \ 
+    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \ 
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \ 
+    "@@ZEA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \ 
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \ 
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \ 
+    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \ 
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \ 
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \ 
+    "@@ZEA") 
 #else
 #error Unsupported MSVC platform
 #endif  // _M_<PLATFORM>
@@ -111,5 +111,5 @@ ZoneInfoSourceFactory zone_info_source_factory = DefaultFactory;
 
 }  // namespace cctz_extension
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_chrono.inc b/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_chrono.inc
index 5eeb6406aa..6160a8b0cb 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_chrono.inc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_chrono.inc
@@ -16,7 +16,7 @@
 #include <cstdint>
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 
 static int64_t GetCurrentTimeNanosFromSystem() {
@@ -27,5 +27,5 @@ static int64_t GetCurrentTimeNanosFromSystem() {
 }
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_posix.inc b/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_posix.inc
index 42072000ae..3a92c45763 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_posix.inc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/get_current_time_posix.inc
@@ -7,7 +7,7 @@
 #include "absl/base/internal/raw_logging.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 
 static int64_t GetCurrentTimeNanosFromSystem() {
@@ -20,5 +20,5 @@ static int64_t GetCurrentTimeNanosFromSystem() {
 }
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/test_util.h b/contrib/restricted/abseil-cpp/absl/time/internal/test_util.h
index 5c4bf1f680..626ee92f6b 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/test_util.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/test_util.h
@@ -20,14 +20,14 @@
 #include "absl/time/time.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 namespace time_internal {
 
 // Loads the named timezone, but dies on any failure.
 absl::TimeZone LoadTimeZone(const std::string& name);
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_TEST_UTIL_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/time.cc b/contrib/restricted/abseil-cpp/absl/time/time.cc
index 1ec2026e25..398b024324 100644
--- a/contrib/restricted/abseil-cpp/absl/time/time.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/time.cc
@@ -47,7 +47,7 @@
 namespace cctz = absl::time_internal::cctz;
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 namespace {
 
@@ -60,10 +60,10 @@ inline cctz::time_point<cctz::seconds> unix_epoch() {
 inline int64_t FloorToUnit(absl::Duration d, absl::Duration unit) {
   absl::Duration rem;
   int64_t q = absl::IDivDuration(d, unit, &rem);
-  return (q > 0 || rem >= ZeroDuration() ||
-          q == std::numeric_limits<int64_t>::min())
-             ? q
-             : q - 1;
+  return (q > 0 || rem >= ZeroDuration() || 
+          q == std::numeric_limits<int64_t>::min()) 
+             ? q 
+             : q - 1; 
 }
 
 inline absl::Time::Breakdown InfiniteFutureBreakdown() {
@@ -496,5 +496,5 @@ struct tm ToTM(absl::Time t, absl::TimeZone tz) {
   return tm;
 }
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/time/time.h b/contrib/restricted/abseil-cpp/absl/time/time.h
index 5abd815a79..6fb7207dde 100644
--- a/contrib/restricted/abseil-cpp/absl/time/time.h
+++ b/contrib/restricted/abseil-cpp/absl/time/time.h
@@ -89,7 +89,7 @@ struct timeval;
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace absl {
-ABSL_NAMESPACE_BEGIN
+ABSL_NAMESPACE_BEGIN 
 
 class Duration;  // Defined below
 class Time;      // Defined below
@@ -575,7 +575,7 @@ inline std::ostream& operator<<(std::ostream& os, Duration d) {
 // suffix.  The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
 // Simple examples include "300ms", "-1.5h", and "2h45m".  Parses "0" as
 // `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
-bool ParseDuration(absl::string_view dur_string, Duration* d);
+bool ParseDuration(absl::string_view dur_string, Duration* d); 
 
 // AbslParseFlag()
 //
@@ -679,7 +679,7 @@ class Time {
   // Deprecated. Use `absl::TimeZone::CivilInfo`.
   struct
       Breakdown {
-    int64_t year;        // year (e.g., 2013)
+    int64_t year;        // year (e.g., 2013) 
     int month;           // month of year [1:12]
     int day;             // day of month [1:31]
     int hour;            // hour of day [0:23]
@@ -1071,13 +1071,13 @@ class TimeZone {
 // Loads the named zone. May perform I/O on the initial load of the named
 // zone. If the name is invalid, or some other kind of error occurs, returns
 // `false` and `*tz` is set to the UTC time zone.
-inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) {
+inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) { 
   if (name == "localtime") {
     *tz = TimeZone(time_internal::cctz::local_time_zone());
     return true;
   }
   time_internal::cctz::time_zone cz;
-  const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
+  const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz); 
   *tz = TimeZone(cz);
   return b;
 }
@@ -1257,15 +1257,15 @@ struct tm ToTM(Time t, TimeZone tz);
 // time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
 // years have exactly four digits, but we allow them to take their natural
 // width.
-ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
-ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
+ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez 
+ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez 
 
 // RFC1123_full
 // RFC1123_no_wday
 //
 // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
-ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
-ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z 
+ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z 
 
 // FormatTime()
 //
@@ -1280,7 +1280,7 @@ ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 //   - %E#f - Fractional seconds with # digits of precision
 //   - %E*f - Fractional seconds with full precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // Note that %E0S behaves like %S, and %E0f produces no characters.  In
 // contrast %E*f always produces at least one digit, which may be '0'.
@@ -1304,7 +1304,7 @@ ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 // `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
 // In both cases the given format string and `absl::TimeZone` are ignored.
 //
-std::string FormatTime(absl::string_view format, Time t, TimeZone tz);
+std::string FormatTime(absl::string_view format, Time t, TimeZone tz); 
 
 // Convenience functions that format the given time using the RFC3339_full
 // format.  The first overload uses the provided TimeZone, while the second
@@ -1323,8 +1323,8 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
 // returns the corresponding `absl::Time`. Uses strftime()-like formatting
 // options, with the same extensions as FormatTime(), but with the
 // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+// and %E*z also accept the same inputs, which (along with %z) includes 
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'. 
 //
 // %Y consumes as many numeric characters as it can, so the matching data
 // should always be terminated with a non-numeric.  %E4Y always consumes
@@ -1366,7 +1366,7 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
 // If the input string is "infinite-past", the returned `absl::Time` will be
 // `absl::InfinitePast()` and `true` will be returned.
 //
-bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
+bool ParseTime(absl::string_view format, absl::string_view input, Time* time, 
                std::string* err);
 
 // Like ParseTime() above, but if the format string does not contain a UTC
@@ -1376,7 +1376,7 @@ bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
 // of ambiguity or non-existence, in which case the "pre" time (as defined
 // by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
 // all date/time strings include a UTC offset so they're context independent.
-bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz,
+bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz, 
                Time* time, std::string* err);
 
 // ============================================================================
@@ -1401,7 +1401,7 @@ constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
 // it's positive and can be converted to int64_t without risk of UB.
 inline Duration MakePosDoubleDuration(double n) {
   const int64_t int_secs = static_cast<int64_t>(n);
-  const uint32_t ticks = static_cast<uint32_t>(
+  const uint32_t ticks = static_cast<uint32_t>( 
       std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
   return ticks < kTicksPerSecond
              ? MakeDuration(int_secs, ticks)
@@ -1529,10 +1529,10 @@ T ToChronoDuration(Duration d) {
 constexpr bool operator<(Duration lhs, Duration rhs) {
   return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
              ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
-         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
-             ? time_internal::GetRepLo(lhs) + 1 <
-                   time_internal::GetRepLo(rhs) + 1
-             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
+         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)() 
+             ? time_internal::GetRepLo(lhs) + 1 < 
+                   time_internal::GetRepLo(rhs) + 1 
+             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs); 
 }
 
 constexpr bool operator==(Duration lhs, Duration rhs) {
@@ -1610,7 +1610,7 @@ constexpr Time FromTimeT(time_t t) {
   return time_internal::FromUnixDuration(Seconds(t));
 }
 
-ABSL_NAMESPACE_END
+ABSL_NAMESPACE_END 
 }  // namespace absl
 
 #endif  // ABSL_TIME_TIME_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/time_zone/ya.make b/contrib/restricted/abseil-cpp/absl/time/time_zone/ya.make
index 810a0b318c..04e1bb9005 100644
--- a/contrib/restricted/abseil-cpp/absl/time/time_zone/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/time/time_zone/ya.make
@@ -20,10 +20,10 @@ NO_COMPILER_WARNINGS()
 
 NO_UTIL()
 
-CFLAGS(
-    -DNOMINMAX
-)
-
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCDIR(contrib/restricted/abseil-cpp/absl/time/internal/cctz/src)
 
 SRCS(
diff --git a/contrib/restricted/abseil-cpp/absl/time/ya.make b/contrib/restricted/abseil-cpp/absl/time/ya.make
index feb835cc53..a70b2c1ee6 100644
--- a/contrib/restricted/abseil-cpp/absl/time/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/time/ya.make
@@ -32,10 +32,10 @@ NO_COMPILER_WARNINGS()
 
 NO_UTIL()
 
-CFLAGS(
-    -DNOMINMAX
-)
-
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCS(
     civil_time.cc
     clock.cc