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

10 files changed, 1915 insertions, 1915 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
index 1c58023e4b..6d25aef463 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
@@ -1,20 +1,20 @@
-====================Apache-2.0====================
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-====================COPYRIGHT====================
-// Copyright 2019 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2019 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
index 6754d7d518..28073afc48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
@@ -1,69 +1,69 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
-
-#include <util/generic/string.h>
-
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/strings/cord.h"
-
-#ifndef SWIG
-// Disabled for SWIG as it doesn't parse attributes correctly.
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-// Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs
-// as part of a class definitions (b/6995610), so we use a forward declaration.
-class ABSL_MUST_USE_RESULT Status;
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-#endif  // !SWIG
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-enum class StatusCode : int;
-
-namespace status_internal {
-
-// Container for status payloads.
-struct Payload {
-  TString type_url;
-  y_absl::Cord payload;
-};
-
-using Payloads = y_absl::InlinedVector<Payload, 1>;
-
-// Reference-counted representation of Status data.
-struct StatusRep {
+// Copyright 2019 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+#ifndef ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
+#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
+ 
+#include <util/generic/string.h> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/cord.h" 
+ 
+#ifndef SWIG 
+// Disabled for SWIG as it doesn't parse attributes correctly. 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+// Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs 
+// as part of a class definitions (b/6995610), so we use a forward declaration. 
+class ABSL_MUST_USE_RESULT Status; 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+#endif  // !SWIG 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+enum class StatusCode : int; 
+ 
+namespace status_internal { 
+ 
+// Container for status payloads. 
+struct Payload { 
+  TString type_url; 
+  y_absl::Cord payload; 
+}; 
+ 
+using Payloads = y_absl::InlinedVector<Payload, 1>; 
+ 
+// Reference-counted representation of Status data. 
+struct StatusRep { 
   StatusRep(y_absl::StatusCode code_arg, y_absl::string_view message_arg,
             std::unique_ptr<status_internal::Payloads> payloads_arg)
-      : ref(int32_t{1}),
+      : ref(int32_t{1}), 
         code(code_arg),
         message(message_arg),
         payloads(std::move(payloads_arg)) {}
-
-  std::atomic<int32_t> ref;
-  y_absl::StatusCode code;
-  TString message;
-  std::unique_ptr<status_internal::Payloads> payloads;
-};
-
-y_absl::StatusCode MapToLocalCode(int value);
-}  // namespace status_internal
-
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+ 
+  std::atomic<int32_t> ref; 
+  y_absl::StatusCode code; 
+  TString message; 
+  std::unique_ptr<status_internal::Payloads> payloads; 
+}; 
+ 
+y_absl::StatusCode MapToLocalCode(int value); 
+}  // namespace status_internal 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
index c4d78e28d2..3c9f587e45 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
@@ -1,396 +1,396 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
-
-#include <type_traits>
-#include <utility>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/status/status.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-namespace internal_statusor {
-
-// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator
-// StatusOr<T>()`.
-template <typename T, typename U, typename = void>
-struct HasConversionOperatorToStatusOr : std::false_type {};
-
-template <typename T, typename U>
-void test(char (*)[sizeof(std::declval<U>().operator y_absl::StatusOr<T>())]);
-
-template <typename T, typename U>
-struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))>
-    : std::true_type {};
-
-// Detects whether `T` is constructible or convertible from `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleFromStatusOr =
-    y_absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
-                      std::is_constructible<T, const StatusOr<U>&>,
-                      std::is_constructible<T, StatusOr<U>&&>,
-                      std::is_constructible<T, const StatusOr<U>&&>,
-                      std::is_convertible<StatusOr<U>&, T>,
-                      std::is_convertible<const StatusOr<U>&, T>,
-                      std::is_convertible<StatusOr<U>&&, T>,
-                      std::is_convertible<const StatusOr<U>&&, T>>;
-
-// Detects whether `T` is constructible or convertible or assignable from
-// `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
-    y_absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
-                      std::is_assignable<T&, StatusOr<U>&>,
-                      std::is_assignable<T&, const StatusOr<U>&>,
-                      std::is_assignable<T&, StatusOr<U>&&>,
-                      std::is_assignable<T&, const StatusOr<U>&&>>;
-
-// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e.
-// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
-template <typename T, typename U>
-struct IsDirectInitializationAmbiguous
-    : public y_absl::conditional_t<
-          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsDirectInitializationAmbiguous<
-              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename V>
-struct IsDirectInitializationAmbiguous<T, y_absl::StatusOr<V>>
-    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {};
-
-// Checks against the constraints of the direction initialization, i.e. when
-// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsDirectInitializationValid = y_absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-    y_absl::negation<y_absl::disjunction<
-        std::is_same<y_absl::StatusOr<T>,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::Status,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::in_place_t,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        IsDirectInitializationAmbiguous<T, U>>>>;
-
-// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
-// is equivalent to whether all the following conditions are met:
-// 1. `U` is `StatusOr<V>`.
-// 2. `T` is constructible and assignable from `V`.
-// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`).
-// For example, the following code is considered ambiguous:
-// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`)
-//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true
-//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false
-//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous
-    : public y_absl::conditional_t<
-          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsForwardingAssignmentAmbiguous<
-              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous<T, y_absl::StatusOr<U>>
-    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {};
-
-// Checks against the constraints of the forwarding assignment, i.e. whether
-// `StatusOr<T>::operator(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsForwardingAssignmentValid = y_absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-    y_absl::negation<y_absl::disjunction<
-        std::is_same<y_absl::StatusOr<T>,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::Status,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::in_place_t,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        IsForwardingAssignmentAmbiguous<T, U>>>>;
-
-class Helper {
- public:
-  // Move type-agnostic error handling to the .cc.
-  static void HandleInvalidStatusCtorArg(Status*);
-  ABSL_ATTRIBUTE_NORETURN static void Crash(const y_absl::Status& status);
-};
-
-// Construct an instance of T in `p` through placement new, passing Args... to
-// the constructor.
-// This abstraction is here mostly for the gcc performance fix.
-template <typename T, typename... Args>
-ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
-  new (p) T(std::forward<Args>(args)...);
-}
-
-// Helper base class to hold the data and all operations.
-// We move all this to a base class to allow mixing with the appropriate
-// TraitsBase specialization.
-template <typename T>
-class StatusOrData {
-  template <typename U>
-  friend class StatusOrData;
-
- public:
-  StatusOrData() = delete;
-
-  StatusOrData(const StatusOrData& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  StatusOrData(StatusOrData&& other) noexcept {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(const StatusOrData<U>& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(StatusOrData<U>&& other) {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename... Args>
-  explicit StatusOrData(y_absl::in_place_t, Args&&... args)
-      : data_(std::forward<Args>(args)...) {
-    MakeStatus();
-  }
-
-  explicit StatusOrData(const T& value) : data_(value) {
-    MakeStatus();
-  }
-  explicit StatusOrData(T&& value) : data_(std::move(value)) {
-    MakeStatus();
-  }
-
-  template <typename U,
-            y_absl::enable_if_t<std::is_constructible<y_absl::Status, U&&>::value,
-                              int> = 0>
-  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
-    EnsureNotOk();
-  }
-
-  StatusOrData& operator=(const StatusOrData& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(other.data_);
-    else
-      AssignStatus(other.status_);
-    return *this;
-  }
-
-  StatusOrData& operator=(StatusOrData&& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(std::move(other.data_));
-    else
-      AssignStatus(std::move(other.status_));
-    return *this;
-  }
-
-  ~StatusOrData() {
-    if (ok()) {
-      status_.~Status();
-      data_.~T();
-    } else {
-      status_.~Status();
-    }
-  }
-
-  template <typename U>
-  void Assign(U&& value) {
-    if (ok()) {
-      data_ = std::forward<U>(value);
-    } else {
-      MakeValue(std::forward<U>(value));
-      status_ = OkStatus();
-    }
-  }
-
-  template <typename U>
-  void AssignStatus(U&& v) {
-    Clear();
-    status_ = static_cast<y_absl::Status>(std::forward<U>(v));
-    EnsureNotOk();
-  }
-
-  bool ok() const { return status_.ok(); }
-
- protected:
-  // status_ will always be active after the constructor.
-  // We make it a union to be able to initialize exactly how we need without
-  // waste.
-  // Eg. in the copy constructor we use the default constructor of Status in
-  // the ok() path to avoid an extra Ref call.
-  union {
-    Status status_;
-  };
-
-  // data_ is active iff status_.ok()==true
-  struct Dummy {};
-  union {
-    // When T is const, we need some non-const object we can cast to void* for
-    // the placement new. dummy_ is that object.
-    Dummy dummy_;
-    T data_;
-  };
-
-  void Clear() {
-    if (ok()) data_.~T();
-  }
-
-  void EnsureOk() const {
-    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
-  }
-
-  void EnsureNotOk() {
-    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
-  }
-
-  // Construct the value (ie. data_) through placement new with the passed
-  // argument.
-  template <typename... Arg>
-  void MakeValue(Arg&&... arg) {
-    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...);
-  }
-
-  // Construct the status (ie. status_) through placement new with the passed
-  // argument.
-  template <typename... Args>
-  void MakeStatus(Args&&... args) {
-    internal_statusor::PlacementNew<Status>(&status_,
-                                            std::forward<Args>(args)...);
-  }
-};
-
-// Helper base classes to allow implicitly deleted constructors and assignment
-// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete
-// the copy constructor when T is not copy constructible and `StatusOr` will
-// inherit that behavior implicitly.
-template <typename T, bool = std::is_copy_constructible<T>::value>
-struct CopyCtorBase {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = default;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T>
-struct CopyCtorBase<T, false> {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = delete;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value>
-struct MoveCtorBase {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = default;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T>
-struct MoveCtorBase<T, false> {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = delete;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_copy_constructible<T>::value&&
-                          std::is_copy_assignable<T>::value>
-struct CopyAssignBase {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = default;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T>
-struct CopyAssignBase<T, false> {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = delete;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value&&
-                          std::is_move_assignable<T>::value>
-struct MoveAssignBase {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = default;
-};
-
-template <typename T>
-struct MoveAssignBase<T, false> {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = delete;
-};
-
-ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status);
-
-}  // namespace internal_statusor
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+// Copyright 2020 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+#ifndef ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
+#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
+ 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "y_absl/base/attributes.h" 
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/utility/utility.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+template <typename T> 
+class ABSL_MUST_USE_RESULT StatusOr; 
+ 
+namespace internal_statusor { 
+ 
+// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator 
+// StatusOr<T>()`. 
+template <typename T, typename U, typename = void> 
+struct HasConversionOperatorToStatusOr : std::false_type {}; 
+ 
+template <typename T, typename U> 
+void test(char (*)[sizeof(std::declval<U>().operator y_absl::StatusOr<T>())]); 
+ 
+template <typename T, typename U> 
+struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))> 
+    : std::true_type {}; 
+ 
+// Detects whether `T` is constructible or convertible from `StatusOr<U>`. 
+template <typename T, typename U> 
+using IsConstructibleOrConvertibleFromStatusOr = 
+    y_absl::disjunction<std::is_constructible<T, StatusOr<U>&>, 
+                      std::is_constructible<T, const StatusOr<U>&>, 
+                      std::is_constructible<T, StatusOr<U>&&>, 
+                      std::is_constructible<T, const StatusOr<U>&&>, 
+                      std::is_convertible<StatusOr<U>&, T>, 
+                      std::is_convertible<const StatusOr<U>&, T>, 
+                      std::is_convertible<StatusOr<U>&&, T>, 
+                      std::is_convertible<const StatusOr<U>&&, T>>; 
+ 
+// Detects whether `T` is constructible or convertible or assignable from 
+// `StatusOr<U>`. 
+template <typename T, typename U> 
+using IsConstructibleOrConvertibleOrAssignableFromStatusOr = 
+    y_absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>, 
+                      std::is_assignable<T&, StatusOr<U>&>, 
+                      std::is_assignable<T&, const StatusOr<U>&>, 
+                      std::is_assignable<T&, StatusOr<U>&&>, 
+                      std::is_assignable<T&, const StatusOr<U>&&>>; 
+ 
+// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e. 
+// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`. 
+template <typename T, typename U> 
+struct IsDirectInitializationAmbiguous 
+    : public y_absl::conditional_t< 
+          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                       U>::value, 
+          std::false_type, 
+          IsDirectInitializationAmbiguous< 
+              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {}; 
+ 
+template <typename T, typename V> 
+struct IsDirectInitializationAmbiguous<T, y_absl::StatusOr<V>> 
+    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {}; 
+ 
+// Checks against the constraints of the direction initialization, i.e. when 
+// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution. 
+template <typename T, typename U> 
+using IsDirectInitializationValid = y_absl::disjunction< 
+    // Short circuits if T is basically U. 
+    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+    y_absl::negation<y_absl::disjunction< 
+        std::is_same<y_absl::StatusOr<T>, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::Status, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::in_place_t, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        IsDirectInitializationAmbiguous<T, U>>>>; 
+ 
+// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which 
+// is equivalent to whether all the following conditions are met: 
+// 1. `U` is `StatusOr<V>`. 
+// 2. `T` is constructible and assignable from `V`. 
+// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`). 
+// For example, the following code is considered ambiguous: 
+// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`) 
+//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true 
+//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false 
+//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`? 
+template <typename T, typename U> 
+struct IsForwardingAssignmentAmbiguous 
+    : public y_absl::conditional_t< 
+          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                       U>::value, 
+          std::false_type, 
+          IsForwardingAssignmentAmbiguous< 
+              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {}; 
+ 
+template <typename T, typename U> 
+struct IsForwardingAssignmentAmbiguous<T, y_absl::StatusOr<U>> 
+    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {}; 
+ 
+// Checks against the constraints of the forwarding assignment, i.e. whether 
+// `StatusOr<T>::operator(U&&)` should participate in overload resolution. 
+template <typename T, typename U> 
+using IsForwardingAssignmentValid = y_absl::disjunction< 
+    // Short circuits if T is basically U. 
+    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+    y_absl::negation<y_absl::disjunction< 
+        std::is_same<y_absl::StatusOr<T>, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::Status, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::in_place_t, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        IsForwardingAssignmentAmbiguous<T, U>>>>; 
+ 
+class Helper { 
+ public: 
+  // Move type-agnostic error handling to the .cc. 
+  static void HandleInvalidStatusCtorArg(Status*); 
+  ABSL_ATTRIBUTE_NORETURN static void Crash(const y_absl::Status& status); 
+}; 
+ 
+// Construct an instance of T in `p` through placement new, passing Args... to 
+// the constructor. 
+// This abstraction is here mostly for the gcc performance fix. 
+template <typename T, typename... Args> 
+ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) { 
+  new (p) T(std::forward<Args>(args)...); 
+} 
+ 
+// Helper base class to hold the data and all operations. 
+// We move all this to a base class to allow mixing with the appropriate 
+// TraitsBase specialization. 
+template <typename T> 
+class StatusOrData { 
+  template <typename U> 
+  friend class StatusOrData; 
+ 
+ public: 
+  StatusOrData() = delete; 
+ 
+  StatusOrData(const StatusOrData& other) { 
+    if (other.ok()) { 
+      MakeValue(other.data_); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(other.status_); 
+    } 
+  } 
+ 
+  StatusOrData(StatusOrData&& other) noexcept { 
+    if (other.ok()) { 
+      MakeValue(std::move(other.data_)); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(std::move(other.status_)); 
+    } 
+  } 
+ 
+  template <typename U> 
+  explicit StatusOrData(const StatusOrData<U>& other) { 
+    if (other.ok()) { 
+      MakeValue(other.data_); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(other.status_); 
+    } 
+  } 
+ 
+  template <typename U> 
+  explicit StatusOrData(StatusOrData<U>&& other) { 
+    if (other.ok()) { 
+      MakeValue(std::move(other.data_)); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(std::move(other.status_)); 
+    } 
+  } 
+ 
+  template <typename... Args> 
+  explicit StatusOrData(y_absl::in_place_t, Args&&... args) 
+      : data_(std::forward<Args>(args)...) { 
+    MakeStatus(); 
+  } 
+ 
+  explicit StatusOrData(const T& value) : data_(value) { 
+    MakeStatus(); 
+  } 
+  explicit StatusOrData(T&& value) : data_(std::move(value)) { 
+    MakeStatus(); 
+  } 
+ 
+  template <typename U, 
+            y_absl::enable_if_t<std::is_constructible<y_absl::Status, U&&>::value, 
+                              int> = 0> 
+  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) { 
+    EnsureNotOk(); 
+  } 
+ 
+  StatusOrData& operator=(const StatusOrData& other) { 
+    if (this == &other) return *this; 
+    if (other.ok()) 
+      Assign(other.data_); 
+    else 
+      AssignStatus(other.status_); 
+    return *this; 
+  } 
+ 
+  StatusOrData& operator=(StatusOrData&& other) { 
+    if (this == &other) return *this; 
+    if (other.ok()) 
+      Assign(std::move(other.data_)); 
+    else 
+      AssignStatus(std::move(other.status_)); 
+    return *this; 
+  } 
+ 
+  ~StatusOrData() { 
+    if (ok()) { 
+      status_.~Status(); 
+      data_.~T(); 
+    } else { 
+      status_.~Status(); 
+    } 
+  } 
+ 
+  template <typename U> 
+  void Assign(U&& value) { 
+    if (ok()) { 
+      data_ = std::forward<U>(value); 
+    } else { 
+      MakeValue(std::forward<U>(value)); 
+      status_ = OkStatus(); 
+    } 
+  } 
+ 
+  template <typename U> 
+  void AssignStatus(U&& v) { 
+    Clear(); 
+    status_ = static_cast<y_absl::Status>(std::forward<U>(v)); 
+    EnsureNotOk(); 
+  } 
+ 
+  bool ok() const { return status_.ok(); } 
+ 
+ protected: 
+  // status_ will always be active after the constructor. 
+  // We make it a union to be able to initialize exactly how we need without 
+  // waste. 
+  // Eg. in the copy constructor we use the default constructor of Status in 
+  // the ok() path to avoid an extra Ref call. 
+  union { 
+    Status status_; 
+  }; 
+ 
+  // data_ is active iff status_.ok()==true 
+  struct Dummy {}; 
+  union { 
+    // When T is const, we need some non-const object we can cast to void* for 
+    // the placement new. dummy_ is that object. 
+    Dummy dummy_; 
+    T data_; 
+  }; 
+ 
+  void Clear() { 
+    if (ok()) data_.~T(); 
+  } 
+ 
+  void EnsureOk() const { 
+    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_); 
+  } 
+ 
+  void EnsureNotOk() { 
+    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_); 
+  } 
+ 
+  // Construct the value (ie. data_) through placement new with the passed 
+  // argument. 
+  template <typename... Arg> 
+  void MakeValue(Arg&&... arg) { 
+    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...); 
+  } 
+ 
+  // Construct the status (ie. status_) through placement new with the passed 
+  // argument. 
+  template <typename... Args> 
+  void MakeStatus(Args&&... args) { 
+    internal_statusor::PlacementNew<Status>(&status_, 
+                                            std::forward<Args>(args)...); 
+  } 
+}; 
+ 
+// Helper base classes to allow implicitly deleted constructors and assignment 
+// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete 
+// the copy constructor when T is not copy constructible and `StatusOr` will 
+// inherit that behavior implicitly. 
+template <typename T, bool = std::is_copy_constructible<T>::value> 
+struct CopyCtorBase { 
+  CopyCtorBase() = default; 
+  CopyCtorBase(const CopyCtorBase&) = default; 
+  CopyCtorBase(CopyCtorBase&&) = default; 
+  CopyCtorBase& operator=(const CopyCtorBase&) = default; 
+  CopyCtorBase& operator=(CopyCtorBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct CopyCtorBase<T, false> { 
+  CopyCtorBase() = default; 
+  CopyCtorBase(const CopyCtorBase&) = delete; 
+  CopyCtorBase(CopyCtorBase&&) = default; 
+  CopyCtorBase& operator=(const CopyCtorBase&) = default; 
+  CopyCtorBase& operator=(CopyCtorBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_move_constructible<T>::value> 
+struct MoveCtorBase { 
+  MoveCtorBase() = default; 
+  MoveCtorBase(const MoveCtorBase&) = default; 
+  MoveCtorBase(MoveCtorBase&&) = default; 
+  MoveCtorBase& operator=(const MoveCtorBase&) = default; 
+  MoveCtorBase& operator=(MoveCtorBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct MoveCtorBase<T, false> { 
+  MoveCtorBase() = default; 
+  MoveCtorBase(const MoveCtorBase&) = default; 
+  MoveCtorBase(MoveCtorBase&&) = delete; 
+  MoveCtorBase& operator=(const MoveCtorBase&) = default; 
+  MoveCtorBase& operator=(MoveCtorBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_copy_constructible<T>::value&& 
+                          std::is_copy_assignable<T>::value> 
+struct CopyAssignBase { 
+  CopyAssignBase() = default; 
+  CopyAssignBase(const CopyAssignBase&) = default; 
+  CopyAssignBase(CopyAssignBase&&) = default; 
+  CopyAssignBase& operator=(const CopyAssignBase&) = default; 
+  CopyAssignBase& operator=(CopyAssignBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct CopyAssignBase<T, false> { 
+  CopyAssignBase() = default; 
+  CopyAssignBase(const CopyAssignBase&) = default; 
+  CopyAssignBase(CopyAssignBase&&) = default; 
+  CopyAssignBase& operator=(const CopyAssignBase&) = delete; 
+  CopyAssignBase& operator=(CopyAssignBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_move_constructible<T>::value&& 
+                          std::is_move_assignable<T>::value> 
+struct MoveAssignBase { 
+  MoveAssignBase() = default; 
+  MoveAssignBase(const MoveAssignBase&) = default; 
+  MoveAssignBase(MoveAssignBase&&) = default; 
+  MoveAssignBase& operator=(const MoveAssignBase&) = default; 
+  MoveAssignBase& operator=(MoveAssignBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct MoveAssignBase<T, false> { 
+  MoveAssignBase() = default; 
+  MoveAssignBase(const MoveAssignBase&) = default; 
+  MoveAssignBase(MoveAssignBase&&) = default; 
+  MoveAssignBase& operator=(const MoveAssignBase&) = default; 
+  MoveAssignBase& operator=(MoveAssignBase&&) = delete; 
+}; 
+ 
+ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status); 
+ 
+}  // namespace internal_statusor 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
index 3b7fe28e08..f4747914bf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
@@ -78,7 +78,7 @@ static int FindPayloadIndexByUrl(const Payloads* payloads,
                                  y_absl::string_view type_url) {
   if (payloads == nullptr) return -1;
 
-  for (size_t i = 0; i < payloads->size(); ++i) {
+  for (size_t i = 0; i < payloads->size(); ++i) { 
     if ((*payloads)[i].type_url == type_url) return i;
   }
 
@@ -167,15 +167,15 @@ void Status::ForEachPayload(
     bool in_reverse =
         payloads->size() > 1 && reinterpret_cast<uintptr_t>(payloads) % 13 > 6;
 
-    for (size_t index = 0; index < payloads->size(); ++index) {
+    for (size_t index = 0; index < payloads->size(); ++index) { 
       const auto& elem =
           (*payloads)[in_reverse ? payloads->size() - 1 - index : index];
 
 #ifdef NDEBUG
       visitor(elem.type_url, elem.payload);
 #else
-      // In debug mode invalidate the type url to prevent users from relying on
-      // this string lifetime.
+      // In debug mode invalidate the type url to prevent users from relying on 
+      // this string lifetime. 
 
       // NOLINTNEXTLINE intentional extra conversion to force temporary.
       visitor(TString(elem.type_url), elem.payload);
@@ -283,27 +283,27 @@ bool Status::EqualsSlow(const y_absl::Status& a, const y_absl::Status& b) {
   return true;
 }
 
-TString Status::ToStringSlow(StatusToStringMode mode) const {
+TString Status::ToStringSlow(StatusToStringMode mode) const { 
   TString text;
   y_absl::StrAppend(&text, y_absl::StatusCodeToString(code()), ": ", message());
 
-  const bool with_payload = (mode & StatusToStringMode::kWithPayload) ==
-                      StatusToStringMode::kWithPayload;
-
-  if (with_payload) {
-    status_internal::StatusPayloadPrinter printer =
-        status_internal::GetStatusPayloadPrinter();
-    this->ForEachPayload([&](y_absl::string_view type_url,
-                             const y_absl::Cord& payload) {
-      y_absl::optional<TString> result;
-      if (printer) result = printer(type_url, payload);
-      y_absl::StrAppend(
-          &text, " [", type_url, "='",
-          result.has_value() ? *result : y_absl::CHexEscape(TString(payload)),
-          "']");
-    });
-  }
-
+  const bool with_payload = (mode & StatusToStringMode::kWithPayload) == 
+                      StatusToStringMode::kWithPayload; 
+ 
+  if (with_payload) { 
+    status_internal::StatusPayloadPrinter printer = 
+        status_internal::GetStatusPayloadPrinter(); 
+    this->ForEachPayload([&](y_absl::string_view type_url, 
+                             const y_absl::Cord& payload) { 
+      y_absl::optional<TString> result; 
+      if (printer) result = printer(type_url, payload); 
+      y_absl::StrAppend( 
+          &text, " [", type_url, "='", 
+          result.has_value() ? *result : y_absl::CHexEscape(TString(payload)), 
+          "']"); 
+    }); 
+  } 
+ 
   return text;
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
index fa461e9f76..0ea97ef92c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
@@ -11,43 +11,43 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: status.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the Abseil `status` library, consisting of:
-//
-//   * An `y_absl::Status` class for holding error handling information
-//   * A set of canonical `y_absl::StatusCode` error codes, and associated
-//     utilities for generating and propagating status codes.
-//   * A set of helper functions for creating status codes and checking their
-//     values
-//
-// Within Google, `y_absl::Status` is the primary mechanism for gracefully
-// handling errors across API boundaries (and in particular across RPC
-// boundaries). Some of these errors may be recoverable, but others may not.
-// Most functions that can produce a recoverable error should be designed to
-// return an `y_absl::Status` (or `y_absl::StatusOr`).
-//
-// Example:
-//
-// y_absl::Status myFunction(y_absl::string_view fname, ...) {
-//   ...
-//   // encounter error
-//   if (error condition) {
-//     return y_absl::InvalidArgumentError("bad mode");
-//   }
-//   // else, return OK
-//   return y_absl::OkStatus();
-// }
-//
-// An `y_absl::Status` is designed to either return "OK" or one of a number of
-// different error codes, corresponding to typical error conditions.
-// In almost all cases, when using `y_absl::Status` you should use the canonical
-// error codes (of type `y_absl::StatusCode`) enumerated in this header file.
-// These canonical codes are understood across the codebase and will be
-// accepted across all API and RPC boundaries.
+// 
+// ----------------------------------------------------------------------------- 
+// File: status.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This header file defines the Abseil `status` library, consisting of: 
+// 
+//   * An `y_absl::Status` class for holding error handling information 
+//   * A set of canonical `y_absl::StatusCode` error codes, and associated 
+//     utilities for generating and propagating status codes. 
+//   * A set of helper functions for creating status codes and checking their 
+//     values 
+// 
+// Within Google, `y_absl::Status` is the primary mechanism for gracefully 
+// handling errors across API boundaries (and in particular across RPC 
+// boundaries). Some of these errors may be recoverable, but others may not. 
+// Most functions that can produce a recoverable error should be designed to 
+// return an `y_absl::Status` (or `y_absl::StatusOr`). 
+// 
+// Example: 
+// 
+// y_absl::Status myFunction(y_absl::string_view fname, ...) { 
+//   ... 
+//   // encounter error 
+//   if (error condition) { 
+//     return y_absl::InvalidArgumentError("bad mode"); 
+//   } 
+//   // else, return OK 
+//   return y_absl::OkStatus(); 
+// } 
+// 
+// An `y_absl::Status` is designed to either return "OK" or one of a number of 
+// different error codes, corresponding to typical error conditions. 
+// In almost all cases, when using `y_absl::Status` you should use the canonical 
+// error codes (of type `y_absl::StatusCode`) enumerated in this header file. 
+// These canonical codes are understood across the codebase and will be 
+// accepted across all API and RPC boundaries. 
 #ifndef ABSL_STATUS_STATUS_H_
 #define ABSL_STATUS_STATUS_H_
 
@@ -56,539 +56,539 @@
 
 #include "y_absl/container/inlined_vector.h"
 #include "y_absl/functional/function_ref.h"
-#include "y_absl/status/internal/status_internal.h"
+#include "y_absl/status/internal/status_internal.h" 
 #include "y_absl/strings/cord.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/string_view.h" 
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
-// y_absl::StatusCode
-//
-// An `y_absl::StatusCode` is an enumerated type indicating either no error ("OK")
-// or an error condition. In most cases, an `y_absl::Status` indicates a
-// recoverable error, and the purpose of signalling an error is to indicate what
-// action to take in response to that error. These error codes map to the proto
-// RPC error codes indicated in https://cloud.google.com/apis/design/errors.
-//
-// The errors listed below are the canonical errors associated with
-// `y_absl::Status` and are used throughout the codebase. As a result, these
-// error codes are somewhat generic.
-//
-// In general, try to return the most specific error that applies if more than
-// one error may pertain. For example, prefer `kOutOfRange` over
-// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or
-// `kAlreadyExists` over `kFailedPrecondition`.
-//
+// y_absl::StatusCode 
+// 
+// An `y_absl::StatusCode` is an enumerated type indicating either no error ("OK") 
+// or an error condition. In most cases, an `y_absl::Status` indicates a 
+// recoverable error, and the purpose of signalling an error is to indicate what 
+// action to take in response to that error. These error codes map to the proto 
+// RPC error codes indicated in https://cloud.google.com/apis/design/errors. 
+// 
+// The errors listed below are the canonical errors associated with 
+// `y_absl::Status` and are used throughout the codebase. As a result, these 
+// error codes are somewhat generic. 
+// 
+// In general, try to return the most specific error that applies if more than 
+// one error may pertain. For example, prefer `kOutOfRange` over 
+// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or 
+// `kAlreadyExists` over `kFailedPrecondition`. 
+// 
 // Because these errors may cross RPC boundaries, these codes are tied to the
-// `google.rpc.Code` definitions within
-// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
-// The string value of these RPC codes is denoted within each enum below.
-//
-// If your error handling code requires more context, you can attach payloads
-// to your status. See `y_absl::Status::SetPayload()` and
-// `y_absl::Status::GetPayload()` below.
+// `google.rpc.Code` definitions within 
+// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto 
+// The string value of these RPC codes is denoted within each enum below. 
+// 
+// If your error handling code requires more context, you can attach payloads 
+// to your status. See `y_absl::Status::SetPayload()` and 
+// `y_absl::Status::GetPayload()` below. 
 enum class StatusCode : int {
-  // StatusCode::kOk
-  //
-  // kOK (gRPC code "OK") does not indicate an error; this value is returned on
-  // success. It is typical to check for this value before proceeding on any
-  // given call across an API or RPC boundary. To check this value, use the
-  // `y_absl::Status::ok()` member function rather than inspecting the raw code.
+  // StatusCode::kOk 
+  // 
+  // kOK (gRPC code "OK") does not indicate an error; this value is returned on 
+  // success. It is typical to check for this value before proceeding on any 
+  // given call across an API or RPC boundary. To check this value, use the 
+  // `y_absl::Status::ok()` member function rather than inspecting the raw code. 
   kOk = 0,
-
-  // StatusCode::kCancelled
-  //
-  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled,
-  // typically by the caller.
+ 
+  // StatusCode::kCancelled 
+  // 
+  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled, 
+  // typically by the caller. 
   kCancelled = 1,
-
-  // StatusCode::kUnknown
-  //
-  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In
-  // general, more specific errors should be raised, if possible. Errors raised
-  // by APIs that do not return enough error information may be converted to
-  // this error.
+ 
+  // StatusCode::kUnknown 
+  // 
+  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In 
+  // general, more specific errors should be raised, if possible. Errors raised 
+  // by APIs that do not return enough error information may be converted to 
+  // this error. 
   kUnknown = 2,
-
-  // StatusCode::kInvalidArgument
-  //
-  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller
+ 
+  // StatusCode::kInvalidArgument 
+  // 
+  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller 
   // specified an invalid argument, such as a malformed filename. Note that use
   // of such errors should be narrowly limited to indicate the invalid nature of
   // the arguments themselves. Errors with validly formed arguments that may
   // cause errors with the state of the receiving system should be denoted with
-  // `kFailedPrecondition` instead.
+  // `kFailedPrecondition` instead. 
   kInvalidArgument = 3,
-
-  // StatusCode::kDeadlineExceeded
-  //
-  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline
-  // expired before the operation could complete. For operations that may change
-  // state within a system, this error may be returned even if the operation has
-  // completed successfully. For example, a successful response from a server
-  // could have been delayed long enough for the deadline to expire.
+ 
+  // StatusCode::kDeadlineExceeded 
+  // 
+  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline 
+  // expired before the operation could complete. For operations that may change 
+  // state within a system, this error may be returned even if the operation has 
+  // completed successfully. For example, a successful response from a server 
+  // could have been delayed long enough for the deadline to expire. 
   kDeadlineExceeded = 4,
-
-  // StatusCode::kNotFound
-  //
-  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as
-  // a file or directory) was not found.
-  //
-  // `kNotFound` is useful if a request should be denied for an entire class of
-  // users, such as during a gradual feature rollout or undocumented allow list.
+ 
+  // StatusCode::kNotFound 
+  // 
+  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as 
+  // a file or directory) was not found. 
+  // 
+  // `kNotFound` is useful if a request should be denied for an entire class of 
+  // users, such as during a gradual feature rollout or undocumented allow list. 
   // If a request should be denied for specific sets of users, such as through
   // user-based access control, use `kPermissionDenied` instead.
   kNotFound = 5,
-
-  // StatusCode::kAlreadyExists
-  //
+ 
+  // StatusCode::kAlreadyExists 
+  // 
   // kAlreadyExists (gRPC code "ALREADY_EXISTS") indicates that the entity a
   // caller attempted to create (such as a file or directory) is already
   // present.
   kAlreadyExists = 6,
-
-  // StatusCode::kPermissionDenied
-  //
-  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller
-  // does not have permission to execute the specified operation. Note that this
-  // error is different than an error due to an *un*authenticated user. This
-  // error code does not imply the request is valid or the requested entity
-  // exists or satisfies any other pre-conditions.
-  //
-  // `kPermissionDenied` must not be used for rejections caused by exhausting
-  // some resource. Instead, use `kResourceExhausted` for those errors.
-  // `kPermissionDenied` must not be used if the caller cannot be identified.
-  // Instead, use `kUnauthenticated` for those errors.
+ 
+  // StatusCode::kPermissionDenied 
+  // 
+  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller 
+  // does not have permission to execute the specified operation. Note that this 
+  // error is different than an error due to an *un*authenticated user. This 
+  // error code does not imply the request is valid or the requested entity 
+  // exists or satisfies any other pre-conditions. 
+  // 
+  // `kPermissionDenied` must not be used for rejections caused by exhausting 
+  // some resource. Instead, use `kResourceExhausted` for those errors. 
+  // `kPermissionDenied` must not be used if the caller cannot be identified. 
+  // Instead, use `kUnauthenticated` for those errors. 
   kPermissionDenied = 7,
-
-  // StatusCode::kResourceExhausted
-  //
-  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource
-  // has been exhausted, perhaps a per-user quota, or perhaps the entire file
-  // system is out of space.
+ 
+  // StatusCode::kResourceExhausted 
+  // 
+  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource 
+  // has been exhausted, perhaps a per-user quota, or perhaps the entire file 
+  // system is out of space. 
   kResourceExhausted = 8,
-
-  // StatusCode::kFailedPrecondition
-  //
-  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the
-  // operation was rejected because the system is not in a state required for
-  // the operation's execution. For example, a directory to be deleted may be
-  // non-empty, an "rmdir" operation is applied to a non-directory, etc.
-  //
-  // Some guidelines that may help a service implementer in deciding between
-  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`:
-  //
-  //  (a) Use `kUnavailable` if the client can retry just the failing call.
-  //  (b) Use `kAborted` if the client should retry at a higher transaction
-  //      level (such as when a client-specified test-and-set fails, indicating
-  //      the client should restart a read-modify-write sequence).
-  //  (c) Use `kFailedPrecondition` if the client should not retry until
+ 
+  // StatusCode::kFailedPrecondition 
+  // 
+  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the 
+  // operation was rejected because the system is not in a state required for 
+  // the operation's execution. For example, a directory to be deleted may be 
+  // non-empty, an "rmdir" operation is applied to a non-directory, etc. 
+  // 
+  // Some guidelines that may help a service implementer in deciding between 
+  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`: 
+  // 
+  //  (a) Use `kUnavailable` if the client can retry just the failing call. 
+  //  (b) Use `kAborted` if the client should retry at a higher transaction 
+  //      level (such as when a client-specified test-and-set fails, indicating 
+  //      the client should restart a read-modify-write sequence). 
+  //  (c) Use `kFailedPrecondition` if the client should not retry until 
   //      the system state has been explicitly fixed. For example, if a "rmdir"
-  //      fails because the directory is non-empty, `kFailedPrecondition`
-  //      should be returned since the client should not retry unless
-  //      the files are deleted from the directory.
+  //      fails because the directory is non-empty, `kFailedPrecondition` 
+  //      should be returned since the client should not retry unless 
+  //      the files are deleted from the directory. 
   kFailedPrecondition = 9,
-
-  // StatusCode::kAborted
-  //
-  // kAborted (gRPC code "ABORTED") indicates the operation was aborted,
-  // typically due to a concurrency issue such as a sequencer check failure or a
-  // failed transaction.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
+ 
+  // StatusCode::kAborted 
+  // 
+  // kAborted (gRPC code "ABORTED") indicates the operation was aborted, 
+  // typically due to a concurrency issue such as a sequencer check failure or a 
+  // failed transaction. 
+  // 
+  // See the guidelines above for deciding between `kFailedPrecondition`, 
+  // `kAborted`, and `kUnavailable`. 
   kAborted = 10,
-
-  // StatusCode::kOutOfRange
-  //
-  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was
-  // attempted past the valid range, such as seeking or reading past an
-  // end-of-file.
-  //
-  // Unlike `kInvalidArgument`, this error indicates a problem that may
-  // be fixed if the system state changes. For example, a 32-bit file
-  // system will generate `kInvalidArgument` if asked to read at an
-  // offset that is not in the range [0,2^32-1], but it will generate
-  // `kOutOfRange` if asked to read from an offset past the current
-  // file size.
-  //
-  // There is a fair bit of overlap between `kFailedPrecondition` and
-  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific
-  // error) when it applies so that callers who are iterating through
-  // a space can easily look for an `kOutOfRange` error to detect when
-  // they are done.
+ 
+  // StatusCode::kOutOfRange 
+  // 
+  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was 
+  // attempted past the valid range, such as seeking or reading past an 
+  // end-of-file. 
+  // 
+  // Unlike `kInvalidArgument`, this error indicates a problem that may 
+  // be fixed if the system state changes. For example, a 32-bit file 
+  // system will generate `kInvalidArgument` if asked to read at an 
+  // offset that is not in the range [0,2^32-1], but it will generate 
+  // `kOutOfRange` if asked to read from an offset past the current 
+  // file size. 
+  // 
+  // There is a fair bit of overlap between `kFailedPrecondition` and 
+  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific 
+  // error) when it applies so that callers who are iterating through 
+  // a space can easily look for an `kOutOfRange` error to detect when 
+  // they are done. 
   kOutOfRange = 11,
-
-  // StatusCode::kUnimplemented
-  //
-  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not
-  // implemented or supported in this service. In this case, the operation
-  // should not be re-attempted.
+ 
+  // StatusCode::kUnimplemented 
+  // 
+  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not 
+  // implemented or supported in this service. In this case, the operation 
+  // should not be re-attempted. 
   kUnimplemented = 12,
-
-  // StatusCode::kInternal
-  //
-  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred
-  // and some invariants expected by the underlying system have not been
-  // satisfied. This error code is reserved for serious errors.
+ 
+  // StatusCode::kInternal 
+  // 
+  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred 
+  // and some invariants expected by the underlying system have not been 
+  // satisfied. This error code is reserved for serious errors. 
   kInternal = 13,
-
-  // StatusCode::kUnavailable
-  //
-  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently
-  // unavailable and that this is most likely a transient condition. An error
-  // such as this can be corrected by retrying with a backoff scheme. Note that
-  // it is not always safe to retry non-idempotent operations.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
+ 
+  // StatusCode::kUnavailable 
+  // 
+  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently 
+  // unavailable and that this is most likely a transient condition. An error 
+  // such as this can be corrected by retrying with a backoff scheme. Note that 
+  // it is not always safe to retry non-idempotent operations. 
+  // 
+  // See the guidelines above for deciding between `kFailedPrecondition`, 
+  // `kAborted`, and `kUnavailable`. 
   kUnavailable = 14,
-
-  // StatusCode::kDataLoss
-  //
-  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or
-  // corruption has occurred. As this error is serious, proper alerting should
-  // be attached to errors such as this.
+ 
+  // StatusCode::kDataLoss 
+  // 
+  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or 
+  // corruption has occurred. As this error is serious, proper alerting should 
+  // be attached to errors such as this. 
   kDataLoss = 15,
-
-  // StatusCode::kUnauthenticated
-  //
-  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request
-  // does not have valid authentication credentials for the operation. Correct
-  // the authentication and try again.
+ 
+  // StatusCode::kUnauthenticated 
+  // 
+  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request 
+  // does not have valid authentication credentials for the operation. Correct 
+  // the authentication and try again. 
   kUnauthenticated = 16,
-
-  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_
-  //
-  // NOTE: this error code entry should not be used and you should not rely on
-  // its value, which may change.
-  //
-  // The purpose of this enumerated value is to force people who handle status
-  // codes with `switch()` statements to *not* simply enumerate all possible
-  // values, but instead provide a "default:" case. Providing such a default
-  // case ensures that code will compile when new codes are added.
+ 
+  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ 
+  // 
+  // NOTE: this error code entry should not be used and you should not rely on 
+  // its value, which may change. 
+  // 
+  // The purpose of this enumerated value is to force people who handle status 
+  // codes with `switch()` statements to *not* simply enumerate all possible 
+  // values, but instead provide a "default:" case. Providing such a default 
+  // case ensures that code will compile when new codes are added. 
   kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
 };
 
-// StatusCodeToString()
-//
+// StatusCodeToString() 
+// 
 // Returns the name for the status code, or "" if it is an unknown value.
 TString StatusCodeToString(StatusCode code);
 
-// operator<<
-//
+// operator<< 
+// 
 // Streams StatusCodeToString(code) to `os`.
 std::ostream& operator<<(std::ostream& os, StatusCode code);
 
-// y_absl::StatusToStringMode
-//
-// An `y_absl::StatusToStringMode` is an enumerated type indicating how
+// y_absl::StatusToStringMode 
+// 
+// An `y_absl::StatusToStringMode` is an enumerated type indicating how 
 // `y_absl::Status::ToString()` should construct the output string for a non-ok
-// status.
-enum class StatusToStringMode : int {
-  // ToString will not contain any extra data (such as payloads). It will only
-  // contain the error code and message, if any.
-  kWithNoExtraData = 0,
-  // ToString will contain the payloads.
-  kWithPayload = 1 << 0,
-  // ToString will include all the extra data this Status has.
-  kWithEverything = ~kWithNoExtraData,
+// status. 
+enum class StatusToStringMode : int { 
+  // ToString will not contain any extra data (such as payloads). It will only 
+  // contain the error code and message, if any. 
+  kWithNoExtraData = 0, 
+  // ToString will contain the payloads. 
+  kWithPayload = 1 << 0, 
+  // ToString will include all the extra data this Status has. 
+  kWithEverything = ~kWithNoExtraData, 
   // Default mode used by ToString. Its exact value might change in the future.
   kDefault = kWithPayload,
 };
 
-// y_absl::StatusToStringMode is specified as a bitmask type, which means the
-// following operations must be provided:
-inline constexpr StatusToStringMode operator&(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) &
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator|(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) |
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator^(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator~(StatusToStringMode arg) {
-  return static_cast<StatusToStringMode>(~static_cast<int>(arg));
-}
-inline StatusToStringMode& operator&=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs & rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator|=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs | rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs ^ rhs;
-  return lhs;
-}
-
-// y_absl::Status
-//
-// The `y_absl::Status` class is generally used to gracefully handle errors
-// across API boundaries (and in particular across RPC boundaries). Some of
-// these errors may be recoverable, but others may not. Most
-// functions which can produce a recoverable error should be designed to return
-// either an `y_absl::Status` (or the similar `y_absl::StatusOr<T>`, which holds
-// either an object of type `T` or an error).
-//
-// API developers should construct their functions to return `y_absl::OkStatus()`
-// upon success, or an `y_absl::StatusCode` upon another type of error (e.g
-// an `y_absl::StatusCode::kInvalidArgument` error). The API provides convenience
+// y_absl::StatusToStringMode is specified as a bitmask type, which means the 
+// following operations must be provided: 
+inline constexpr StatusToStringMode operator&(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) & 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator|(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) | 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator^(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^ 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator~(StatusToStringMode arg) { 
+  return static_cast<StatusToStringMode>(~static_cast<int>(arg)); 
+} 
+inline StatusToStringMode& operator&=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs & rhs; 
+  return lhs; 
+} 
+inline StatusToStringMode& operator|=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs | rhs; 
+  return lhs; 
+} 
+inline StatusToStringMode& operator^=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs ^ rhs; 
+  return lhs; 
+} 
+
+// y_absl::Status 
+// 
+// The `y_absl::Status` class is generally used to gracefully handle errors 
+// across API boundaries (and in particular across RPC boundaries). Some of 
+// these errors may be recoverable, but others may not. Most 
+// functions which can produce a recoverable error should be designed to return 
+// either an `y_absl::Status` (or the similar `y_absl::StatusOr<T>`, which holds 
+// either an object of type `T` or an error). 
+// 
+// API developers should construct their functions to return `y_absl::OkStatus()` 
+// upon success, or an `y_absl::StatusCode` upon another type of error (e.g 
+// an `y_absl::StatusCode::kInvalidArgument` error). The API provides convenience 
 // functions to construct each status code.
-//
-// Example:
-//
-// y_absl::Status myFunction(y_absl::string_view fname, ...) {
-//   ...
-//   // encounter error
-//   if (error condition) {
-//     // Construct an y_absl::StatusCode::kInvalidArgument error
-//     return y_absl::InvalidArgumentError("bad mode");
-//   }
-//   // else, return OK
-//   return y_absl::OkStatus();
-// }
-//
-// Users handling status error codes should prefer checking for an OK status
-// using the `ok()` member function. Handling multiple error codes may justify
-// use of switch statement, but only check for error codes you know how to
-// handle; do not try to exhaustively match against all canonical error codes.
-// Errors that cannot be handled should be logged and/or propagated for higher
-// levels to deal with. If you do use a switch statement, make sure that you
-// also provide a `default:` switch case, so that code does not break as other
-// canonical codes are added to the API.
-//
-// Example:
-//
-//   y_absl::Status result = DoSomething();
-//   if (!result.ok()) {
-//     LOG(ERROR) << result;
-//   }
-//
-//   // Provide a default if switching on multiple error codes
-//   switch (result.code()) {
-//     // The user hasn't authenticated. Ask them to reauth
-//     case y_absl::StatusCode::kUnauthenticated:
-//       DoReAuth();
-//       break;
-//     // The user does not have permission. Log an error.
-//     case y_absl::StatusCode::kPermissionDenied:
-//       LOG(ERROR) << result;
-//       break;
-//     // Propagate the error otherwise.
-//     default:
-//       return true;
-//   }
-//
-// An `y_absl::Status` can optionally include a payload with more information
-// about the error. Typically, this payload serves one of several purposes:
-//
-//   * It may provide more fine-grained semantic information about the error to
-//     facilitate actionable remedies.
-//   * It may provide human-readable contexual information that is more
-//     appropriate to display to an end user.
-//
-// Example:
-//
-//   y_absl::Status result = DoSomething();
-//   // Inform user to retry after 30 seconds
-//   // See more error details in googleapis/google/rpc/error_details.proto
-//   if (y_absl::IsResourceExhausted(result)) {
-//     google::rpc::RetryInfo info;
-//     info.retry_delay().seconds() = 30;
-//     // Payloads require a unique key (a URL to ensure no collisions with
-//     // other payloads), and an `y_absl::Cord` to hold the encoded data.
-//     y_absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo";
-//     result.SetPayload(url, info.SerializeAsCord());
-//     return result;
-//   }
-//
-// For documentation see https://abseil.io/docs/cpp/guides/status.
-//
-// Returned Status objects may not be ignored. status_internal.h has a forward
-// declaration of the form
-// class ABSL_MUST_USE_RESULT Status;
-class Status final {
- public:
-  // Constructors
-
-  // This default constructor creates an OK status with no message or payload.
-  // Avoid this constructor and prefer explicit construction of an OK status
-  // with `y_absl::OkStatus()`.
+// 
+// Example: 
+// 
+// y_absl::Status myFunction(y_absl::string_view fname, ...) { 
+//   ... 
+//   // encounter error 
+//   if (error condition) { 
+//     // Construct an y_absl::StatusCode::kInvalidArgument error 
+//     return y_absl::InvalidArgumentError("bad mode"); 
+//   } 
+//   // else, return OK 
+//   return y_absl::OkStatus(); 
+// } 
+// 
+// Users handling status error codes should prefer checking for an OK status 
+// using the `ok()` member function. Handling multiple error codes may justify 
+// use of switch statement, but only check for error codes you know how to 
+// handle; do not try to exhaustively match against all canonical error codes. 
+// Errors that cannot be handled should be logged and/or propagated for higher 
+// levels to deal with. If you do use a switch statement, make sure that you 
+// also provide a `default:` switch case, so that code does not break as other 
+// canonical codes are added to the API. 
+// 
+// Example: 
+// 
+//   y_absl::Status result = DoSomething(); 
+//   if (!result.ok()) { 
+//     LOG(ERROR) << result; 
+//   } 
+// 
+//   // Provide a default if switching on multiple error codes 
+//   switch (result.code()) { 
+//     // The user hasn't authenticated. Ask them to reauth 
+//     case y_absl::StatusCode::kUnauthenticated: 
+//       DoReAuth(); 
+//       break; 
+//     // The user does not have permission. Log an error. 
+//     case y_absl::StatusCode::kPermissionDenied: 
+//       LOG(ERROR) << result; 
+//       break; 
+//     // Propagate the error otherwise. 
+//     default: 
+//       return true; 
+//   } 
+// 
+// An `y_absl::Status` can optionally include a payload with more information 
+// about the error. Typically, this payload serves one of several purposes: 
+// 
+//   * It may provide more fine-grained semantic information about the error to 
+//     facilitate actionable remedies. 
+//   * It may provide human-readable contexual information that is more 
+//     appropriate to display to an end user. 
+// 
+// Example: 
+// 
+//   y_absl::Status result = DoSomething(); 
+//   // Inform user to retry after 30 seconds 
+//   // See more error details in googleapis/google/rpc/error_details.proto 
+//   if (y_absl::IsResourceExhausted(result)) { 
+//     google::rpc::RetryInfo info; 
+//     info.retry_delay().seconds() = 30; 
+//     // Payloads require a unique key (a URL to ensure no collisions with 
+//     // other payloads), and an `y_absl::Cord` to hold the encoded data. 
+//     y_absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo"; 
+//     result.SetPayload(url, info.SerializeAsCord()); 
+//     return result; 
+//   } 
+// 
+// For documentation see https://abseil.io/docs/cpp/guides/status. 
+// 
+// Returned Status objects may not be ignored. status_internal.h has a forward 
+// declaration of the form 
+// class ABSL_MUST_USE_RESULT Status; 
+class Status final { 
+ public: 
+  // Constructors 
+
+  // This default constructor creates an OK status with no message or payload. 
+  // Avoid this constructor and prefer explicit construction of an OK status 
+  // with `y_absl::OkStatus()`. 
   Status();
 
-  // Creates a status in the canonical error space with the specified
-  // `y_absl::StatusCode` and error message.  If `code == y_absl::StatusCode::kOk`,  // NOLINT
-  // `msg` is ignored and an object identical to an OK status is constructed.
+  // Creates a status in the canonical error space with the specified 
+  // `y_absl::StatusCode` and error message.  If `code == y_absl::StatusCode::kOk`,  // NOLINT 
+  // `msg` is ignored and an object identical to an OK status is constructed. 
   //
-  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
+  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT 
   // by printing a warning) if it is not.
   Status(y_absl::StatusCode code, y_absl::string_view msg);
 
   Status(const Status&);
   Status& operator=(const Status& x);
 
-  // Move operators
-
+  // Move operators 
+ 
   // The moved-from state is valid but unspecified.
   Status(Status&&) noexcept;
   Status& operator=(Status&&);
 
   ~Status();
 
-  // Status::Update()
-  //
-  // Updates the existing status with `new_status` provided that `this->ok()`.
-  // If the existing status already contains a non-OK error, this update has no
-  // effect and preserves the current data. Note that this behavior may change
-  // in the future to augment a current non-ok status with additional
-  // information about `new_status`.
-  //
-  // `Update()` provides a convenient way of keeping track of the first error
-  // encountered.
-  //
-  // Example:
-  //   // Instead of "if (overall_status.ok()) overall_status = new_status"
+  // Status::Update() 
+  //
+  // Updates the existing status with `new_status` provided that `this->ok()`. 
+  // If the existing status already contains a non-OK error, this update has no 
+  // effect and preserves the current data. Note that this behavior may change 
+  // in the future to augment a current non-ok status with additional 
+  // information about `new_status`. 
+  // 
+  // `Update()` provides a convenient way of keeping track of the first error 
+  // encountered. 
+  // 
+  // Example: 
+  //   // Instead of "if (overall_status.ok()) overall_status = new_status" 
   //   overall_status.Update(new_status);
   //
   void Update(const Status& new_status);
   void Update(Status&& new_status);
 
-  // Status::ok()
-  //
-  // Returns `true` if `this->ok()`. Prefer checking for an OK status using this
-  // member function.
+  // Status::ok() 
+  // 
+  // Returns `true` if `this->ok()`. Prefer checking for an OK status using this 
+  // member function. 
   ABSL_MUST_USE_RESULT bool ok() const;
 
-  // Status::code()
-  //
-  // Returns the canonical error code of type `y_absl::StatusCode` of this status.
+  // Status::code() 
+  // 
+  // Returns the canonical error code of type `y_absl::StatusCode` of this status. 
   y_absl::StatusCode code() const;
 
-  // Status::raw_code()
-  //
-  // Returns a raw (canonical) error code corresponding to the enum value of
-  // `google.rpc.Code` definitions within
-  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto.
-  // These values could be out of the range of canonical `y_absl::StatusCode`
-  // enum values.
-  //
-  // NOTE: This function should only be called when converting to an associated
-  // wire format. Use `Status::code()` for error handling.
+  // Status::raw_code() 
+  // 
+  // Returns a raw (canonical) error code corresponding to the enum value of 
+  // `google.rpc.Code` definitions within 
+  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto. 
+  // These values could be out of the range of canonical `y_absl::StatusCode` 
+  // enum values. 
+  // 
+  // NOTE: This function should only be called when converting to an associated 
+  // wire format. Use `Status::code()` for error handling. 
   int raw_code() const;
 
-  // Status::message()
-  //
-  // Returns the error message associated with this error code, if available.
-  // Note that this message rarely describes the error code.  It is not unusual
-  // for the error message to be the empty string. As a result, prefer
+  // Status::message() 
+  // 
+  // Returns the error message associated with this error code, if available. 
+  // Note that this message rarely describes the error code.  It is not unusual 
+  // for the error message to be the empty string. As a result, prefer 
   // `operator<<` or `Status::ToString()` for debug logging.
   y_absl::string_view message() const;
 
   friend bool operator==(const Status&, const Status&);
   friend bool operator!=(const Status&, const Status&);
 
-  // Status::ToString()
-  //
-  // Returns a string based on the `mode`. By default, it returns combination of
-  // the error code name, the message and any associated payload messages. This
-  // string is designed simply to be human readable and its exact format should
-  // not be load bearing. Do not depend on the exact format of the result of
-  // `ToString()` which is subject to change.
-  //
-  // The printed code name and the message are generally substrings of the
-  // result, and the payloads to be printed use the status payload printer
-  // mechanism (which is internal).
-  TString ToString(
+  // Status::ToString() 
+  // 
+  // Returns a string based on the `mode`. By default, it returns combination of 
+  // the error code name, the message and any associated payload messages. This 
+  // string is designed simply to be human readable and its exact format should 
+  // not be load bearing. Do not depend on the exact format of the result of 
+  // `ToString()` which is subject to change. 
+  // 
+  // The printed code name and the message are generally substrings of the 
+  // result, and the payloads to be printed use the status payload printer 
+  // mechanism (which is internal). 
+  TString ToString( 
       StatusToStringMode mode = StatusToStringMode::kDefault) const;
 
-  // Status::IgnoreError()
-  //
+  // Status::IgnoreError() 
+  // 
   // Ignores any errors. This method does nothing except potentially suppress
   // complaints from any tools that are checking that errors are not dropped on
   // the floor.
   void IgnoreError() const;
 
-  // swap()
-  //
-  // Swap the contents of one status with another.
+  // swap() 
+  // 
+  // Swap the contents of one status with another. 
   friend void swap(Status& a, Status& b);
 
-  //----------------------------------------------------------------------------
-  // Payload Management APIs
-  //----------------------------------------------------------------------------
-
-  // A payload may be attached to a status to provide additional context to an
-  // error that may not be satisifed by an existing `y_absl::StatusCode`.
-  // Typically, this payload serves one of several purposes:
-  //
-  //   * It may provide more fine-grained semantic information about the error
-  //     to facilitate actionable remedies.
-  //   * It may provide human-readable contexual information that is more
-  //     appropriate to display to an end user.
-  //
-  // A payload consists of a [key,value] pair, where the key is a string
-  // referring to a unique "type URL" and the value is an object of type
-  // `y_absl::Cord` to hold the contextual data.
-  //
-  // The "type URL" should be unique and follow the format of a URL
-  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some
-  // documentation or schema on how to interpret its associated data. For
-  // example, the default type URL for a protobuf message type is
-  // "type.googleapis.com/packagename.messagename". Other custom wire formats
-  // should define the format of type URL in a similar practice so as to
-  // minimize the chance of conflict between type URLs.
-  // Users should ensure that the type URL can be mapped to a concrete
+  //---------------------------------------------------------------------------- 
+  // Payload Management APIs 
+  //---------------------------------------------------------------------------- 
+
+  // A payload may be attached to a status to provide additional context to an 
+  // error that may not be satisifed by an existing `y_absl::StatusCode`. 
+  // Typically, this payload serves one of several purposes: 
+  // 
+  //   * It may provide more fine-grained semantic information about the error 
+  //     to facilitate actionable remedies. 
+  //   * It may provide human-readable contexual information that is more 
+  //     appropriate to display to an end user. 
+  // 
+  // A payload consists of a [key,value] pair, where the key is a string 
+  // referring to a unique "type URL" and the value is an object of type 
+  // `y_absl::Cord` to hold the contextual data. 
+  // 
+  // The "type URL" should be unique and follow the format of a URL 
+  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some 
+  // documentation or schema on how to interpret its associated data. For 
+  // example, the default type URL for a protobuf message type is 
+  // "type.googleapis.com/packagename.messagename". Other custom wire formats 
+  // should define the format of type URL in a similar practice so as to 
+  // minimize the chance of conflict between type URLs. 
+  // Users should ensure that the type URL can be mapped to a concrete 
   // C++ type if they want to deserialize the payload and read it effectively.
-  //
-  // To attach a payload to a status object, call `Status::SetPayload()`,
-  // passing it the type URL and an `y_absl::Cord` of associated data. Similarly,
-  // to extract the payload from a status, call `Status::GetPayload()`. You
-  // may attach multiple payloads (with differing type URLs) to any given
-  // status object, provided that the status is currently exhibiting an error
-  // code (i.e. is not OK).
-
-  // Status::GetPayload()
-  //
-  // Gets the payload of a status given its unique `type_url` key, if present.
+  // 
+  // To attach a payload to a status object, call `Status::SetPayload()`, 
+  // passing it the type URL and an `y_absl::Cord` of associated data. Similarly, 
+  // to extract the payload from a status, call `Status::GetPayload()`. You 
+  // may attach multiple payloads (with differing type URLs) to any given 
+  // status object, provided that the status is currently exhibiting an error 
+  // code (i.e. is not OK). 
+
+  // Status::GetPayload() 
+  // 
+  // Gets the payload of a status given its unique `type_url` key, if present. 
   y_absl::optional<y_absl::Cord> GetPayload(y_absl::string_view type_url) const;
 
-  // Status::SetPayload()
-  //
-  // Sets the payload for a non-ok status using a `type_url` key, overwriting
-  // any existing payload for that `type_url`.
+  // Status::SetPayload() 
   //
-  // NOTE: This function does nothing if the Status is ok.
+  // Sets the payload for a non-ok status using a `type_url` key, overwriting 
+  // any existing payload for that `type_url`. 
+  // 
+  // NOTE: This function does nothing if the Status is ok. 
   void SetPayload(y_absl::string_view type_url, y_absl::Cord payload);
 
-  // Status::ErasePayload()
-  //
-  // Erases the payload corresponding to the `type_url` key.  Returns `true` if
+  // Status::ErasePayload() 
+  // 
+  // Erases the payload corresponding to the `type_url` key.  Returns `true` if 
   // the payload was present.
   bool ErasePayload(y_absl::string_view type_url);
 
-  // Status::ForEachPayload()
-  //
-  // Iterates over the stored payloads and calls the
-  // `visitor(type_key, payload)` callable for each one.
+  // Status::ForEachPayload() 
   //
-  // NOTE: The order of calls to `visitor()` is not specified and may change at
+  // Iterates over the stored payloads and calls the 
+  // `visitor(type_key, payload)` callable for each one. 
+  // 
+  // NOTE: The order of calls to `visitor()` is not specified and may change at 
   // any time.
   //
-  // NOTE: Any mutation on the same 'y_absl::Status' object during visitation is
+  // NOTE: Any mutation on the same 'y_absl::Status' object during visitation is 
   // forbidden and could result in undefined behavior.
   void ForEachPayload(
       y_absl::FunctionRef<void(y_absl::string_view, const y_absl::Cord&)> visitor)
@@ -613,9 +613,9 @@ class Status final {
   status_internal::Payloads* GetPayloads();
 
   // Takes ownership of payload.
-  static uintptr_t NewRep(
-      y_absl::StatusCode code, y_absl::string_view msg,
-      std::unique_ptr<status_internal::Payloads> payload);
+  static uintptr_t NewRep( 
+      y_absl::StatusCode code, y_absl::string_view msg, 
+      std::unique_ptr<status_internal::Payloads> payload); 
   static bool EqualsSlow(const y_absl::Status& a, const y_absl::Status& b);
 
   // MSVC 14.0 limitation requires the const.
@@ -644,7 +644,7 @@ class Status final {
   static uintptr_t PointerToRep(status_internal::StatusRep* r);
   static status_internal::StatusRep* RepToPointer(uintptr_t r);
 
-  TString ToStringSlow(StatusToStringMode mode) const;
+  TString ToStringSlow(StatusToStringMode mode) const; 
 
   // Status supports two different representations.
   //  - When the low bit is off it is an inlined representation.
@@ -657,93 +657,93 @@ class Status final {
   uintptr_t rep_;
 };
 
-// OkStatus()
-//
-// Returns an OK status, equivalent to a default constructed instance. Prefer
-// usage of `y_absl::OkStatus()` when constructing such an OK status.
+// OkStatus() 
+// 
+// Returns an OK status, equivalent to a default constructed instance. Prefer 
+// usage of `y_absl::OkStatus()` when constructing such an OK status. 
 Status OkStatus();
 
-// operator<<()
-//
+// operator<<() 
+// 
 // Prints a human-readable representation of `x` to `os`.
 std::ostream& operator<<(std::ostream& os, const Status& x);
 
-// IsAborted()
-// IsAlreadyExists()
-// IsCancelled()
-// IsDataLoss()
-// IsDeadlineExceeded()
-// IsFailedPrecondition()
-// IsInternal()
-// IsInvalidArgument()
-// IsNotFound()
-// IsOutOfRange()
-// IsPermissionDenied()
-// IsResourceExhausted()
-// IsUnauthenticated()
-// IsUnavailable()
-// IsUnimplemented()
-// IsUnknown()
-//
-// These convenience functions return `true` if a given status matches the
-// `y_absl::StatusCode` error code of its associated function.
-ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
-ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
-ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
-ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
-ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
-ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
-ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
-
-// AbortedError()
-// AlreadyExistsError()
-// CancelledError()
-// DataLossError()
-// DeadlineExceededError()
-// FailedPreconditionError()
-// InternalError()
-// InvalidArgumentError()
-// NotFoundError()
-// OutOfRangeError()
-// PermissionDeniedError()
-// ResourceExhaustedError()
-// UnauthenticatedError()
-// UnavailableError()
-// UnimplementedError()
-// UnknownError()
-//
-// These convenience functions create an `y_absl::Status` object with an error
-// code as indicated by the associated function name, using the error message
-// passed in `message`.
-Status AbortedError(y_absl::string_view message);
-Status AlreadyExistsError(y_absl::string_view message);
-Status CancelledError(y_absl::string_view message);
-Status DataLossError(y_absl::string_view message);
-Status DeadlineExceededError(y_absl::string_view message);
-Status FailedPreconditionError(y_absl::string_view message);
-Status InternalError(y_absl::string_view message);
-Status InvalidArgumentError(y_absl::string_view message);
-Status NotFoundError(y_absl::string_view message);
-Status OutOfRangeError(y_absl::string_view message);
-Status PermissionDeniedError(y_absl::string_view message);
-Status ResourceExhaustedError(y_absl::string_view message);
-Status UnauthenticatedError(y_absl::string_view message);
-Status UnavailableError(y_absl::string_view message);
-Status UnimplementedError(y_absl::string_view message);
-Status UnknownError(y_absl::string_view message);
-
-//------------------------------------------------------------------------------
+// IsAborted() 
+// IsAlreadyExists() 
+// IsCancelled() 
+// IsDataLoss() 
+// IsDeadlineExceeded() 
+// IsFailedPrecondition() 
+// IsInternal() 
+// IsInvalidArgument() 
+// IsNotFound() 
+// IsOutOfRange() 
+// IsPermissionDenied() 
+// IsResourceExhausted() 
+// IsUnauthenticated() 
+// IsUnavailable() 
+// IsUnimplemented() 
+// IsUnknown() 
+// 
+// These convenience functions return `true` if a given status matches the 
+// `y_absl::StatusCode` error code of its associated function. 
+ABSL_MUST_USE_RESULT bool IsAborted(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsInternal(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status); 
+ 
+// AbortedError() 
+// AlreadyExistsError() 
+// CancelledError() 
+// DataLossError() 
+// DeadlineExceededError() 
+// FailedPreconditionError() 
+// InternalError() 
+// InvalidArgumentError() 
+// NotFoundError() 
+// OutOfRangeError() 
+// PermissionDeniedError() 
+// ResourceExhaustedError() 
+// UnauthenticatedError() 
+// UnavailableError() 
+// UnimplementedError() 
+// UnknownError() 
+// 
+// These convenience functions create an `y_absl::Status` object with an error 
+// code as indicated by the associated function name, using the error message 
+// passed in `message`. 
+Status AbortedError(y_absl::string_view message); 
+Status AlreadyExistsError(y_absl::string_view message); 
+Status CancelledError(y_absl::string_view message); 
+Status DataLossError(y_absl::string_view message); 
+Status DeadlineExceededError(y_absl::string_view message); 
+Status FailedPreconditionError(y_absl::string_view message); 
+Status InternalError(y_absl::string_view message); 
+Status InvalidArgumentError(y_absl::string_view message); 
+Status NotFoundError(y_absl::string_view message); 
+Status OutOfRangeError(y_absl::string_view message); 
+Status PermissionDeniedError(y_absl::string_view message); 
+Status ResourceExhaustedError(y_absl::string_view message); 
+Status UnauthenticatedError(y_absl::string_view message); 
+Status UnavailableError(y_absl::string_view message); 
+Status UnimplementedError(y_absl::string_view message); 
+Status UnknownError(y_absl::string_view message); 
+ 
+//------------------------------------------------------------------------------ 
 // Implementation details follow
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------ 
 
 inline Status::Status() : rep_(CodeToInlinedRep(y_absl::StatusCode::kOk)) {}
 
@@ -767,11 +767,11 @@ inline Status::Status(Status&& x) noexcept : rep_(x.rep_) {
 
 inline Status& Status::operator=(Status&& x) {
   uintptr_t old_rep = rep_;
-  if (x.rep_ != old_rep) {
-    rep_ = x.rep_;
-    x.rep_ = MovedFromRep();
-    Unref(old_rep);
-  }
+  if (x.rep_ != old_rep) { 
+    rep_ = x.rep_; 
+    x.rep_ = MovedFromRep(); 
+    Unref(old_rep); 
+  } 
   return *this;
 }
 
@@ -808,8 +808,8 @@ inline bool operator!=(const Status& lhs, const Status& rhs) {
   return !(lhs == rhs);
 }
 
-inline TString Status::ToString(StatusToStringMode mode) const {
-  return ok() ? "OK" : ToStringSlow(mode);
+inline TString Status::ToString(StatusToStringMode mode) const { 
+  return ok() ? "OK" : ToStringSlow(mode); 
 }
 
 inline void Status::IgnoreError() const {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
index 6990ff6e8d..d22f50de8b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
@@ -16,21 +16,21 @@
 #include <atomic>
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/internal/atomic_hook.h"
+#include "y_absl/base/internal/atomic_hook.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace status_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-static y_absl::base_internal::AtomicHook<StatusPayloadPrinter> storage;
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+static y_absl::base_internal::AtomicHook<StatusPayloadPrinter> storage; 
 
 void SetStatusPayloadPrinter(StatusPayloadPrinter printer) {
-  storage.Store(printer);
+  storage.Store(printer); 
 }
 
 StatusPayloadPrinter GetStatusPayloadPrinter() {
-  return storage.Load();
+  return storage.Load(); 
 }
 
 }  // namespace status_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
index 03e6d1cec4..ac881e65b5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
@@ -1,32 +1,32 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "y_absl/status/statusor.h"
-
-#include <cstdlib>
-#include <utility>
-
+// Copyright 2020 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+#include "y_absl/status/statusor.h" 
+ 
+#include <cstdlib> 
+#include <utility> 
+ 
 #include "y_absl/base/call_once.h"
-#include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/status/status.h"
-#include "y_absl/strings/str_cat.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-BadStatusOrAccess::BadStatusOrAccess(y_absl::Status status)
-    : status_(std::move(status)) {}
-
+#include "y_absl/base/internal/raw_logging.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/strings/str_cat.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+BadStatusOrAccess::BadStatusOrAccess(y_absl::Status status) 
+    : status_(std::move(status)) {} 
+ 
 BadStatusOrAccess::BadStatusOrAccess(const BadStatusOrAccess& other)
     : status_(other.status_) {}
 
@@ -52,52 +52,52 @@ BadStatusOrAccess& BadStatusOrAccess::operator=(BadStatusOrAccess&& other) {
 BadStatusOrAccess::BadStatusOrAccess(BadStatusOrAccess&& other)
     : status_(std::move(other.status_)) {}
 
-const char* BadStatusOrAccess::what() const noexcept {
+const char* BadStatusOrAccess::what() const noexcept { 
   InitWhat();
   return what_.c_str();
-}
-
-const y_absl::Status& BadStatusOrAccess::status() const { return status_; }
-
+} 
+ 
+const y_absl::Status& BadStatusOrAccess::status() const { return status_; } 
+ 
 void BadStatusOrAccess::InitWhat() const {
   y_absl::call_once(init_what_, [this] {
     what_ = y_absl::StrCat("Bad StatusOr access: ", status_.ToString());
   });
 }
 
-namespace internal_statusor {
-
-void Helper::HandleInvalidStatusCtorArg(y_absl::Status* status) {
-  const char* kMessage =
-      "An OK status is not a valid constructor argument to StatusOr<T>";
-#ifdef NDEBUG
-  ABSL_INTERNAL_LOG(ERROR, kMessage);
-#else
-  ABSL_INTERNAL_LOG(FATAL, kMessage);
-#endif
-  // In optimized builds, we will fall back to InternalError.
-  *status = y_absl::InternalError(kMessage);
-}
-
-void Helper::Crash(const y_absl::Status& status) {
-  ABSL_INTERNAL_LOG(
-      FATAL,
-      y_absl::StrCat("Attempting to fetch value instead of handling error ",
-                   status.ToString()));
-}
-
-void ThrowBadStatusOrAccess(y_absl::Status status) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  throw y_absl::BadStatusOrAccess(std::move(status));
-#else
-  ABSL_INTERNAL_LOG(
-      FATAL,
-      y_absl::StrCat("Attempting to fetch value instead of handling error ",
-                   status.ToString()));
-  std::abort();
-#endif
-}
-
-}  // namespace internal_statusor
-ABSL_NAMESPACE_END
-}  // namespace y_absl
+namespace internal_statusor { 
+ 
+void Helper::HandleInvalidStatusCtorArg(y_absl::Status* status) { 
+  const char* kMessage = 
+      "An OK status is not a valid constructor argument to StatusOr<T>"; 
+#ifdef NDEBUG 
+  ABSL_INTERNAL_LOG(ERROR, kMessage); 
+#else 
+  ABSL_INTERNAL_LOG(FATAL, kMessage); 
+#endif 
+  // In optimized builds, we will fall back to InternalError. 
+  *status = y_absl::InternalError(kMessage); 
+} 
+ 
+void Helper::Crash(const y_absl::Status& status) { 
+  ABSL_INTERNAL_LOG( 
+      FATAL, 
+      y_absl::StrCat("Attempting to fetch value instead of handling error ", 
+                   status.ToString())); 
+} 
+ 
+void ThrowBadStatusOrAccess(y_absl::Status status) { 
+#ifdef ABSL_HAVE_EXCEPTIONS 
+  throw y_absl::BadStatusOrAccess(std::move(status)); 
+#else 
+  ABSL_INTERNAL_LOG( 
+      FATAL, 
+      y_absl::StrCat("Attempting to fetch value instead of handling error ", 
+                   status.ToString())); 
+  std::abort(); 
+#endif 
+} 
+ 
+}  // namespace internal_statusor 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
index 23e1b8a6e4..4931a7a837 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
@@ -1,770 +1,770 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: statusor.h
-// -----------------------------------------------------------------------------
-//
-// An `y_absl::StatusOr<T>` represents a union of an `y_absl::Status` object
-// and an object of type `T`. The `y_absl::StatusOr<T>` will either contain an
-// object of type `T` (indicating a successful operation), or an error (of type
-// `y_absl::Status`) explaining why such a value is not present.
-//
-// In general, check the success of an operation returning an
-// `y_absl::StatusOr<T>` like you would an `y_absl::Status` by using the `ok()`
-// member function.
-//
-// Example:
-//
-//   StatusOr<Foo> result = Calculation();
-//   if (result.ok()) {
-//     result->DoSomethingCool();
-//   } else {
-//     LOG(ERROR) << result.status();
-//   }
-#ifndef ABSL_STATUS_STATUSOR_H_
-#define ABSL_STATUS_STATUSOR_H_
-
-#include <exception>
-#include <initializer_list>
-#include <new>
-#include <util/generic/string.h>
-#include <type_traits>
-#include <utility>
-
-#include "y_absl/base/attributes.h"
+// Copyright 2020 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: statusor.h 
+// ----------------------------------------------------------------------------- 
+// 
+// An `y_absl::StatusOr<T>` represents a union of an `y_absl::Status` object 
+// and an object of type `T`. The `y_absl::StatusOr<T>` will either contain an 
+// object of type `T` (indicating a successful operation), or an error (of type 
+// `y_absl::Status`) explaining why such a value is not present. 
+// 
+// In general, check the success of an operation returning an 
+// `y_absl::StatusOr<T>` like you would an `y_absl::Status` by using the `ok()` 
+// member function. 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = Calculation(); 
+//   if (result.ok()) { 
+//     result->DoSomethingCool(); 
+//   } else { 
+//     LOG(ERROR) << result.status(); 
+//   } 
+#ifndef ABSL_STATUS_STATUSOR_H_ 
+#define ABSL_STATUS_STATUSOR_H_ 
+ 
+#include <exception> 
+#include <initializer_list> 
+#include <new> 
+#include <util/generic/string.h> 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/call_once.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/status/internal/statusor_internal.h"
-#include "y_absl/status/status.h"
-#include "y_absl/types/variant.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-// BadStatusOrAccess
-//
-// This class defines the type of object to throw (if exceptions are enabled),
-// when accessing the value of an `y_absl::StatusOr<T>` object that does not
-// contain a value. This behavior is analogous to that of
-// `std::bad_optional_access` in the case of accessing an invalid
-// `std::optional` value.
-//
-// Example:
-//
-// try {
-//   y_absl::StatusOr<int> v = FetchInt();
-//   DoWork(v.value());  // Accessing value() when not "OK" may throw
-// } catch (y_absl::BadStatusOrAccess& ex) {
-//   LOG(ERROR) << ex.status();
-// }
-class BadStatusOrAccess : public std::exception {
- public:
-  explicit BadStatusOrAccess(y_absl::Status status);
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/status/internal/statusor_internal.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/types/variant.h" 
+#include "y_absl/utility/utility.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+// BadStatusOrAccess 
+// 
+// This class defines the type of object to throw (if exceptions are enabled), 
+// when accessing the value of an `y_absl::StatusOr<T>` object that does not 
+// contain a value. This behavior is analogous to that of 
+// `std::bad_optional_access` in the case of accessing an invalid 
+// `std::optional` value. 
+// 
+// Example: 
+// 
+// try { 
+//   y_absl::StatusOr<int> v = FetchInt(); 
+//   DoWork(v.value());  // Accessing value() when not "OK" may throw 
+// } catch (y_absl::BadStatusOrAccess& ex) { 
+//   LOG(ERROR) << ex.status(); 
+// } 
+class BadStatusOrAccess : public std::exception { 
+ public: 
+  explicit BadStatusOrAccess(y_absl::Status status); 
   ~BadStatusOrAccess() override = default;
-
+ 
   BadStatusOrAccess(const BadStatusOrAccess& other);
   BadStatusOrAccess& operator=(const BadStatusOrAccess& other);
   BadStatusOrAccess(BadStatusOrAccess&& other);
   BadStatusOrAccess& operator=(BadStatusOrAccess&& other);
 
-  // BadStatusOrAccess::what()
-  //
-  // Returns the associated explanatory string of the `y_absl::StatusOr<T>`
+  // BadStatusOrAccess::what() 
+  // 
+  // Returns the associated explanatory string of the `y_absl::StatusOr<T>` 
   // object's error code. This function contains information about the failing
   // status, but its exact formatting may change and should not be depended on.
-  //
-  // The pointer of this string is guaranteed to be valid until any non-const
-  // function is invoked on the exception object.
-  const char* what() const noexcept override;
-
-  // BadStatusOrAccess::status()
-  //
-  // Returns the associated `y_absl::Status` of the `y_absl::StatusOr<T>` object's
-  // error.
-  const y_absl::Status& status() const;
-
- private:
+  // 
+  // The pointer of this string is guaranteed to be valid until any non-const 
+  // function is invoked on the exception object. 
+  const char* what() const noexcept override; 
+ 
+  // BadStatusOrAccess::status() 
+  // 
+  // Returns the associated `y_absl::Status` of the `y_absl::StatusOr<T>` object's 
+  // error. 
+  const y_absl::Status& status() const; 
+ 
+ private: 
   void InitWhat() const;
 
-  y_absl::Status status_;
+  y_absl::Status status_; 
   mutable y_absl::once_flag init_what_;
   mutable TString what_;
-};
-
-// Returned StatusOr objects may not be ignored.
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-// y_absl::StatusOr<T>
-//
-// The `y_absl::StatusOr<T>` class template is a union of an `y_absl::Status` object
-// and an object of type `T`. The `y_absl::StatusOr<T>` models an object that is
-// either a usable object, or an error (of type `y_absl::Status`) explaining why
-// such an object is not present. An `y_absl::StatusOr<T>` is typically the return
-// value of a function which may fail.
-//
-// An `y_absl::StatusOr<T>` can never hold an "OK" status (an
-// `y_absl::StatusCode::kOk` value); instead, the presence of an object of type
-// `T` indicates success. Instead of checking for a `kOk` value, use the
-// `y_absl::StatusOr<T>::ok()` member function. (It is for this reason, and code
-// readability, that using the `ok()` function is preferred for `y_absl::Status`
-// as well.)
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   if (result.ok()) {
-//     result->DoSomethingCool();
-//   } else {
-//     LOG(ERROR) << result.status();
-//   }
-//
-// Accessing the object held by an `y_absl::StatusOr<T>` should be performed via
-// `operator*` or `operator->`, after a call to `ok()` confirms that the
-// `y_absl::StatusOr<T>` holds an object of type `T`:
-//
-// Example:
-//
-//   y_absl::StatusOr<int> i = GetCount();
-//   if (i.ok()) {
-//     updated_total += *i
-//   }
-//
-// NOTE: using `y_absl::StatusOr<T>::value()` when no valid value is present will
-// throw an exception if exceptions are enabled or terminate the process when
-// exceptions are not enabled.
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   const Foo& foo = result.value();    // Crash/exception if no value present
-//   foo.DoSomethingCool();
-//
-// A `y_absl::StatusOr<T*>` can be constructed from a null pointer like any other
-// pointer value, and the result will be that `ok()` returns `true` and
-// `value()` returns `nullptr`. Checking the value of pointer in an
-// `y_absl::StatusOr<T>` generally requires a bit more care, to ensure both that a
-// value is present and that value is not null:
-//
-//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
-//  if (!result.ok()) {
-//    LOG(ERROR) << result.status();
-//  } else if (*result == nullptr) {
-//    LOG(ERROR) << "Unexpected null pointer";
-//  } else {
-//    (*result)->DoSomethingCool();
-//  }
-//
-// Example factory implementation returning StatusOr<T>:
-//
-//  StatusOr<Foo> FooFactory::MakeFoo(int arg) {
-//    if (arg <= 0) {
-//      return y_absl::Status(y_absl::StatusCode::kInvalidArgument,
-//                          "Arg must be positive");
-//    }
-//    return Foo(arg);
-//  }
-template <typename T>
-class StatusOr : private internal_statusor::StatusOrData<T>,
-                 private internal_statusor::CopyCtorBase<T>,
-                 private internal_statusor::MoveCtorBase<T>,
-                 private internal_statusor::CopyAssignBase<T>,
-                 private internal_statusor::MoveAssignBase<T> {
-  template <typename U>
-  friend class StatusOr;
-
-  typedef internal_statusor::StatusOrData<T> Base;
-
- public:
-  // StatusOr<T>::value_type
-  //
-  // This instance data provides a generic `value_type` member for use within
-  // generic programming. This usage is analogous to that of
-  // `optional::value_type` in the case of `std::optional`.
-  typedef T value_type;
-
-  // Constructors
-
-  // Constructs a new `y_absl::StatusOr` with an `y_absl::StatusCode::kUnknown`
-  // status. This constructor is marked 'explicit' to prevent usages in return
-  // values such as 'return {};', under the misconception that
-  // `y_absl::StatusOr<std::vector<int>>` will be initialized with an empty
-  // vector, instead of an `y_absl::StatusCode::kUnknown` error code.
-  explicit StatusOr();
-
-  // `StatusOr<T>` is copy constructible if `T` is copy constructible.
-  StatusOr(const StatusOr&) = default;
-  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy
-  // assignable.
-  StatusOr& operator=(const StatusOr&) = default;
-
-  // `StatusOr<T>` is move constructible if `T` is move constructible.
-  StatusOr(StatusOr&&) = default;
-  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move
-  // assignable.
-  StatusOr& operator=(StatusOr&&) = default;
-
-  // Converting Constructors
-
-  // Constructs a new `y_absl::StatusOr<T>` from an `y_absl::StatusOr<U>`, when `T`
-  // is constructible from `U`. To avoid ambiguity, these constructors are
-  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor
-  // is explicit if and only if the corresponding construction of `T` from `U`
-  // is explicit. (This constructor inherits its explicitness from the
-  // underlying constructor.)
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_convertible<const U&, T>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(const StatusOr<U>& other)  // NOLINT
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              y_absl::negation<std::is_convertible<const U&, T>>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(const StatusOr<U>& other)
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_convertible<U&&, T>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(StatusOr<U>&& other)  // NOLINT
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              y_absl::negation<std::is_convertible<U&&, T>>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(StatusOr<U>&& other)
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-
-  // Converting Assignment Operators
-
-  // Creates an `y_absl::StatusOr<T>` through assignment from an
-  // `y_absl::StatusOr<U>` when:
-  //
-  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` are OK by assigning
-  //     `U` to `T` directly.
-  //   * `y_absl::StatusOr<T>` is OK and `y_absl::StatusOr<U>` contains an error
-  //      code by destroying `y_absl::StatusOr<T>`'s value and assigning from
-  //      `y_absl::StatusOr<U>'
-  //   * `y_absl::StatusOr<T>` contains an error code and `y_absl::StatusOr<U>` is
-  //      OK by directly initializing `T` from `U`.
-  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` contain an error
-  //     code by assigning the `Status` in `y_absl::StatusOr<U>` to
-  //     `y_absl::StatusOr<T>`
-  //
-  // These overloads only apply if `y_absl::StatusOr<T>` is constructible and
-  // assignable from `y_absl::StatusOr<U>` and `StatusOr<T>` cannot be directly
-  // assigned from `StatusOr<U>`.
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_assignable<T, const U&>,
-              y_absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(const StatusOr<U>& other) {
-    this->Assign(other);
-    return *this;
-  }
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_assignable<T, U&&>,
-              y_absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(StatusOr<U>&& other) {
-    this->Assign(std::move(other));
-    return *this;
-  }
-
-  // Constructs a new `y_absl::StatusOr<T>` with a non-ok status. After calling
-  // this constructor, `this->ok()` will be `false` and calls to `value()` will
-  // crash, or produce an exception if exceptions are enabled.
-  //
-  // The constructor also takes any type `U` that is convertible to
-  // `y_absl::Status`. This constructor is explicit if an only if `U` is not of
-  // type `y_absl::Status` and the conversion from `U` to `Status` is explicit.
-  //
-  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed.
-  // In optimized builds, passing y_absl::OkStatus() here will have the effect
-  // of passing y_absl::StatusCode::kInternal as a fallback.
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              std::is_convertible<U&&, y_absl::Status>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              std::is_convertible<U&&, y_absl::Status>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr& operator=(U&& v) {
-    this->AssignStatus(std::forward<U>(v));
-    return *this;
-  }
-
-  // Perfect-forwarding value assignment operator.
-
-  // If `*this` contains a `T` value before the call, the contained value is
-  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized
-  // from `std::forward<U>(v)`.
-  // This function does not participate in overload unless:
-  // 1. `std::is_constructible_v<T, U>` is true,
-  // 2. `std::is_assignable_v<T&, U>` is true.
-  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false.
-  // 4. Assigning `U` to `T` is not ambiguous:
-  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from
-  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and
-  //  ambiguous thus will fail to compile. For example:
-  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true
-  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false
-  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`?
-  template <
-      typename U = T,
-      typename = typename std::enable_if<y_absl::conjunction<
-          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>,
-          y_absl::disjunction<
-              std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, T>,
-              y_absl::conjunction<
-                  y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-                  y_absl::negation<internal_statusor::
-                                     HasConversionOperatorToStatusOr<T, U&&>>>>,
-          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type>
-  StatusOr& operator=(U&& v) {
-    this->Assign(std::forward<U>(v));
-    return *this;
-  }
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(args...)` constructor.
-  template <typename... Args>
-  explicit StatusOr(y_absl::in_place_t, Args&&... args);
-  template <typename U, typename... Args>
-  explicit StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist,
-                    Args&&... args);
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(U)` (direct-initialization) constructor. This constructor is only valid
-  // if `T` can be constructed from a `U`. Can accept move or copy constructors.
-  //
-  // This constructor is explicit if `U` is not convertible to `T`. To avoid
+}; 
+ 
+// Returned StatusOr objects may not be ignored. 
+template <typename T> 
+class ABSL_MUST_USE_RESULT StatusOr; 
+ 
+// y_absl::StatusOr<T> 
+// 
+// The `y_absl::StatusOr<T>` class template is a union of an `y_absl::Status` object 
+// and an object of type `T`. The `y_absl::StatusOr<T>` models an object that is 
+// either a usable object, or an error (of type `y_absl::Status`) explaining why 
+// such an object is not present. An `y_absl::StatusOr<T>` is typically the return 
+// value of a function which may fail. 
+// 
+// An `y_absl::StatusOr<T>` can never hold an "OK" status (an 
+// `y_absl::StatusCode::kOk` value); instead, the presence of an object of type 
+// `T` indicates success. Instead of checking for a `kOk` value, use the 
+// `y_absl::StatusOr<T>::ok()` member function. (It is for this reason, and code 
+// readability, that using the `ok()` function is preferred for `y_absl::Status` 
+// as well.) 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+//   if (result.ok()) { 
+//     result->DoSomethingCool(); 
+//   } else { 
+//     LOG(ERROR) << result.status(); 
+//   } 
+// 
+// Accessing the object held by an `y_absl::StatusOr<T>` should be performed via 
+// `operator*` or `operator->`, after a call to `ok()` confirms that the 
+// `y_absl::StatusOr<T>` holds an object of type `T`: 
+// 
+// Example: 
+// 
+//   y_absl::StatusOr<int> i = GetCount(); 
+//   if (i.ok()) { 
+//     updated_total += *i 
+//   } 
+// 
+// NOTE: using `y_absl::StatusOr<T>::value()` when no valid value is present will 
+// throw an exception if exceptions are enabled or terminate the process when 
+// exceptions are not enabled. 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+//   const Foo& foo = result.value();    // Crash/exception if no value present 
+//   foo.DoSomethingCool(); 
+// 
+// A `y_absl::StatusOr<T*>` can be constructed from a null pointer like any other 
+// pointer value, and the result will be that `ok()` returns `true` and 
+// `value()` returns `nullptr`. Checking the value of pointer in an 
+// `y_absl::StatusOr<T>` generally requires a bit more care, to ensure both that a 
+// value is present and that value is not null: 
+// 
+//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg); 
+//  if (!result.ok()) { 
+//    LOG(ERROR) << result.status(); 
+//  } else if (*result == nullptr) { 
+//    LOG(ERROR) << "Unexpected null pointer"; 
+//  } else { 
+//    (*result)->DoSomethingCool(); 
+//  } 
+// 
+// Example factory implementation returning StatusOr<T>: 
+// 
+//  StatusOr<Foo> FooFactory::MakeFoo(int arg) { 
+//    if (arg <= 0) { 
+//      return y_absl::Status(y_absl::StatusCode::kInvalidArgument, 
+//                          "Arg must be positive"); 
+//    } 
+//    return Foo(arg); 
+//  } 
+template <typename T> 
+class StatusOr : private internal_statusor::StatusOrData<T>, 
+                 private internal_statusor::CopyCtorBase<T>, 
+                 private internal_statusor::MoveCtorBase<T>, 
+                 private internal_statusor::CopyAssignBase<T>, 
+                 private internal_statusor::MoveAssignBase<T> { 
+  template <typename U> 
+  friend class StatusOr; 
+ 
+  typedef internal_statusor::StatusOrData<T> Base; 
+ 
+ public: 
+  // StatusOr<T>::value_type 
+  // 
+  // This instance data provides a generic `value_type` member for use within 
+  // generic programming. This usage is analogous to that of 
+  // `optional::value_type` in the case of `std::optional`. 
+  typedef T value_type; 
+ 
+  // Constructors 
+ 
+  // Constructs a new `y_absl::StatusOr` with an `y_absl::StatusCode::kUnknown` 
+  // status. This constructor is marked 'explicit' to prevent usages in return 
+  // values such as 'return {};', under the misconception that 
+  // `y_absl::StatusOr<std::vector<int>>` will be initialized with an empty 
+  // vector, instead of an `y_absl::StatusCode::kUnknown` error code. 
+  explicit StatusOr(); 
+ 
+  // `StatusOr<T>` is copy constructible if `T` is copy constructible. 
+  StatusOr(const StatusOr&) = default; 
+  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy 
+  // assignable. 
+  StatusOr& operator=(const StatusOr&) = default; 
+ 
+  // `StatusOr<T>` is move constructible if `T` is move constructible. 
+  StatusOr(StatusOr&&) = default; 
+  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move 
+  // assignable. 
+  StatusOr& operator=(StatusOr&&) = default; 
+ 
+  // Converting Constructors 
+ 
+  // Constructs a new `y_absl::StatusOr<T>` from an `y_absl::StatusOr<U>`, when `T` 
+  // is constructible from `U`. To avoid ambiguity, these constructors are 
+  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor 
+  // is explicit if and only if the corresponding construction of `T` from `U` 
+  // is explicit. (This constructor inherits its explicitness from the 
+  // underlying constructor.) 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              std::is_convertible<const U&, T>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  StatusOr(const StatusOr<U>& other)  // NOLINT 
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {} 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              y_absl::negation<std::is_convertible<const U&, T>>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  explicit StatusOr(const StatusOr<U>& other) 
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {} 
+ 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              std::is_convertible<U&&, T>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  StatusOr(StatusOr<U>&& other)  // NOLINT 
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {} 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              y_absl::negation<std::is_convertible<U&&, T>>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  explicit StatusOr(StatusOr<U>&& other) 
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {} 
+ 
+  // Converting Assignment Operators 
+ 
+  // Creates an `y_absl::StatusOr<T>` through assignment from an 
+  // `y_absl::StatusOr<U>` when: 
+  // 
+  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` are OK by assigning 
+  //     `U` to `T` directly. 
+  //   * `y_absl::StatusOr<T>` is OK and `y_absl::StatusOr<U>` contains an error 
+  //      code by destroying `y_absl::StatusOr<T>`'s value and assigning from 
+  //      `y_absl::StatusOr<U>' 
+  //   * `y_absl::StatusOr<T>` contains an error code and `y_absl::StatusOr<U>` is 
+  //      OK by directly initializing `T` from `U`. 
+  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` contain an error 
+  //     code by assigning the `Status` in `y_absl::StatusOr<U>` to 
+  //     `y_absl::StatusOr<T>` 
+  // 
+  // These overloads only apply if `y_absl::StatusOr<T>` is constructible and 
+  // assignable from `y_absl::StatusOr<U>` and `StatusOr<T>` cannot be directly 
+  // assigned from `StatusOr<U>`. 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              std::is_assignable<T, const U&>, 
+              y_absl::negation< 
+                  internal_statusor:: 
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr< 
+                          T, U>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(const StatusOr<U>& other) { 
+    this->Assign(other); 
+    return *this; 
+  } 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              std::is_assignable<T, U&&>, 
+              y_absl::negation< 
+                  internal_statusor:: 
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr< 
+                          T, U>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(StatusOr<U>&& other) { 
+    this->Assign(std::move(other)); 
+    return *this; 
+  } 
+ 
+  // Constructs a new `y_absl::StatusOr<T>` with a non-ok status. After calling 
+  // this constructor, `this->ok()` will be `false` and calls to `value()` will 
+  // crash, or produce an exception if exceptions are enabled. 
+  // 
+  // The constructor also takes any type `U` that is convertible to 
+  // `y_absl::Status`. This constructor is explicit if an only if `U` is not of 
+  // type `y_absl::Status` and the conversion from `U` to `Status` is explicit. 
+  // 
+  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed. 
+  // In optimized builds, passing y_absl::OkStatus() here will have the effect 
+  // of passing y_absl::StatusCode::kInternal as a fallback. 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              std::is_convertible<U&&, y_absl::Status>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  StatusOr(U&& v) : Base(std::forward<U>(v)) {} 
+ 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {} 
+ 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              std::is_convertible<U&&, y_absl::Status>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(U&& v) { 
+    this->AssignStatus(std::forward<U>(v)); 
+    return *this; 
+  } 
+ 
+  // Perfect-forwarding value assignment operator. 
+ 
+  // If `*this` contains a `T` value before the call, the contained value is 
+  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized 
+  // from `std::forward<U>(v)`. 
+  // This function does not participate in overload unless: 
+  // 1. `std::is_constructible_v<T, U>` is true, 
+  // 2. `std::is_assignable_v<T&, U>` is true. 
+  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false. 
+  // 4. Assigning `U` to `T` is not ambiguous: 
+  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from 
+  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and 
+  //  ambiguous thus will fail to compile. For example: 
+  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true 
+  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false 
+  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`? 
+  template < 
+      typename U = T, 
+      typename = typename std::enable_if<y_absl::conjunction< 
+          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>, 
+          y_absl::disjunction< 
+              std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, T>, 
+              y_absl::conjunction< 
+                  y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+                  y_absl::negation<internal_statusor:: 
+                                     HasConversionOperatorToStatusOr<T, U&&>>>>, 
+          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type> 
+  StatusOr& operator=(U&& v) { 
+    this->Assign(std::forward<U>(v)); 
+    return *this; 
+  } 
+ 
+  // Constructs the inner value `T` in-place using the provided args, using the 
+  // `T(args...)` constructor. 
+  template <typename... Args> 
+  explicit StatusOr(y_absl::in_place_t, Args&&... args); 
+  template <typename U, typename... Args> 
+  explicit StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist, 
+                    Args&&... args); 
+ 
+  // Constructs the inner value `T` in-place using the provided args, using the 
+  // `T(U)` (direct-initialization) constructor. This constructor is only valid 
+  // if `T` can be constructed from a `U`. Can accept move or copy constructors. 
+  // 
+  // This constructor is explicit if `U` is not convertible to `T`. To avoid 
   // ambiguity, this constructor is disabled if `U` is a `StatusOr<J>`, where
   // `J` is convertible to `T`.
-  template <
-      typename U = T,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>,
-              y_absl::disjunction<
-                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                               T>,
-                  y_absl::conjunction<
-                      y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-                      y_absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>>::value,
-          int> = 0>
-  StatusOr(U&& u)  // NOLINT
+  template < 
+      typename U = T, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              internal_statusor::IsDirectInitializationValid<T, U&&>, 
+              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, 
+              y_absl::disjunction< 
+                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                               T>, 
+                  y_absl::conjunction< 
+                      y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+                      y_absl::negation< 
+                          internal_statusor::HasConversionOperatorToStatusOr< 
+                              T, U&&>>>>>::value, 
+          int> = 0> 
+  StatusOr(U&& u)  // NOLINT 
       : StatusOr(y_absl::in_place, std::forward<U>(u)) {}
-
-  template <
-      typename U = T,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              y_absl::disjunction<
-                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                               T>,
-                  y_absl::conjunction<
-                      y_absl::negation<std::is_constructible<y_absl::Status, U&&>>,
-                      y_absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>,
-              std::is_constructible<T, U&&>,
-              y_absl::negation<std::is_convertible<U&&, T>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& u)  // NOLINT
+ 
+  template < 
+      typename U = T, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              internal_statusor::IsDirectInitializationValid<T, U&&>, 
+              y_absl::disjunction< 
+                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                               T>, 
+                  y_absl::conjunction< 
+                      y_absl::negation<std::is_constructible<y_absl::Status, U&&>>, 
+                      y_absl::negation< 
+                          internal_statusor::HasConversionOperatorToStatusOr< 
+                              T, U&&>>>>, 
+              std::is_constructible<T, U&&>, 
+              y_absl::negation<std::is_convertible<U&&, T>>>::value, 
+          int> = 0> 
+  explicit StatusOr(U&& u)  // NOLINT 
       : StatusOr(y_absl::in_place, std::forward<U>(u)) {}
-
-  // StatusOr<T>::ok()
-  //
-  // Returns whether or not this `y_absl::StatusOr<T>` holds a `T` value. This
-  // member function is analagous to `y_absl::Status::ok()` and should be used
-  // similarly to check the status of return values.
-  //
-  // Example:
-  //
-  // StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-  // if (result.ok()) {
-  //    // Handle result
-  // else {
-  //    // Handle error
-  // }
-  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
-
-  // StatusOr<T>::status()
-  //
-  // Returns a reference to the current `y_absl::Status` contained within the
-  // `y_absl::StatusOr<T>`. If `y_absl::StatusOr<T>` contains a `T`, then this
-  // function returns `y_absl::OkStatus()`.
+ 
+  // StatusOr<T>::ok() 
+  // 
+  // Returns whether or not this `y_absl::StatusOr<T>` holds a `T` value. This 
+  // member function is analagous to `y_absl::Status::ok()` and should be used 
+  // similarly to check the status of return values. 
+  // 
+  // Example: 
+  // 
+  // StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+  // if (result.ok()) { 
+  //    // Handle result 
+  // else { 
+  //    // Handle error 
+  // } 
+  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); } 
+ 
+  // StatusOr<T>::status() 
+  // 
+  // Returns a reference to the current `y_absl::Status` contained within the 
+  // `y_absl::StatusOr<T>`. If `y_absl::StatusOr<T>` contains a `T`, then this 
+  // function returns `y_absl::OkStatus()`. 
   const Status& status() const&;
-  Status status() &&;
-
-  // StatusOr<T>::value()
-  //
-  // Returns a reference to the held value if `this->ok()`. Otherwise, throws
-  // `y_absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to
-  // terminate the process if exceptions are disabled.
-  //
-  // If you have already checked the status using `this->ok()`, you probably
-  // want to use `operator*()` or `operator->()` to access the value instead of
-  // `value`.
-  //
-  // Note: for value types that are cheap to copy, prefer simple code:
-  //
-  //   T value = statusor.value();
-  //
-  // Otherwise, if the value type is expensive to copy, but can be left
-  // in the StatusOr, simply assign to a reference:
-  //
-  //   T& value = statusor.value();  // or `const T&`
-  //
-  // Otherwise, if the value type supports an efficient move, it can be
-  // used as follows:
-  //
-  //   T value = std::move(statusor).value();
-  //
-  // The `std::move` on statusor instead of on the whole expression enables
-  // warnings about possible uses of the statusor object after the move.
+  Status status() &&; 
+ 
+  // StatusOr<T>::value() 
+  // 
+  // Returns a reference to the held value if `this->ok()`. Otherwise, throws 
+  // `y_absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to 
+  // terminate the process if exceptions are disabled. 
+  // 
+  // If you have already checked the status using `this->ok()`, you probably 
+  // want to use `operator*()` or `operator->()` to access the value instead of 
+  // `value`. 
+  // 
+  // Note: for value types that are cheap to copy, prefer simple code: 
+  // 
+  //   T value = statusor.value(); 
+  // 
+  // Otherwise, if the value type is expensive to copy, but can be left 
+  // in the StatusOr, simply assign to a reference: 
+  // 
+  //   T& value = statusor.value();  // or `const T&` 
+  // 
+  // Otherwise, if the value type supports an efficient move, it can be 
+  // used as follows: 
+  // 
+  //   T value = std::move(statusor).value(); 
+  // 
+  // The `std::move` on statusor instead of on the whole expression enables 
+  // warnings about possible uses of the statusor object after the move. 
   const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
   const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>:: operator*()
-  //
-  // Returns a reference to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value within the
-  // `y_absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
-  // similar API that guarantees crashing or throwing an exception if there is
-  // no current value.
+ 
+  // StatusOr<T>:: operator*() 
+  // 
+  // Returns a reference to the current value. 
+  // 
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined. 
+  // 
+  // Use `this->ok()` to verify that there is a current value within the 
+  // `y_absl::StatusOr<T>`. Alternatively, see the `value()` member function for a 
+  // similar API that guarantees crashing or throwing an exception if there is 
+  // no current value. 
   const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
   const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::operator->()
-  //
-  // Returns a pointer to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value.
+ 
+  // StatusOr<T>::operator->() 
+  // 
+  // Returns a pointer to the current value. 
+  // 
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined. 
+  // 
+  // Use `this->ok()` to verify that there is a current value. 
   const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::value_or()
-  //
-  // Returns the current value if `this->ok() == true`. Otherwise constructs a
-  // value using the provided `default_value`.
-  //
-  // Unlike `value`, this function returns by value, copying the current value
-  // if necessary. If the value type supports an efficient move, it can be used
-  // as follows:
-  //
-  //   T value = std::move(statusor).value_or(def);
-  //
-  // Unlike with `value`, calling `std::move()` on the result of `value_or` will
-  // still trigger a copy.
-  template <typename U>
-  T value_or(U&& default_value) const&;
-  template <typename U>
-  T value_or(U&& default_value) &&;
-
-  // StatusOr<T>::IgnoreError()
-  //
-  // Ignores any errors. This method does nothing except potentially suppress
-  // complaints from any tools that are checking that errors are not dropped on
-  // the floor.
-  void IgnoreError() const;
-
-  // StatusOr<T>::emplace()
-  //
-  // Reconstructs the inner value T in-place using the provided args, using the
-  // T(args...) constructor. Returns reference to the reconstructed `T`.
-  template <typename... Args>
-  T& emplace(Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(std::forward<Args>(args)...);
-      this->status_ = y_absl::OkStatus();
-    }
-    return this->data_;
-  }
-
-  template <
-      typename U, typename... Args,
-      y_absl::enable_if_t<
-          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
-          int> = 0>
-  T& emplace(std::initializer_list<U> ilist, Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-      this->status_ = y_absl::OkStatus();
-    }
-    return this->data_;
-  }
-
- private:
-  using internal_statusor::StatusOrData<T>::Assign;
-  template <typename U>
-  void Assign(const y_absl::StatusOr<U>& other);
-  template <typename U>
-  void Assign(y_absl::StatusOr<U>&& other);
-};
-
-// operator==()
-//
-// This operator checks the equality of two `y_absl::StatusOr<T>` objects.
-template <typename T>
-bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  if (lhs.ok() && rhs.ok()) return *lhs == *rhs;
-  return lhs.status() == rhs.status();
-}
-
-// operator!=()
-//
-// This operator checks the inequality of two `y_absl::StatusOr<T>` objects.
-template <typename T>
-bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  return !(lhs == rhs);
-}
-
-//------------------------------------------------------------------------------
-// Implementation details for StatusOr<T>
-//------------------------------------------------------------------------------
-
-// TODO(sbenza): avoid the string here completely.
-template <typename T>
-StatusOr<T>::StatusOr() : Base(Status(y_absl::StatusCode::kUnknown, "")) {}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(const StatusOr<U>& other) {
-  if (other.ok()) {
-    this->Assign(*other);
-  } else {
-    this->AssignStatus(other.status());
-  }
-}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(StatusOr<U>&& other) {
-  if (other.ok()) {
-    this->Assign(*std::move(other));
-  } else {
-    this->AssignStatus(std::move(other).status());
-  }
-}
-template <typename T>
-template <typename... Args>
-StatusOr<T>::StatusOr(y_absl::in_place_t, Args&&... args)
-    : Base(y_absl::in_place, std::forward<Args>(args)...) {}
-
-template <typename T>
-template <typename U, typename... Args>
-StatusOr<T>::StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist,
-                      Args&&... args)
-    : Base(y_absl::in_place, ilist, std::forward<Args>(args)...) {}
-
-template <typename T>
+ 
+  // StatusOr<T>::value_or() 
+  // 
+  // Returns the current value if `this->ok() == true`. Otherwise constructs a 
+  // value using the provided `default_value`. 
+  // 
+  // Unlike `value`, this function returns by value, copying the current value 
+  // if necessary. If the value type supports an efficient move, it can be used 
+  // as follows: 
+  // 
+  //   T value = std::move(statusor).value_or(def); 
+  // 
+  // Unlike with `value`, calling `std::move()` on the result of `value_or` will 
+  // still trigger a copy. 
+  template <typename U> 
+  T value_or(U&& default_value) const&; 
+  template <typename U> 
+  T value_or(U&& default_value) &&; 
+ 
+  // StatusOr<T>::IgnoreError() 
+  // 
+  // Ignores any errors. This method does nothing except potentially suppress 
+  // complaints from any tools that are checking that errors are not dropped on 
+  // the floor. 
+  void IgnoreError() const; 
+ 
+  // StatusOr<T>::emplace() 
+  // 
+  // Reconstructs the inner value T in-place using the provided args, using the 
+  // T(args...) constructor. Returns reference to the reconstructed `T`. 
+  template <typename... Args> 
+  T& emplace(Args&&... args) { 
+    if (ok()) { 
+      this->Clear(); 
+      this->MakeValue(std::forward<Args>(args)...); 
+    } else { 
+      this->MakeValue(std::forward<Args>(args)...); 
+      this->status_ = y_absl::OkStatus(); 
+    } 
+    return this->data_; 
+  } 
+ 
+  template < 
+      typename U, typename... Args, 
+      y_absl::enable_if_t< 
+          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, 
+          int> = 0> 
+  T& emplace(std::initializer_list<U> ilist, Args&&... args) { 
+    if (ok()) { 
+      this->Clear(); 
+      this->MakeValue(ilist, std::forward<Args>(args)...); 
+    } else { 
+      this->MakeValue(ilist, std::forward<Args>(args)...); 
+      this->status_ = y_absl::OkStatus(); 
+    } 
+    return this->data_; 
+  } 
+ 
+ private: 
+  using internal_statusor::StatusOrData<T>::Assign; 
+  template <typename U> 
+  void Assign(const y_absl::StatusOr<U>& other); 
+  template <typename U> 
+  void Assign(y_absl::StatusOr<U>&& other); 
+}; 
+ 
+// operator==() 
+// 
+// This operator checks the equality of two `y_absl::StatusOr<T>` objects. 
+template <typename T> 
+bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) { 
+  if (lhs.ok() && rhs.ok()) return *lhs == *rhs; 
+  return lhs.status() == rhs.status(); 
+} 
+ 
+// operator!=() 
+// 
+// This operator checks the inequality of two `y_absl::StatusOr<T>` objects. 
+template <typename T> 
+bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) { 
+  return !(lhs == rhs); 
+} 
+ 
+//------------------------------------------------------------------------------ 
+// Implementation details for StatusOr<T> 
+//------------------------------------------------------------------------------ 
+ 
+// TODO(sbenza): avoid the string here completely. 
+template <typename T> 
+StatusOr<T>::StatusOr() : Base(Status(y_absl::StatusCode::kUnknown, "")) {} 
+ 
+template <typename T> 
+template <typename U> 
+inline void StatusOr<T>::Assign(const StatusOr<U>& other) { 
+  if (other.ok()) { 
+    this->Assign(*other); 
+  } else { 
+    this->AssignStatus(other.status()); 
+  } 
+} 
+ 
+template <typename T> 
+template <typename U> 
+inline void StatusOr<T>::Assign(StatusOr<U>&& other) { 
+  if (other.ok()) { 
+    this->Assign(*std::move(other)); 
+  } else { 
+    this->AssignStatus(std::move(other).status()); 
+  } 
+} 
+template <typename T> 
+template <typename... Args> 
+StatusOr<T>::StatusOr(y_absl::in_place_t, Args&&... args) 
+    : Base(y_absl::in_place, std::forward<Args>(args)...) {} 
+ 
+template <typename T> 
+template <typename U, typename... Args> 
+StatusOr<T>::StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist, 
+                      Args&&... args) 
+    : Base(y_absl::in_place, ilist, std::forward<Args>(args)...) {} 
+ 
+template <typename T> 
 const Status& StatusOr<T>::status() const& {
   return this->status_;
 }
-template <typename T>
-Status StatusOr<T>::status() && {
-  return ok() ? OkStatus() : std::move(this->status_);
-}
-
-template <typename T>
-const T& StatusOr<T>::value() const& {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::value() & {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::value() const&& {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::value() && {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T& StatusOr<T>::operator*() const& {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::operator*() & {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::operator*() const&& {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::operator*() && {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T* StatusOr<T>::operator->() const {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-T* StatusOr<T>::operator->() {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) const& {
-  if (ok()) {
-    return this->data_;
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) && {
-  if (ok()) {
-    return std::move(this->data_);
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-void StatusOr<T>::IgnoreError() const {
-  // no-op
-}
-
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_STATUSOR_H_
+template <typename T> 
+Status StatusOr<T>::status() && { 
+  return ok() ? OkStatus() : std::move(this->status_); 
+} 
+ 
+template <typename T> 
+const T& StatusOr<T>::value() const& { 
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+T& StatusOr<T>::value() & { 
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+const T&& StatusOr<T>::value() const&& { 
+  if (!this->ok()) { 
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_)); 
+  } 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+T&& StatusOr<T>::value() && { 
+  if (!this->ok()) { 
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_)); 
+  } 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+const T& StatusOr<T>::operator*() const& { 
+  this->EnsureOk(); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+T& StatusOr<T>::operator*() & { 
+  this->EnsureOk(); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+const T&& StatusOr<T>::operator*() const&& { 
+  this->EnsureOk(); 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+T&& StatusOr<T>::operator*() && { 
+  this->EnsureOk(); 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+const T* StatusOr<T>::operator->() const { 
+  this->EnsureOk(); 
+  return &this->data_; 
+} 
+ 
+template <typename T> 
+T* StatusOr<T>::operator->() { 
+  this->EnsureOk(); 
+  return &this->data_; 
+} 
+ 
+template <typename T> 
+template <typename U> 
+T StatusOr<T>::value_or(U&& default_value) const& { 
+  if (ok()) { 
+    return this->data_; 
+  } 
+  return std::forward<U>(default_value); 
+} 
+ 
+template <typename T> 
+template <typename U> 
+T StatusOr<T>::value_or(U&& default_value) && { 
+  if (ok()) { 
+    return std::move(this->data_); 
+  } 
+  return std::forward<U>(default_value); 
+} 
+ 
+template <typename T> 
+void StatusOr<T>::IgnoreError() const { 
+  // no-op 
+} 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_STATUSOR_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
index a29c7ae5b3..0574972151 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
@@ -1,31 +1,31 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
     contrib/restricted/abseil-cpp-tstring/y_absl/status
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
@@ -38,20 +38,20 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/status)
-
-SRCS(
+ 
+SRCS( 
     statusor.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
index 9414dfc26b..ceb84a219e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc