Intermediate changes

32 files changed, 0 insertions, 5993 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.cc
deleted file mode 100644
index b70a9815c9..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// 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/flags/commandlineflag.h"
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-bool CommandLineFlag::IsRetired() const { return false; }
-bool CommandLineFlag::ParseFrom(y_absl::string_view value, TString* error) {
-  return ParseFrom(value, flags_internal::SET_FLAGS_VALUE,
-                   flags_internal::kProgrammaticChange, *error);
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.h
deleted file mode 100644
index 30c2bb07a5..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag.h
+++ /dev/null
@@ -1,200 +0,0 @@
-//
-// 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: commandlineflag.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `CommandLineFlag`, which acts as a type-erased
-// handle for accessing metadata about the Abseil Flag in question.
-//
-// Because an actual Abseil flag is of an unspecified type, you should not
-// manipulate or interact directly with objects of that type. Instead, use the
-// CommandLineFlag type as an intermediary.
-#ifndef Y_ABSL_FLAGS_COMMANDLINEFLAG_H_
-#define Y_ABSL_FLAGS_COMMANDLINEFLAG_H_
-
-#include <memory>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/base/internal/fast_type_id.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/types/optional.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-class PrivateHandleAccessor;
-}  // namespace flags_internal
-
-// CommandLineFlag
-//
-// This type acts as a type-erased handle for an instance of an Abseil Flag and
-// holds reflection information pertaining to that flag. Use CommandLineFlag to
-// access a flag's name, location, help string etc.
-//
-// To obtain an y_absl::CommandLineFlag, invoke `y_absl::FindCommandLineFlag()`
-// passing it the flag name string.
-//
-// Example:
-//
-//   // Obtain reflection handle for a flag named "flagname".
-//   const y_absl::CommandLineFlag* my_flag_data =
-//        y_absl::FindCommandLineFlag("flagname");
-//
-//   // Now you can get flag info from that reflection handle.
-//   TString flag_location = my_flag_data->Filename();
-//   ...
-class CommandLineFlag {
- public:
-  constexpr CommandLineFlag() = default;
-
-  // Not copyable/assignable.
-  CommandLineFlag(const CommandLineFlag&) = delete;
-  CommandLineFlag& operator=(const CommandLineFlag&) = delete;
-
-  // y_absl::CommandLineFlag::IsOfType()
-  //
-  // Return true iff flag has type T.
-  template <typename T>
-  inline bool IsOfType() const {
-    return TypeId() == base_internal::FastTypeId<T>();
-  }
-
-  // y_absl::CommandLineFlag::TryGet()
-  //
-  // Attempts to retrieve the flag value. Returns value on success,
-  // y_absl::nullopt otherwise.
-  template <typename T>
-  y_absl::optional<T> TryGet() const {
-    if (IsRetired() || !IsOfType<T>()) {
-      return y_absl::nullopt;
-    }
-
-    // Implementation notes:
-    //
-    // We are wrapping a union around the value of `T` to serve three purposes:
-    //
-    //  1. `U.value` has correct size and alignment for a value of type `T`
-    //  2. The `U.value` constructor is not invoked since U's constructor does
-    //     not do it explicitly.
-    //  3. The `U.value` destructor is invoked since U's destructor does it
-    //     explicitly. This makes `U` a kind of RAII wrapper around non default
-    //     constructible value of T, which is destructed when we leave the
-    //     scope. We do need to destroy U.value, which is constructed by
-    //     CommandLineFlag::Read even though we left it in a moved-from state
-    //     after std::move.
-    //
-    // All of this serves to avoid requiring `T` being default constructible.
-    union U {
-      T value;
-      U() {}
-      ~U() { value.~T(); }
-    };
-    U u;
-
-    Read(&u.value);
-    // allow retired flags to be "read", so we can report invalid access.
-    if (IsRetired()) {
-      return y_absl::nullopt;
-    }
-    return std::move(u.value);
-  }
-
-  // y_absl::CommandLineFlag::Name()
-  //
-  // Returns name of this flag.
-  virtual y_absl::string_view Name() const = 0;
-
-  // y_absl::CommandLineFlag::Filename()
-  //
-  // Returns name of the file where this flag is defined.
-  virtual TString Filename() const = 0;
-
-  // y_absl::CommandLineFlag::Help()
-  //
-  // Returns help message associated with this flag.
-  virtual TString Help() const = 0;
-
-  // y_absl::CommandLineFlag::IsRetired()
-  //
-  // Returns true iff this object corresponds to retired flag.
-  virtual bool IsRetired() const;
-
-  // y_absl::CommandLineFlag::DefaultValue()
-  //
-  // Returns the default value for this flag.
-  virtual TString DefaultValue() const = 0;
-
-  // y_absl::CommandLineFlag::CurrentValue()
-  //
-  // Returns the current value for this flag.
-  virtual TString CurrentValue() const = 0;
-
-  // y_absl::CommandLineFlag::ParseFrom()
-  //
-  // Sets the value of the flag based on specified string `value`. If the flag
-  // was successfully set to new value, it returns true. Otherwise, sets `error`
-  // to indicate the error, leaves the flag unchanged, and returns false.
-  bool ParseFrom(y_absl::string_view value, TString* error);
-
- protected:
-  ~CommandLineFlag() = default;
-
- private:
-  friend class flags_internal::PrivateHandleAccessor;
-
-  // Sets the value of the flag based on specified string `value`. If the flag
-  // was successfully set to new value, it returns true. Otherwise, sets `error`
-  // to indicate the error, leaves the flag unchanged, and returns false. There
-  // are three ways to set the flag's value:
-  //  * Update the current flag value
-  //  * Update the flag's default value
-  //  * Update the current flag value if it was never set before
-  // The mode is selected based on `set_mode` parameter.
-  virtual bool ParseFrom(y_absl::string_view value,
-                         flags_internal::FlagSettingMode set_mode,
-                         flags_internal::ValueSource source,
-                         TString& error) = 0;
-
-  // Returns id of the flag's value type.
-  virtual flags_internal::FlagFastTypeId TypeId() const = 0;
-
-  // Interface to save flag to some persistent state. Returns current flag state
-  // or nullptr if flag does not support saving and restoring a state.
-  virtual std::unique_ptr<flags_internal::FlagStateInterface> SaveState() = 0;
-
-  // Copy-construct a new value of the flag's type in a memory referenced by
-  // the dst based on the current flag's value.
-  virtual void Read(void* dst) const = 0;
-
-  // To be deleted. Used to return true if flag's current value originated from
-  // command line.
-  virtual bool IsSpecifiedOnCommandLine() const = 0;
-
-  // Validates supplied value usign validator or parseflag routine
-  virtual bool ValidateInputValue(y_absl::string_view value) const = 0;
-
-  // Checks that flags default value can be converted to string and back to the
-  // flag's value type.
-  virtual void CheckDefaultValueParsingRoundtrip() const = 0;
-};
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_COMMANDLINEFLAG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/config.h
deleted file mode 100644
index 08de490eb1..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/config.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-//  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 Y_ABSL_FLAGS_CONFIG_H_
-#define Y_ABSL_FLAGS_CONFIG_H_
-
-// Determine if we should strip string literals from the Flag objects.
-// By default we strip string literals on mobile platforms.
-#if !defined(Y_ABSL_FLAGS_STRIP_NAMES)
-
-#if defined(__ANDROID__)
-#define Y_ABSL_FLAGS_STRIP_NAMES 1
-
-#elif defined(__APPLE__)
-#include <TargetConditionals.h>
-#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
-#define Y_ABSL_FLAGS_STRIP_NAMES 1
-#elif defined(TARGET_OS_EMBEDDED) && TARGET_OS_EMBEDDED
-#define Y_ABSL_FLAGS_STRIP_NAMES 1
-#endif  // TARGET_OS_*
-#endif
-
-#endif  // !defined(Y_ABSL_FLAGS_STRIP_NAMES)
-
-#if !defined(Y_ABSL_FLAGS_STRIP_NAMES)
-// If Y_ABSL_FLAGS_STRIP_NAMES wasn't set on the command line or above,
-// the default is not to strip.
-#define Y_ABSL_FLAGS_STRIP_NAMES 0
-#endif
-
-#if !defined(Y_ABSL_FLAGS_STRIP_HELP)
-// By default, if we strip names, we also strip help.
-#define Y_ABSL_FLAGS_STRIP_HELP Y_ABSL_FLAGS_STRIP_NAMES
-#endif
-
-// These macros represent the "source of truth" for the list of supported
-// built-in types.
-#define Y_ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \
-  A(bool, bool)                              \
-  A(short, short)                            \
-  A(unsigned short, unsigned_short)          \
-  A(int, int)                                \
-  A(unsigned int, unsigned_int)              \
-  A(long, long)                              \
-  A(unsigned long, unsigned_long)            \
-  A(long long, long_long)                    \
-  A(unsigned long long, unsigned_long_long)  \
-  A(double, double)                          \
-  A(float, float)
-
-#define Y_ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \
-  Y_ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)         \
-  A(TString, std_string)                   \
-  A(std::vector<TString>, std_vector_of_string)
-
-#endif  // Y_ABSL_FLAGS_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/declare.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/declare.h
deleted file mode 100644
index 0b36402496..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/declare.h
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-//  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.
-//
-// -----------------------------------------------------------------------------
-// File: declare.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the Y_ABSL_DECLARE_FLAG macro, allowing you to declare an
-// `y_absl::Flag` for use within a translation unit. You should place this
-// declaration within the header file associated with the .cc file that defines
-// and owns the `Flag`.
-
-#ifndef Y_ABSL_FLAGS_DECLARE_H_
-#define Y_ABSL_FLAGS_DECLARE_H_
-
-#include "y_absl/base/config.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// y_absl::Flag<T> represents a flag of type 'T' created by Y_ABSL_FLAG.
-template <typename T>
-class Flag;
-
-}  // namespace flags_internal
-
-// Flag
-//
-// Forward declaration of the `y_absl::Flag` type for use in defining the macro.
-#if defined(_MSC_VER) && !defined(__clang__)
-template <typename T>
-class Flag;
-#else
-template <typename T>
-using Flag = flags_internal::Flag<T>;
-#endif
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-// Y_ABSL_DECLARE_FLAG()
-//
-// This macro is a convenience for declaring use of an `y_absl::Flag` within a
-// translation unit. This macro should be used within a header file to
-// declare usage of the flag within any .cc file including that header file.
-//
-// The Y_ABSL_DECLARE_FLAG(type, name) macro expands to:
-//
-//   extern y_absl::Flag<type> FLAGS_name;
-#define Y_ABSL_DECLARE_FLAG(type, name) Y_ABSL_DECLARE_FLAG_INTERNAL(type, name)
-
-// Internal implementation of Y_ABSL_DECLARE_FLAG to allow macro expansion of its
-// arguments. Clients must use Y_ABSL_DECLARE_FLAG instead.
-#define Y_ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
-  extern y_absl::Flag<type> FLAGS_##name;                      \
-  namespace y_absl /* block flags in namespaces */ {}          \
-  /* second redeclaration is to allow applying attributes */ \
-  extern y_absl::Flag<type> FLAGS_##name
-
-#endif  // Y_ABSL_FLAGS_DECLARE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.cc
deleted file mode 100644
index 9bc5137f3e..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-//  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.
-
-#include "y_absl/flags/flag.h"
-
-#include "y_absl/base/config.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-// This global mutex protects on-demand construction of flag objects in MSVC
-// builds.
-#if defined(_MSC_VER) && !defined(__clang__)
-
-namespace flags_internal {
-
-Y_ABSL_CONST_INIT static y_absl::Mutex construction_guard(y_absl::kConstInit);
-
-y_absl::Mutex* GetGlobalConstructionGuard() { return &construction_guard; }
-
-}  // namespace flags_internal
-
-#endif
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.h
deleted file mode 100644
index 65448650d3..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/flag.h
+++ /dev/null
@@ -1,310 +0,0 @@
-//
-//  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.
-//
-// -----------------------------------------------------------------------------
-// File: flag.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `y_absl::Flag<T>` type for holding command-line
-// flag data, and abstractions to create, get and set such flag data.
-//
-// It is important to note that this type is **unspecified** (an implementation
-// detail) and you do not construct or manipulate actual `y_absl::Flag<T>`
-// instances. Instead, you define and declare flags using the
-// `Y_ABSL_FLAG()` and `Y_ABSL_DECLARE_FLAG()` macros, and get and set flag values
-// using the `y_absl::GetFlag()` and `y_absl::SetFlag()` functions.
-
-#ifndef Y_ABSL_FLAGS_FLAG_H_
-#define Y_ABSL_FLAGS_FLAG_H_
-
-#include <util/generic/string.h>
-#include <type_traits>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/optimization.h"
-#include "y_absl/flags/config.h"
-#include "y_absl/flags/internal/flag.h"
-#include "y_absl/flags/internal/registry.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-// Flag
-//
-// An `y_absl::Flag` holds a command-line flag value, providing a runtime
-// parameter to a binary. Such flags should be defined in the global namespace
-// and (preferably) in the module containing the binary's `main()` function.
-//
-// You should not construct and cannot use the `y_absl::Flag` type directly;
-// instead, you should declare flags using the `Y_ABSL_DECLARE_FLAG()` macro
-// within a header file, and define your flag using `Y_ABSL_FLAG()` within your
-// header's associated `.cc` file. Such flags will be named `FLAGS_name`.
-//
-// Example:
-//
-//    .h file
-//
-//      // Declares usage of a flag named "FLAGS_count"
-//      Y_ABSL_DECLARE_FLAG(int, count);
-//
-//    .cc file
-//
-//      // Defines a flag named "FLAGS_count" with a default `int` value of 0.
-//      Y_ABSL_FLAG(int, count, 0, "Count of items to process");
-//
-// No public methods of `y_absl::Flag<T>` are part of the Abseil Flags API.
-//
-// For type support of Abseil Flags, see the marshalling.h header file, which
-// discusses supported standard types, optional flags, and additional Abseil
-// type support.
-#if !defined(_MSC_VER) || defined(__clang__)
-template <typename T>
-using Flag = flags_internal::Flag<T>;
-#else
-#include "y_absl/flags/internal/flag_msvc.inc"
-#endif
-
-// GetFlag()
-//
-// Returns the value (of type `T`) of an `y_absl::Flag<T>` instance, by value. Do
-// not construct an `y_absl::Flag<T>` directly and call `y_absl::GetFlag()`;
-// instead, refer to flag's constructed variable name (e.g. `FLAGS_name`).
-// Because this function returns by value and not by reference, it is
-// thread-safe, but note that the operation may be expensive; as a result, avoid
-// `y_absl::GetFlag()` within any tight loops.
-//
-// Example:
-//
-//   // FLAGS_count is a Flag of type `int`
-//   int my_count = y_absl::GetFlag(FLAGS_count);
-//
-//   // FLAGS_firstname is a Flag of type `TString`
-//   TString first_name = y_absl::GetFlag(FLAGS_firstname);
-template <typename T>
-Y_ABSL_MUST_USE_RESULT T GetFlag(const y_absl::Flag<T>& flag) {
-  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
-}
-
-// SetFlag()
-//
-// Sets the value of an `y_absl::Flag` to the value `v`. Do not construct an
-// `y_absl::Flag<T>` directly and call `y_absl::SetFlag()`; instead, use the
-// flag's variable name (e.g. `FLAGS_name`). This function is
-// thread-safe, but is potentially expensive. Avoid setting flags in general,
-// but especially within performance-critical code.
-template <typename T>
-void SetFlag(y_absl::Flag<T>* flag, const T& v) {
-  flags_internal::FlagImplPeer::InvokeSet(*flag, v);
-}
-
-// Overload of `SetFlag()` to allow callers to pass in a value that is
-// convertible to `T`. E.g., use this overload to pass a "const char*" when `T`
-// is `TString`.
-template <typename T, typename V>
-void SetFlag(y_absl::Flag<T>* flag, const V& v) {
-  T value(v);
-  flags_internal::FlagImplPeer::InvokeSet(*flag, value);
-}
-
-// GetFlagReflectionHandle()
-//
-// Returns the reflection handle corresponding to specified Abseil Flag
-// instance. Use this handle to access flag's reflection information, like name,
-// location, default value etc.
-//
-// Example:
-//
-//   TString = y_absl::GetFlagReflectionHandle(FLAGS_count).DefaultValue();
-
-template <typename T>
-const CommandLineFlag& GetFlagReflectionHandle(const y_absl::Flag<T>& f) {
-  return flags_internal::FlagImplPeer::InvokeReflect(f);
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-
-// Y_ABSL_FLAG()
-//
-// This macro defines an `y_absl::Flag<T>` instance of a specified type `T`:
-//
-//   Y_ABSL_FLAG(T, name, default_value, help);
-//
-// where:
-//
-//   * `T` is a supported flag type (see the list of types in `marshalling.h`),
-//   * `name` designates the name of the flag (as a global variable
-//     `FLAGS_name`),
-//   * `default_value` is an expression holding the default value for this flag
-//     (which must be implicitly convertible to `T`),
-//   * `help` is the help text, which can also be an expression.
-//
-// This macro expands to a flag named 'FLAGS_name' of type 'T':
-//
-//   y_absl::Flag<T> FLAGS_name = ...;
-//
-// Note that all such instances are created as global variables.
-//
-// For `Y_ABSL_FLAG()` values that you wish to expose to other translation units,
-// it is recommended to define those flags within the `.cc` file associated with
-// the header where the flag is declared.
-//
-// Note: do not construct objects of type `y_absl::Flag<T>` directly. Only use the
-// `Y_ABSL_FLAG()` macro for such construction.
-#define Y_ABSL_FLAG(Type, name, default_value, help) \
-  Y_ABSL_FLAG_IMPL(Type, name, default_value, help)
-
-// Y_ABSL_FLAG().OnUpdate()
-//
-// Defines a flag of type `T` with a callback attached:
-//
-//   Y_ABSL_FLAG(T, name, default_value, help).OnUpdate(callback);
-//
-// `callback` should be convertible to `void (*)()`.
-//
-// After any setting of the flag value, the callback will be called at least
-// once. A rapid sequence of changes may be merged together into the same
-// callback. No concurrent calls to the callback will be made for the same
-// flag. Callbacks are allowed to read the current value of the flag but must
-// not mutate that flag.
-//
-// The update mechanism guarantees "eventual consistency"; if the callback
-// derives an auxiliary data structure from the flag value, it is guaranteed
-// that eventually the flag value and the derived data structure will be
-// consistent.
-//
-// Note: Y_ABSL_FLAG.OnUpdate() does not have a public definition. Hence, this
-// comment serves as its API documentation.
-
-// -----------------------------------------------------------------------------
-// Implementation details below this section
-// -----------------------------------------------------------------------------
-
-// Y_ABSL_FLAG_IMPL macro definition conditional on Y_ABSL_FLAGS_STRIP_NAMES
-#if !defined(_MSC_VER) || defined(__clang__)
-#define Y_ABSL_FLAG_IMPL_FLAG_PTR(flag) flag
-#define Y_ABSL_FLAG_IMPL_HELP_ARG(name)                      \
-  y_absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
-      FLAGS_help_storage_##name)
-#define Y_ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) \
-  y_absl::flags_internal::DefaultArg<Type, AbslFlagDefaultGenFor##name>(0)
-#else
-#define Y_ABSL_FLAG_IMPL_FLAG_PTR(flag) flag.GetImpl()
-#define Y_ABSL_FLAG_IMPL_HELP_ARG(name) &AbslFlagHelpGenFor##name::NonConst
-#define Y_ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) &AbslFlagDefaultGenFor##name::Gen
-#endif
-
-#if Y_ABSL_FLAGS_STRIP_NAMES
-#define Y_ABSL_FLAG_IMPL_FLAGNAME(txt) ""
-#define Y_ABSL_FLAG_IMPL_FILENAME() ""
-#define Y_ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
-  y_absl::flags_internal::FlagRegistrar<T, false>(Y_ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                                nullptr)
-#else
-#define Y_ABSL_FLAG_IMPL_FLAGNAME(txt) txt
-#define Y_ABSL_FLAG_IMPL_FILENAME() __FILE__
-#define Y_ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
-  y_absl::flags_internal::FlagRegistrar<T, true>(Y_ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                               __FILE__)
-#endif
-
-// Y_ABSL_FLAG_IMPL macro definition conditional on Y_ABSL_FLAGS_STRIP_HELP
-
-#if Y_ABSL_FLAGS_STRIP_HELP
-#define Y_ABSL_FLAG_IMPL_FLAGHELP(txt) y_absl::flags_internal::kStrippedFlagHelp
-#else
-#define Y_ABSL_FLAG_IMPL_FLAGHELP(txt) txt
-#endif
-
-// AbslFlagHelpGenFor##name is used to encapsulate both immediate (method Const)
-// and lazy (method NonConst) evaluation of help message expression. We choose
-// between the two via the call to HelpArg in y_absl::Flag instantiation below.
-// If help message expression is constexpr evaluable compiler will optimize
-// away this whole struct.
-// TODO(rogeeff): place these generated structs into local namespace and apply
-// Y_ABSL_INTERNAL_UNIQUE_SHORT_NAME.
-// TODO(rogeeff): Apply __attribute__((nodebug)) to FLAGS_help_storage_##name
-#define Y_ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt)                       \
-  struct AbslFlagHelpGenFor##name {                                          \
-    /* The expression is run in the caller as part of the   */               \
-    /* default value argument. That keeps temporaries alive */               \
-    /* long enough for NonConst to work correctly.          */               \
-    static constexpr y_absl::string_view Value(                                \
-        y_absl::string_view absl_flag_help = Y_ABSL_FLAG_IMPL_FLAGHELP(txt)) {   \
-      return absl_flag_help;                                                 \
-    }                                                                        \
-    static TString NonConst() { return TString(Value()); }           \
-  };                                                                         \
-  constexpr auto FLAGS_help_storage_##name Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
-      Y_ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) =                     \
-          y_absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
-              0);
-
-#define Y_ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)     \
-  struct AbslFlagDefaultGenFor##name {                                        \
-    Type value = y_absl::flags_internal::InitDefaultValue<Type>(default_value); \
-    static void Gen(void* absl_flag_default_loc) {                            \
-      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
-    }                                                                         \
-  };
-
-// Y_ABSL_FLAG_IMPL
-//
-// Note: Name of registrar object is not arbitrary. It is used to "grab"
-// global name for FLAGS_no<flag_name> symbol, thus preventing the possibility
-// of defining two flags with names foo and nofoo.
-#define Y_ABSL_FLAG_IMPL(Type, name, default_value, help)                       \
-  extern ::y_absl::Flag<Type> FLAGS_##name;                                     \
-  namespace y_absl /* block flags in namespaces */ {}                           \
-  Y_ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)           \
-  Y_ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                             \
-  Y_ABSL_CONST_INIT y_absl::Flag<Type> FLAGS_##name{                              \
-      Y_ABSL_FLAG_IMPL_FLAGNAME(#name), Y_ABSL_FLAG_IMPL_FILENAME(),              \
-      Y_ABSL_FLAG_IMPL_HELP_ARG(name), Y_ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)}; \
-  extern y_absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;             \
-  y_absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =                   \
-      Y_ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
-
-// Y_ABSL_RETIRED_FLAG
-//
-// Designates the flag (which is usually pre-existing) as "retired." A retired
-// flag is a flag that is now unused by the program, but may still be passed on
-// the command line, usually by production scripts. A retired flag is ignored
-// and code can't access it at runtime.
-//
-// This macro registers a retired flag with given name and type, with a name
-// identical to the name of the original flag you are retiring. The retired
-// flag's type can change over time, so that you can retire code to support a
-// custom flag type.
-//
-// This macro has the same signature as `Y_ABSL_FLAG`. To retire a flag, simply
-// replace an `Y_ABSL_FLAG` definition with `Y_ABSL_RETIRED_FLAG`, leaving the
-// arguments unchanged (unless of course you actually want to retire the flag
-// type at this time as well).
-//
-// `default_value` is only used as a double check on the type. `explanation` is
-// unused.
-// TODO(rogeeff): replace RETIRED_FLAGS with FLAGS once forward declarations of
-// retired flags are cleaned up.
-#define Y_ABSL_RETIRED_FLAG(type, name, default_value, explanation)      \
-  static y_absl::flags_internal::RetiredFlag<type> RETIRED_FLAGS_##name; \
-  Y_ABSL_ATTRIBUTE_UNUSED static const auto RETIRED_FLAGS_REG_##name =   \
-      (RETIRED_FLAGS_##name.Retire(#name),                             \
-       ::y_absl::flags_internal::FlagRegistrarEmpty{})
-
-#endif  // Y_ABSL_FLAGS_FLAG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.cc
deleted file mode 100644
index d9c0f4d40e..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// 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/flags/internal/commandlineflag.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-FlagStateInterface::~FlagStateInterface() {}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.h
deleted file mode 100644
index 70d90d5441..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
-#define Y_ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
-
-#include "y_absl/base/config.h"
-#include "y_absl/base/internal/fast_type_id.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// An alias for flag fast type id. This value identifies the flag value type
-// similarly to typeid(T), without relying on RTTI being available. In most
-// cases this id is enough to uniquely identify the flag's value type. In a few
-// cases we'll have to resort to using actual RTTI implementation if it is
-// available.
-using FlagFastTypeId = y_absl::base_internal::FastTypeIdType;
-
-// Options that control SetCommandLineOptionWithMode.
-enum FlagSettingMode {
-  // update the flag's value unconditionally (can call this multiple times).
-  SET_FLAGS_VALUE,
-  // update the flag's value, but *only if* it has not yet been updated
-  // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
-  SET_FLAG_IF_DEFAULT,
-  // set the flag's default value to this.  If the flag has not been updated
-  // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
-  // change the flag's current value to the new default value as well.
-  SET_FLAGS_DEFAULT
-};
-
-// Options that control ParseFrom: Source of a value.
-enum ValueSource {
-  // Flag is being set by value specified on a command line.
-  kCommandLine,
-  // Flag is being set by value specified in the code.
-  kProgrammaticChange,
-};
-
-// Handle to FlagState objects. Specific flag state objects will restore state
-// of a flag produced this flag state from method CommandLineFlag::SaveState().
-class FlagStateInterface {
- public:
-  virtual ~FlagStateInterface();
-
-  // Restores the flag originated this object to the saved state.
-  virtual void Restore() const = 0;
-};
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.cc
deleted file mode 100644
index d3047ee045..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.cc
+++ /dev/null
@@ -1,615 +0,0 @@
-//
-// 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.
-
-#include "y_absl/flags/internal/flag.h"
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <array>
-#include <atomic>
-#include <memory>
-#include <new>
-#include <util/generic/string.h>
-#include <typeinfo>
-
-#include "y_absl/base/call_once.h"
-#include "y_absl/base/casts.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/dynamic_annotations.h"
-#include "y_absl/base/optimization.h"
-#include "y_absl/flags/config.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/flags/usage_config.h"
-#include "y_absl/memory/memory.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/synchronization/mutex.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// The help message indicating that the commandline flag has been
-// 'stripped'. It will not show up when doing "-help" and its
-// variants. The flag is stripped if Y_ABSL_FLAGS_STRIP_HELP is set to 1
-// before including y_absl/flags/flag.h
-const char kStrippedFlagHelp[] = "\001\002\003\004 (unknown) \004\003\002\001";
-
-namespace {
-
-// Currently we only validate flag values for user-defined flag types.
-bool ShouldValidateFlagValue(FlagFastTypeId flag_type_id) {
-#define DONT_VALIDATE(T, _) \
-  if (flag_type_id == base_internal::FastTypeId<T>()) return false;
-  Y_ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(DONT_VALIDATE)
-#undef DONT_VALIDATE
-
-  return true;
-}
-
-// RAII helper used to temporarily unlock and relock `y_absl::Mutex`.
-// This is used when we need to ensure that locks are released while
-// invoking user supplied callbacks and then reacquired, since callbacks may
-// need to acquire these locks themselves.
-class MutexRelock {
- public:
-  explicit MutexRelock(y_absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); }
-  ~MutexRelock() { mu_.Lock(); }
-
-  MutexRelock(const MutexRelock&) = delete;
-  MutexRelock& operator=(const MutexRelock&) = delete;
-
- private:
-  y_absl::Mutex& mu_;
-};
-
-}  // namespace
-
-///////////////////////////////////////////////////////////////////////////////
-// Persistent state of the flag data.
-
-class FlagImpl;
-
-class FlagState : public flags_internal::FlagStateInterface {
- public:
-  template <typename V>
-  FlagState(FlagImpl& flag_impl, const V& v, bool modified,
-            bool on_command_line, int64_t counter)
-      : flag_impl_(flag_impl),
-        value_(v),
-        modified_(modified),
-        on_command_line_(on_command_line),
-        counter_(counter) {}
-
-  ~FlagState() override {
-    if (flag_impl_.ValueStorageKind() != FlagValueStorageKind::kAlignedBuffer &&
-        flag_impl_.ValueStorageKind() != FlagValueStorageKind::kSequenceLocked)
-      return;
-    flags_internal::Delete(flag_impl_.op_, value_.heap_allocated);
-  }
-
- private:
-  friend class FlagImpl;
-
-  // Restores the flag to the saved state.
-  void Restore() const override {
-    if (!flag_impl_.RestoreState(*this)) return;
-
-    Y_ABSL_INTERNAL_LOG(INFO,
-                      y_absl::StrCat("Restore saved value of ", flag_impl_.Name(),
-                                   " to: ", flag_impl_.CurrentValue()));
-  }
-
-  // Flag and saved flag data.
-  FlagImpl& flag_impl_;
-  union SavedValue {
-    explicit SavedValue(void* v) : heap_allocated(v) {}
-    explicit SavedValue(int64_t v) : one_word(v) {}
-
-    void* heap_allocated;
-    int64_t one_word;
-  } value_;
-  bool modified_;
-  bool on_command_line_;
-  int64_t counter_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag implementation, which does not depend on flag value type.
-
-DynValueDeleter::DynValueDeleter(FlagOpFn op_arg) : op(op_arg) {}
-
-void DynValueDeleter::operator()(void* ptr) const {
-  if (op == nullptr) return;
-
-  Delete(op, ptr);
-}
-
-void FlagImpl::Init() {
-  new (&data_guard_) y_absl::Mutex;
-
-  auto def_kind = static_cast<FlagDefaultKind>(def_kind_);
-
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic: {
-      alignas(int64_t) std::array<char, sizeof(int64_t)> buf{};
-      if (def_kind == FlagDefaultKind::kGenFunc) {
-        (*default_value_.gen_func)(buf.data());
-      } else {
-        assert(def_kind != FlagDefaultKind::kDynamicValue);
-        std::memcpy(buf.data(), &default_value_, Sizeof(op_));
-      }
-      if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) {
-        // We presume here the memory layout of FlagValueAndInitBit struct.
-        uint8_t initialized = 1;
-        std::memcpy(buf.data() + Sizeof(op_), &initialized,
-                    sizeof(initialized));
-      }
-      // Type can contain valid uninitialized bits, e.g. padding.
-      Y_ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size());
-      OneWordValue().store(y_absl::bit_cast<int64_t>(buf),
-                           std::memory_order_release);
-      break;
-    }
-    case FlagValueStorageKind::kSequenceLocked: {
-      // For this storage kind the default_value_ always points to gen_func
-      // during initialization.
-      assert(def_kind == FlagDefaultKind::kGenFunc);
-      (*default_value_.gen_func)(AtomicBufferValue());
-      break;
-    }
-    case FlagValueStorageKind::kAlignedBuffer:
-      // For this storage kind the default_value_ always points to gen_func
-      // during initialization.
-      assert(def_kind == FlagDefaultKind::kGenFunc);
-      (*default_value_.gen_func)(AlignedBufferValue());
-      break;
-  }
-  seq_lock_.MarkInitialized();
-}
-
-y_absl::Mutex* FlagImpl::DataGuard() const {
-  y_absl::call_once(const_cast<FlagImpl*>(this)->init_control_, &FlagImpl::Init,
-                  const_cast<FlagImpl*>(this));
-
-  // data_guard_ is initialized inside Init.
-  return reinterpret_cast<y_absl::Mutex*>(&data_guard_);
-}
-
-void FlagImpl::AssertValidType(FlagFastTypeId rhs_type_id,
-                               const std::type_info* (*gen_rtti)()) const {
-  FlagFastTypeId lhs_type_id = flags_internal::FastTypeId(op_);
-
-  // `rhs_type_id` is the fast type id corresponding to the declaration
-  // visibile at the call site. `lhs_type_id` is the fast type id
-  // corresponding to the type specified in flag definition. They must match
-  //  for this operation to be well-defined.
-  if (Y_ABSL_PREDICT_TRUE(lhs_type_id == rhs_type_id)) return;
-
-  const std::type_info* lhs_runtime_type_id =
-      flags_internal::RuntimeTypeId(op_);
-  const std::type_info* rhs_runtime_type_id = (*gen_rtti)();
-
-  if (lhs_runtime_type_id == rhs_runtime_type_id) return;
-
-#ifdef Y_ABSL_INTERNAL_HAS_RTTI
-  if (*lhs_runtime_type_id == *rhs_runtime_type_id) return;
-#endif
-
-  Y_ABSL_INTERNAL_LOG(
-      FATAL, y_absl::StrCat("Flag '", Name(),
-                          "' is defined as one type and declared as another"));
-}
-
-std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
-  void* res = nullptr;
-  switch (DefaultKind()) {
-    case FlagDefaultKind::kDynamicValue:
-      res = flags_internal::Clone(op_, default_value_.dynamic_value);
-      break;
-    case FlagDefaultKind::kGenFunc:
-      res = flags_internal::Alloc(op_);
-      (*default_value_.gen_func)(res);
-      break;
-    default:
-      res = flags_internal::Clone(op_, &default_value_);
-      break;
-  }
-  return {res, DynValueDeleter{op_}};
-}
-
-void FlagImpl::StoreValue(const void* src) {
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic: {
-      // Load the current value to avoid setting 'init' bit manualy.
-      int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
-      std::memcpy(&one_word_val, src, Sizeof(op_));
-      OneWordValue().store(one_word_val, std::memory_order_release);
-      seq_lock_.IncrementModificationCount();
-      break;
-    }
-    case FlagValueStorageKind::kSequenceLocked: {
-      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_));
-      break;
-    }
-    case FlagValueStorageKind::kAlignedBuffer:
-      Copy(op_, src, AlignedBufferValue());
-      seq_lock_.IncrementModificationCount();
-      break;
-  }
-  modified_ = true;
-  InvokeCallback();
-}
-
-y_absl::string_view FlagImpl::Name() const { return name_; }
-
-TString FlagImpl::Filename() const {
-  return flags_internal::GetUsageConfig().normalize_filename(filename_);
-}
-
-TString FlagImpl::Help() const {
-  return HelpSourceKind() == FlagHelpKind::kLiteral ? help_.literal
-                                                    : help_.gen_func();
-}
-
-FlagFastTypeId FlagImpl::TypeId() const {
-  return flags_internal::FastTypeId(op_);
-}
-
-int64_t FlagImpl::ModificationCount() const {
-  return seq_lock_.ModificationCount();
-}
-
-bool FlagImpl::IsSpecifiedOnCommandLine() const {
-  y_absl::MutexLock l(DataGuard());
-  return on_command_line_;
-}
-
-TString FlagImpl::DefaultValue() const {
-  y_absl::MutexLock l(DataGuard());
-
-  auto obj = MakeInitValue();
-  return flags_internal::Unparse(op_, obj.get());
-}
-
-TString FlagImpl::CurrentValue() const {
-  auto* guard = DataGuard();  // Make sure flag initialized
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic: {
-      const auto one_word_val =
-          y_absl::bit_cast<std::array<char, sizeof(int64_t)>>(
-              OneWordValue().load(std::memory_order_acquire));
-      return flags_internal::Unparse(op_, one_word_val.data());
-    }
-    case FlagValueStorageKind::kSequenceLocked: {
-      std::unique_ptr<void, DynValueDeleter> cloned(flags_internal::Alloc(op_),
-                                                    DynValueDeleter{op_});
-      ReadSequenceLockedData(cloned.get());
-      return flags_internal::Unparse(op_, cloned.get());
-    }
-    case FlagValueStorageKind::kAlignedBuffer: {
-      y_absl::MutexLock l(guard);
-      return flags_internal::Unparse(op_, AlignedBufferValue());
-    }
-  }
-
-  return "";
-}
-
-void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) {
-  y_absl::MutexLock l(DataGuard());
-
-  if (callback_ == nullptr) {
-    callback_ = new FlagCallback;
-  }
-  callback_->func = mutation_callback;
-
-  InvokeCallback();
-}
-
-void FlagImpl::InvokeCallback() const {
-  if (!callback_) return;
-
-  // Make a copy of the C-style function pointer that we are about to invoke
-  // before we release the lock guarding it.
-  FlagCallbackFunc cb = callback_->func;
-
-  // If the flag has a mutation callback this function invokes it. While the
-  // callback is being invoked the primary flag's mutex is unlocked and it is
-  // re-locked back after call to callback is completed. Callback invocation is
-  // guarded by flag's secondary mutex instead which prevents concurrent
-  // callback invocation. Note that it is possible for other thread to grab the
-  // primary lock and update flag's value at any time during the callback
-  // invocation. This is by design. Callback can get a value of the flag if
-  // necessary, but it might be different from the value initiated the callback
-  // and it also can be different by the time the callback invocation is
-  // completed. Requires that *primary_lock be held in exclusive mode; it may be
-  // released and reacquired by the implementation.
-  MutexRelock relock(*DataGuard());
-  y_absl::MutexLock lock(&callback_->guard);
-  cb();
-}
-
-std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
-  y_absl::MutexLock l(DataGuard());
-
-  bool modified = modified_;
-  bool on_command_line = on_command_line_;
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic: {
-      return y_absl::make_unique<FlagState>(
-          *this, OneWordValue().load(std::memory_order_acquire), modified,
-          on_command_line, ModificationCount());
-    }
-    case FlagValueStorageKind::kSequenceLocked: {
-      void* cloned = flags_internal::Alloc(op_);
-      // Read is guaranteed to be successful because we hold the lock.
-      bool success =
-          seq_lock_.TryRead(cloned, AtomicBufferValue(), Sizeof(op_));
-      assert(success);
-      static_cast<void>(success);
-      return y_absl::make_unique<FlagState>(*this, cloned, modified,
-                                          on_command_line, ModificationCount());
-    }
-    case FlagValueStorageKind::kAlignedBuffer: {
-      return y_absl::make_unique<FlagState>(
-          *this, flags_internal::Clone(op_, AlignedBufferValue()), modified,
-          on_command_line, ModificationCount());
-    }
-  }
-  return nullptr;
-}
-
-bool FlagImpl::RestoreState(const FlagState& flag_state) {
-  y_absl::MutexLock l(DataGuard());
-  if (flag_state.counter_ == ModificationCount()) {
-    return false;
-  }
-
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic:
-      StoreValue(&flag_state.value_.one_word);
-      break;
-    case FlagValueStorageKind::kSequenceLocked:
-    case FlagValueStorageKind::kAlignedBuffer:
-      StoreValue(flag_state.value_.heap_allocated);
-      break;
-  }
-
-  modified_ = flag_state.modified_;
-  on_command_line_ = flag_state.on_command_line_;
-
-  return true;
-}
-
-template <typename StorageT>
-StorageT* FlagImpl::OffsetValue() const {
-  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
-  // The offset is deduced via Flag value type specific op_.
-  size_t offset = flags_internal::ValueOffset(op_);
-
-  return reinterpret_cast<StorageT*>(p + offset);
-}
-
-void* FlagImpl::AlignedBufferValue() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kAlignedBuffer);
-  return OffsetValue<void>();
-}
-
-std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
-  return OffsetValue<std::atomic<uint64_t>>();
-}
-
-std::atomic<int64_t>& FlagImpl::OneWordValue() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
-         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
-  return OffsetValue<FlagOneWordValue>()->value;
-}
-
-// Attempts to parse supplied `value` string using parsing routine in the `flag`
-// argument. If parsing successful, this function replaces the dst with newly
-// parsed value. In case if any error is encountered in either step, the error
-// message is stored in 'err'
-std::unique_ptr<void, DynValueDeleter> FlagImpl::TryParse(
-    y_absl::string_view value, TString& err) const {
-  std::unique_ptr<void, DynValueDeleter> tentative_value = MakeInitValue();
-
-  TString parse_err;
-  if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) {
-    y_absl::string_view err_sep = parse_err.empty() ? "" : "; ";
-    err = y_absl::StrCat("Illegal value '", value, "' specified for flag '",
-                       Name(), "'", err_sep, parse_err);
-    return nullptr;
-  }
-
-  return tentative_value;
-}
-
-void FlagImpl::Read(void* dst) const {
-  auto* guard = DataGuard();  // Make sure flag initialized
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic: {
-      const int64_t one_word_val =
-          OneWordValue().load(std::memory_order_acquire);
-      std::memcpy(dst, &one_word_val, Sizeof(op_));
-      break;
-    }
-    case FlagValueStorageKind::kSequenceLocked: {
-      ReadSequenceLockedData(dst);
-      break;
-    }
-    case FlagValueStorageKind::kAlignedBuffer: {
-      y_absl::MutexLock l(guard);
-      flags_internal::CopyConstruct(op_, AlignedBufferValue(), dst);
-      break;
-    }
-  }
-}
-
-int64_t FlagImpl::ReadOneWord() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
-         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
-  auto* guard = DataGuard();  // Make sure flag initialized
-  (void)guard;
-  return OneWordValue().load(std::memory_order_acquire);
-}
-
-bool FlagImpl::ReadOneBool() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
-  auto* guard = DataGuard();  // Make sure flag initialized
-  (void)guard;
-  return y_absl::bit_cast<FlagValueAndInitBit<bool>>(
-             OneWordValue().load(std::memory_order_acquire))
-      .value;
-}
-
-void FlagImpl::ReadSequenceLockedData(void* dst) const {
-  int size = Sizeof(op_);
-  // Attempt to read using the sequence lock.
-  if (Y_ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) {
-    return;
-  }
-  // We failed due to contention. Acquire the lock to prevent contention
-  // and try again.
-  y_absl::ReaderMutexLock l(DataGuard());
-  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size);
-  assert(success);
-  static_cast<void>(success);
-}
-
-void FlagImpl::Write(const void* src) {
-  y_absl::MutexLock l(DataGuard());
-
-  if (ShouldValidateFlagValue(flags_internal::FastTypeId(op_))) {
-    std::unique_ptr<void, DynValueDeleter> obj{flags_internal::Clone(op_, src),
-                                               DynValueDeleter{op_}};
-    TString ignored_error;
-    TString src_as_str = flags_internal::Unparse(op_, src);
-    if (!flags_internal::Parse(op_, src_as_str, obj.get(), &ignored_error)) {
-      Y_ABSL_INTERNAL_LOG(ERROR, y_absl::StrCat("Attempt to set flag '", Name(),
-                                            "' to invalid value ", src_as_str));
-    }
-  }
-
-  StoreValue(src);
-}
-
-// Sets the value of the flag based on specified string `value`. If the flag
-// was successfully set to new value, it returns true. Otherwise, sets `err`
-// to indicate the error, leaves the flag unchanged, and returns false. There
-// are three ways to set the flag's value:
-//  * Update the current flag value
-//  * Update the flag's default value
-//  * Update the current flag value if it was never set before
-// The mode is selected based on 'set_mode' parameter.
-bool FlagImpl::ParseFrom(y_absl::string_view value, FlagSettingMode set_mode,
-                         ValueSource source, TString& err) {
-  y_absl::MutexLock l(DataGuard());
-
-  switch (set_mode) {
-    case SET_FLAGS_VALUE: {
-      // set or modify the flag's value
-      auto tentative_value = TryParse(value, err);
-      if (!tentative_value) return false;
-
-      StoreValue(tentative_value.get());
-
-      if (source == kCommandLine) {
-        on_command_line_ = true;
-      }
-      break;
-    }
-    case SET_FLAG_IF_DEFAULT: {
-      // set the flag's value, but only if it hasn't been set by someone else
-      if (modified_) {
-        // TODO(rogeeff): review and fix this semantic. Currently we do not fail
-        // in this case if flag is modified. This is misleading since the flag's
-        // value is not updated even though we return true.
-        // *err = y_absl::StrCat(Name(), " is already set to ",
-        //                     CurrentValue(), "\n");
-        // return false;
-        return true;
-      }
-      auto tentative_value = TryParse(value, err);
-      if (!tentative_value) return false;
-
-      StoreValue(tentative_value.get());
-      break;
-    }
-    case SET_FLAGS_DEFAULT: {
-      auto tentative_value = TryParse(value, err);
-      if (!tentative_value) return false;
-
-      if (DefaultKind() == FlagDefaultKind::kDynamicValue) {
-        void* old_value = default_value_.dynamic_value;
-        default_value_.dynamic_value = tentative_value.release();
-        tentative_value.reset(old_value);
-      } else {
-        default_value_.dynamic_value = tentative_value.release();
-        def_kind_ = static_cast<uint8_t>(FlagDefaultKind::kDynamicValue);
-      }
-
-      if (!modified_) {
-        // Need to set both default value *and* current, in this case.
-        StoreValue(default_value_.dynamic_value);
-        modified_ = false;
-      }
-      break;
-    }
-  }
-
-  return true;
-}
-
-void FlagImpl::CheckDefaultValueParsingRoundtrip() const {
-  TString v = DefaultValue();
-
-  y_absl::MutexLock lock(DataGuard());
-
-  auto dst = MakeInitValue();
-  TString error;
-  if (!flags_internal::Parse(op_, v, dst.get(), &error)) {
-    Y_ABSL_INTERNAL_LOG(
-        FATAL,
-        y_absl::StrCat("Flag ", Name(), " (from ", Filename(),
-                     "): string form of default value '", v,
-                     "' could not be parsed; error=", error));
-  }
-
-  // We do not compare dst to def since parsing/unparsing may make
-  // small changes, e.g., precision loss for floating point types.
-}
-
-bool FlagImpl::ValidateInputValue(y_absl::string_view value) const {
-  y_absl::MutexLock l(DataGuard());
-
-  auto obj = MakeInitValue();
-  TString ignored_error;
-  return flags_internal::Parse(op_, value, obj.get(), &ignored_error);
-}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.h
deleted file mode 100644
index bce5e32656..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag.h
+++ /dev/null
@@ -1,800 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_FLAG_H_
-#define Y_ABSL_FLAGS_INTERNAL_FLAG_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
-#include <cstring>
-#include <memory>
-#include <new>
-#include <util/generic/string.h>
-#include <type_traits>
-#include <typeinfo>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/call_once.h"
-#include "y_absl/base/casts.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/optimization.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/config.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/flags/internal/registry.h"
-#include "y_absl/flags/internal/sequence_lock.h"
-#include "y_absl/flags/marshalling.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/synchronization/mutex.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Forward declaration of y_absl::Flag<T> public API.
-namespace flags_internal {
-template <typename T>
-class Flag;
-}  // namespace flags_internal
-
-#if defined(_MSC_VER) && !defined(__clang__)
-template <typename T>
-class Flag;
-#else
-template <typename T>
-using Flag = flags_internal::Flag<T>;
-#endif
-
-template <typename T>
-Y_ABSL_MUST_USE_RESULT T GetFlag(const y_absl::Flag<T>& flag);
-
-template <typename T>
-void SetFlag(y_absl::Flag<T>* flag, const T& v);
-
-template <typename T, typename V>
-void SetFlag(y_absl::Flag<T>* flag, const V& v);
-
-template <typename U>
-const CommandLineFlag& GetFlagReflectionHandle(const y_absl::Flag<U>& f);
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag value type operations, eg., parsing, copying, etc. are provided
-// by function specific to that type with a signature matching FlagOpFn.
-
-namespace flags_internal {
-
-enum class FlagOp {
-  kAlloc,
-  kDelete,
-  kCopy,
-  kCopyConstruct,
-  kSizeof,
-  kFastTypeId,
-  kRuntimeTypeId,
-  kParse,
-  kUnparse,
-  kValueOffset,
-};
-using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
-
-// Forward declaration for Flag value specific operations.
-template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
-
-// Allocate aligned memory for a flag value.
-inline void* Alloc(FlagOpFn op) {
-  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
-}
-// Deletes memory interpreting obj as flag value type pointer.
-inline void Delete(FlagOpFn op, void* obj) {
-  op(FlagOp::kDelete, nullptr, obj, nullptr);
-}
-// Copies src to dst interpreting as flag value type pointers.
-inline void Copy(FlagOpFn op, const void* src, void* dst) {
-  op(FlagOp::kCopy, src, dst, nullptr);
-}
-// Construct a copy of flag value in a location pointed by dst
-// based on src - pointer to the flag's value.
-inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
-  op(FlagOp::kCopyConstruct, src, dst, nullptr);
-}
-// Makes a copy of flag value pointed by obj.
-inline void* Clone(FlagOpFn op, const void* obj) {
-  void* res = flags_internal::Alloc(op);
-  flags_internal::CopyConstruct(op, obj, res);
-  return res;
-}
-// Returns true if parsing of input text is successfull.
-inline bool Parse(FlagOpFn op, y_absl::string_view text, void* dst,
-                  TString* error) {
-  return op(FlagOp::kParse, &text, dst, error) != nullptr;
-}
-// Returns string representing supplied value.
-inline TString Unparse(FlagOpFn op, const void* val) {
-  TString result;
-  op(FlagOp::kUnparse, val, &result, nullptr);
-  return result;
-}
-// Returns size of flag value type.
-inline size_t Sizeof(FlagOpFn op) {
-  // This sequence of casts reverses the sequence from
-  // `flags_internal::FlagOps()`
-  return static_cast<size_t>(reinterpret_cast<intptr_t>(
-      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
-}
-// Returns fast type id coresponding to the value type.
-inline FlagFastTypeId FastTypeId(FlagOpFn op) {
-  return reinterpret_cast<FlagFastTypeId>(
-      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
-}
-// Returns fast type id coresponding to the value type.
-inline const std::type_info* RuntimeTypeId(FlagOpFn op) {
-  return reinterpret_cast<const std::type_info*>(
-      op(FlagOp::kRuntimeTypeId, nullptr, nullptr, nullptr));
-}
-// Returns offset of the field value_ from the field impl_ inside of
-// y_absl::Flag<T> data. Given FlagImpl pointer p you can get the
-// location of the corresponding value as:
-//      reinterpret_cast<char*>(p) + ValueOffset().
-inline ptrdiff_t ValueOffset(FlagOpFn op) {
-  // This sequence of casts reverses the sequence from
-  // `flags_internal::FlagOps()`
-  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
-      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
-}
-
-// Returns an address of RTTI's typeid(T).
-template <typename T>
-inline const std::type_info* GenRuntimeTypeId() {
-#ifdef Y_ABSL_INTERNAL_HAS_RTTI
-  return &typeid(T);
-#else
-  return nullptr;
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag help auxiliary structs.
-
-// This is help argument for y_absl::Flag encapsulating the string literal pointer
-// or pointer to function generating it as well as enum descriminating two
-// cases.
-using HelpGenFunc = TString (*)();
-
-template <size_t N>
-struct FixedCharArray {
-  char value[N];
-
-  template <size_t... I>
-  static constexpr FixedCharArray<N> FromLiteralString(
-      y_absl::string_view str, y_absl::index_sequence<I...>) {
-    return (void)str, FixedCharArray<N>({{str[I]..., '\0'}});
-  }
-};
-
-template <typename Gen, size_t N = Gen::Value().size()>
-constexpr FixedCharArray<N + 1> HelpStringAsArray(int) {
-  return FixedCharArray<N + 1>::FromLiteralString(
-      Gen::Value(), y_absl::make_index_sequence<N>{});
-}
-
-template <typename Gen>
-constexpr std::false_type HelpStringAsArray(char) {
-  return std::false_type{};
-}
-
-union FlagHelpMsg {
-  constexpr explicit FlagHelpMsg(const char* help_msg) : literal(help_msg) {}
-  constexpr explicit FlagHelpMsg(HelpGenFunc help_gen) : gen_func(help_gen) {}
-
-  const char* literal;
-  HelpGenFunc gen_func;
-};
-
-enum class FlagHelpKind : uint8_t { kLiteral = 0, kGenFunc = 1 };
-
-struct FlagHelpArg {
-  FlagHelpMsg source;
-  FlagHelpKind kind;
-};
-
-extern const char kStrippedFlagHelp[];
-
-// These two HelpArg overloads allows us to select at compile time one of two
-// way to pass Help argument to y_absl::Flag. We'll be passing
-// AbslFlagHelpGenFor##name as Gen and integer 0 as a single argument to prefer
-// first overload if possible. If help message is evaluatable on constexpr
-// context We'll be able to make FixedCharArray out of it and we'll choose first
-// overload. In this case the help message expression is immediately evaluated
-// and is used to construct the y_absl::Flag. No additionl code is generated by
-// Y_ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
-// consideration, in which case the second overload will be used. The second
-// overload does not attempt to evaluate the help message expression
-// immediately and instead delays the evaluation by returing the function
-// pointer (&T::NonConst) genering the help message when necessary. This is
-// evaluatable in constexpr context, but the cost is an extra function being
-// generated in the Y_ABSL_FLAG code.
-template <typename Gen, size_t N>
-constexpr FlagHelpArg HelpArg(const FixedCharArray<N>& value) {
-  return {FlagHelpMsg(value.value), FlagHelpKind::kLiteral};
-}
-
-template <typename Gen>
-constexpr FlagHelpArg HelpArg(std::false_type) {
-  return {FlagHelpMsg(&Gen::NonConst), FlagHelpKind::kGenFunc};
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag default value auxiliary structs.
-
-// Signature for the function generating the initial flag value (usually
-// based on default value supplied in flag's definition)
-using FlagDfltGenFunc = void (*)(void*);
-
-union FlagDefaultSrc {
-  constexpr explicit FlagDefaultSrc(FlagDfltGenFunc gen_func_arg)
-      : gen_func(gen_func_arg) {}
-
-#define Y_ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE(T, name) \
-  T name##_value;                                  \
-  constexpr explicit FlagDefaultSrc(T value) : name##_value(value) {}  // NOLINT
-  Y_ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(Y_ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE)
-#undef Y_ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE
-
-  void* dynamic_value;
-  FlagDfltGenFunc gen_func;
-};
-
-enum class FlagDefaultKind : uint8_t {
-  kDynamicValue = 0,
-  kGenFunc = 1,
-  kOneWord = 2  // for default values UP to one word in size
-};
-
-struct FlagDefaultArg {
-  FlagDefaultSrc source;
-  FlagDefaultKind kind;
-};
-
-// This struct and corresponding overload to InitDefaultValue are used to
-// facilitate usage of {} as default value in Y_ABSL_FLAG macro.
-// TODO(rogeeff): Fix handling types with explicit constructors.
-struct EmptyBraces {};
-
-template <typename T>
-constexpr T InitDefaultValue(T t) {
-  return t;
-}
-
-template <typename T>
-constexpr T InitDefaultValue(EmptyBraces) {
-  return T{};
-}
-
-template <typename ValueT, typename GenT,
-          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
-              ((void)GenT{}, 0)>
-constexpr FlagDefaultArg DefaultArg(int) {
-  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
-}
-
-template <typename ValueT, typename GenT>
-constexpr FlagDefaultArg DefaultArg(char) {
-  return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag current value auxiliary structs.
-
-constexpr int64_t UninitializedFlagValue() {
-  return static_cast<int64_t>(0xababababababababll);
-}
-
-template <typename T>
-using FlagUseValueAndInitBitStorage = std::integral_constant<
-    bool, y_absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              std::is_default_constructible<T>::value && (sizeof(T) < 8)>;
-
-template <typename T>
-using FlagUseOneWordStorage = std::integral_constant<
-    bool, y_absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              (sizeof(T) <= 8)>;
-
-template <class T>
-using FlagUseSequenceLockStorage = std::integral_constant<
-    bool, y_absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              (sizeof(T) > 8)>;
-
-enum class FlagValueStorageKind : uint8_t {
-  kValueAndInitBit = 0,
-  kOneWordAtomic = 1,
-  kSequenceLocked = 2,
-  kAlignedBuffer = 3,
-};
-
-template <typename T>
-static constexpr FlagValueStorageKind StorageKind() {
-  return FlagUseValueAndInitBitStorage<T>::value
-             ? FlagValueStorageKind::kValueAndInitBit
-         : FlagUseOneWordStorage<T>::value
-             ? FlagValueStorageKind::kOneWordAtomic
-         : FlagUseSequenceLockStorage<T>::value
-             ? FlagValueStorageKind::kSequenceLocked
-             : FlagValueStorageKind::kAlignedBuffer;
-}
-
-struct FlagOneWordValue {
-  constexpr explicit FlagOneWordValue(int64_t v) : value(v) {}
-  std::atomic<int64_t> value;
-};
-
-template <typename T>
-struct alignas(8) FlagValueAndInitBit {
-  T value;
-  // Use an int instead of a bool to guarantee that a non-zero value has
-  // a bit set.
-  uint8_t init;
-};
-
-template <typename T,
-          FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
-struct FlagValue;
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kValueAndInitBit> : FlagOneWordValue {
-  constexpr FlagValue() : FlagOneWordValue(0) {}
-  bool Get(const SequenceLock&, T& dst) const {
-    int64_t storage = value.load(std::memory_order_acquire);
-    if (Y_ABSL_PREDICT_FALSE(storage == 0)) {
-      return false;
-    }
-    dst = y_absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
-    return true;
-  }
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
-  constexpr FlagValue() : FlagOneWordValue(UninitializedFlagValue()) {}
-  bool Get(const SequenceLock&, T& dst) const {
-    int64_t one_word_val = value.load(std::memory_order_acquire);
-    if (Y_ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
-      return false;
-    }
-    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
-    return true;
-  }
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kSequenceLocked> {
-  bool Get(const SequenceLock& lock, T& dst) const {
-    return lock.TryRead(&dst, value_words, sizeof(T));
-  }
-
-  static constexpr int kNumWords =
-      flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t);
-
-  alignas(T) alignas(
-      std::atomic<uint64_t>) std::atomic<uint64_t> value_words[kNumWords];
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kAlignedBuffer> {
-  bool Get(const SequenceLock&, T&) const { return false; }
-
-  alignas(T) char value[sizeof(T)];
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag callback auxiliary structs.
-
-// Signature for the mutation callback used by watched Flags
-// The callback is noexcept.
-// TODO(rogeeff): add noexcept after C++17 support is added.
-using FlagCallbackFunc = void (*)();
-
-struct FlagCallback {
-  FlagCallbackFunc func;
-  y_absl::Mutex guard;  // Guard for concurrent callback invocations.
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag implementation, which does not depend on flag value type.
-// The class encapsulates the Flag's data and access to it.
-
-struct DynValueDeleter {
-  explicit DynValueDeleter(FlagOpFn op_arg = nullptr);
-  void operator()(void* ptr) const;
-
-  FlagOpFn op;
-};
-
-class FlagState;
-
-class FlagImpl final : public CommandLineFlag {
- public:
-  constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op,
-                     FlagHelpArg help, FlagValueStorageKind value_kind,
-                     FlagDefaultArg default_arg)
-      : name_(name),
-        filename_(filename),
-        op_(op),
-        help_(help.source),
-        help_source_kind_(static_cast<uint8_t>(help.kind)),
-        value_storage_kind_(static_cast<uint8_t>(value_kind)),
-        def_kind_(static_cast<uint8_t>(default_arg.kind)),
-        modified_(false),
-        on_command_line_(false),
-        callback_(nullptr),
-        default_value_(default_arg.source),
-        data_guard_{} {}
-
-  // Constant access methods
-  int64_t ReadOneWord() const Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool ReadOneBool() const Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(void* dst) const override Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(bool* value) const Y_ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    *value = ReadOneBool();
-  }
-  template <typename T,
-            y_absl::enable_if_t<flags_internal::StorageKind<T>() ==
-                                  FlagValueStorageKind::kOneWordAtomic,
-                              int> = 0>
-  void Read(T* value) const Y_ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    int64_t v = ReadOneWord();
-    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
-  }
-  template <typename T,
-            typename std::enable_if<flags_internal::StorageKind<T>() ==
-                                        FlagValueStorageKind::kValueAndInitBit,
-                                    int>::type = 0>
-  void Read(T* value) const Y_ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    *value = y_absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
-  }
-
-  // Mutating access methods
-  void Write(const void* src) Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Interfaces to operate on callbacks.
-  void SetCallback(const FlagCallbackFunc mutation_callback)
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void InvokeCallback() const Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Used in read/write operations to validate source/target has correct type.
-  // For example if flag is declared as y_absl::Flag<int> FLAGS_foo, a call to
-  // y_absl::GetFlag(FLAGS_foo) validates that the type of FLAGS_foo is indeed
-  // int. To do that we pass the "assumed" type id (which is deduced from type
-  // int) as an argument `type_id`, which is in turn is validated against the
-  // type id stored in flag object by flag definition statement.
-  void AssertValidType(FlagFastTypeId type_id,
-                       const std::type_info* (*gen_rtti)()) const;
-
- private:
-  template <typename T>
-  friend class Flag;
-  friend class FlagState;
-
-  // Ensures that `data_guard_` is initialized and returns it.
-  y_absl::Mutex* DataGuard() const
-      Y_ABSL_LOCK_RETURNED(reinterpret_cast<y_absl::Mutex*>(data_guard_));
-  // Returns heap allocated value of type T initialized with default value.
-  std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
-      Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-  // Flag initialization called via y_absl::call_once.
-  void Init();
-
-  // Offset value access methods. One per storage kind. These methods to not
-  // respect const correctness, so be very carefull using them.
-
-  // This is a shared helper routine which encapsulates most of the magic. Since
-  // it is only used inside the three routines below, which are defined in
-  // flag.cc, we can define it in that file as well.
-  template <typename StorageT>
-  StorageT* OffsetValue() const;
-  // This is an accessor for a value stored in an aligned buffer storage
-  // used for non-trivially-copyable data types.
-  // Returns a mutable pointer to the start of a buffer.
-  void* AlignedBufferValue() const;
-
-  // The same as above, but used for sequencelock-protected storage.
-  std::atomic<uint64_t>* AtomicBufferValue() const;
-
-  // This is an accessor for a value stored as one word atomic. Returns a
-  // mutable reference to an atomic value.
-  std::atomic<int64_t>& OneWordValue() const;
-
-  // Attempts to parse supplied `value` string. If parsing is successful,
-  // returns new value. Otherwise returns nullptr.
-  std::unique_ptr<void, DynValueDeleter> TryParse(y_absl::string_view value,
-                                                  TString& err) const
-      Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-  // Stores the flag value based on the pointer to the source.
-  void StoreValue(const void* src) Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Copy the flag data, protected by `seq_lock_` into `dst`.
-  //
-  // REQUIRES: ValueStorageKind() == kSequenceLocked.
-  void ReadSequenceLockedData(void* dst) const
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  FlagHelpKind HelpSourceKind() const {
-    return static_cast<FlagHelpKind>(help_source_kind_);
-  }
-  FlagValueStorageKind ValueStorageKind() const {
-    return static_cast<FlagValueStorageKind>(value_storage_kind_);
-  }
-  FlagDefaultKind DefaultKind() const
-      Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
-    return static_cast<FlagDefaultKind>(def_kind_);
-  }
-
-  // CommandLineFlag interface implementation
-  y_absl::string_view Name() const override;
-  TString Filename() const override;
-  TString Help() const override;
-  FlagFastTypeId TypeId() const override;
-  bool IsSpecifiedOnCommandLine() const override
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  TString DefaultValue() const override Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  TString CurrentValue() const override Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool ValidateInputValue(y_absl::string_view value) const override
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void CheckDefaultValueParsingRoundtrip() const override
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  int64_t ModificationCount() const Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Interfaces to save and restore flags to/from persistent state.
-  // Returns current flag state or nullptr if flag does not support
-  // saving and restoring a state.
-  std::unique_ptr<FlagStateInterface> SaveState() override
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Restores the flag state to the supplied state object. If there is
-  // nothing to restore returns false. Otherwise returns true.
-  bool RestoreState(const FlagState& flag_state)
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  bool ParseFrom(y_absl::string_view value, FlagSettingMode set_mode,
-                 ValueSource source, TString& error) override
-      Y_ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Immutable flag's state.
-
-  // Flags name passed to Y_ABSL_FLAG as second arg.
-  const char* const name_;
-  // The file name where Y_ABSL_FLAG resides.
-  const char* const filename_;
-  // Type-specific operations "vtable".
-  const FlagOpFn op_;
-  // Help message literal or function to generate it.
-  const FlagHelpMsg help_;
-  // Indicates if help message was supplied as literal or generator func.
-  const uint8_t help_source_kind_ : 1;
-  // Kind of storage this flag is using for the flag's value.
-  const uint8_t value_storage_kind_ : 2;
-
-  uint8_t : 0;  // The bytes containing the const bitfields must not be
-                // shared with bytes containing the mutable bitfields.
-
-  // Mutable flag's state (guarded by `data_guard_`).
-
-  // def_kind_ is not guard by DataGuard() since it is accessed in Init without
-  // locks.
-  uint8_t def_kind_ : 2;
-  // Has this flag's value been modified?
-  bool modified_ : 1 Y_ABSL_GUARDED_BY(*DataGuard());
-  // Has this flag been specified on command line.
-  bool on_command_line_ : 1 Y_ABSL_GUARDED_BY(*DataGuard());
-
-  // Unique tag for y_absl::call_once call to initialize this flag.
-  y_absl::once_flag init_control_;
-
-  // Sequence lock / mutation counter.
-  flags_internal::SequenceLock seq_lock_;
-
-  // Optional flag's callback and y_absl::Mutex to guard the invocations.
-  FlagCallback* callback_ Y_ABSL_GUARDED_BY(*DataGuard());
-  // Either a pointer to the function generating the default value based on the
-  // value specified in Y_ABSL_FLAG or pointer to the dynamically set default
-  // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
-  // these two cases.
-  FlagDefaultSrc default_value_;
-
-  // This is reserved space for an y_absl::Mutex to guard flag data. It will be
-  // initialized in FlagImpl::Init via placement new.
-  // We can't use "y_absl::Mutex data_guard_", since this class is not literal.
-  // We do not want to use "y_absl::Mutex* data_guard_", since this would require
-  // heap allocation during initialization, which is both slows program startup
-  // and can fail. Using reserved space + placement new allows us to avoid both
-  // problems.
-  alignas(y_absl::Mutex) mutable char data_guard_[sizeof(y_absl::Mutex)];
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// The Flag object parameterized by the flag's value type. This class implements
-// flag reflection handle interface.
-
-template <typename T>
-class Flag {
- public:
-  constexpr Flag(const char* name, const char* filename, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : impl_(name, filename, &FlagOps<T>, help,
-              flags_internal::StorageKind<T>(), default_arg),
-        value_() {}
-
-  // CommandLineFlag interface
-  y_absl::string_view Name() const { return impl_.Name(); }
-  TString Filename() const { return impl_.Filename(); }
-  TString Help() const { return impl_.Help(); }
-  // Do not use. To be removed.
-  bool IsSpecifiedOnCommandLine() const {
-    return impl_.IsSpecifiedOnCommandLine();
-  }
-  TString DefaultValue() const { return impl_.DefaultValue(); }
-  TString CurrentValue() const { return impl_.CurrentValue(); }
-
- private:
-  template <typename, bool>
-  friend class FlagRegistrar;
-  friend class FlagImplPeer;
-
-  T Get() const {
-    // See implementation notes in CommandLineFlag::Get().
-    union U {
-      T value;
-      U() {}
-      ~U() { value.~T(); }
-    };
-    U u;
-
-#if !defined(NDEBUG)
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
-#endif
-
-    if (Y_ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
-      impl_.Read(&u.value);
-    }
-    return std::move(u.value);
-  }
-  void Set(const T& v) {
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
-    impl_.Write(&v);
-  }
-
-  // Access to the reflection.
-  const CommandLineFlag& Reflect() const { return impl_; }
-
-  // Flag's data
-  // The implementation depends on value_ field to be placed exactly after the
-  // impl_ field, so that impl_ can figure out the offset to the value and
-  // access it.
-  FlagImpl impl_;
-  FlagValue<T> value_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Trampoline for friend access
-
-class FlagImplPeer {
- public:
-  template <typename T, typename FlagType>
-  static T InvokeGet(const FlagType& flag) {
-    return flag.Get();
-  }
-  template <typename FlagType, typename T>
-  static void InvokeSet(FlagType& flag, const T& v) {
-    flag.Set(v);
-  }
-  template <typename FlagType>
-  static const CommandLineFlag& InvokeReflect(const FlagType& f) {
-    return f.Reflect();
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of Flag value specific operations routine.
-template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
-  switch (op) {
-    case FlagOp::kAlloc: {
-      std::allocator<T> alloc;
-      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
-    }
-    case FlagOp::kDelete: {
-      T* p = static_cast<T*>(v2);
-      p->~T();
-      std::allocator<T> alloc;
-      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
-      return nullptr;
-    }
-    case FlagOp::kCopy:
-      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
-      return nullptr;
-    case FlagOp::kCopyConstruct:
-      new (v2) T(*static_cast<const T*>(v1));
-      return nullptr;
-    case FlagOp::kSizeof:
-      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
-    case FlagOp::kFastTypeId:
-      return const_cast<void*>(base_internal::FastTypeId<T>());
-    case FlagOp::kRuntimeTypeId:
-      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
-    case FlagOp::kParse: {
-      // Initialize the temporary instance of type T based on current value in
-      // destination (which is going to be flag's default value).
-      T temp(*static_cast<T*>(v2));
-      if (!y_absl::ParseFlag<T>(*static_cast<const y_absl::string_view*>(v1), &temp,
-                              static_cast<TString*>(v3))) {
-        return nullptr;
-      }
-      *static_cast<T*>(v2) = std::move(temp);
-      return v2;
-    }
-    case FlagOp::kUnparse:
-      *static_cast<TString*>(v2) =
-          y_absl::UnparseFlag<T>(*static_cast<const T*>(v1));
-      return nullptr;
-    case FlagOp::kValueOffset: {
-      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
-      // offset of the data.
-      size_t round_to = alignof(FlagValue<T>);
-      size_t offset =
-          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
-      return reinterpret_cast<void*>(offset);
-    }
-  }
-  return nullptr;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// This class facilitates Flag object registration and tail expression-based
-// flag definition, for example:
-// Y_ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
-struct FlagRegistrarEmpty {};
-template <typename T, bool do_register>
-class FlagRegistrar {
- public:
-  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
-    if (do_register)
-      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
-  }
-
-  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
-    flag_.impl_.SetCallback(cb);
-    return *this;
-  }
-
-  // Make the registrar "die" gracefully as an empty struct on a line where
-  // registration happens. Registrar objects are intended to live only as
-  // temporary.
-  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
-
- private:
-  Flag<T>& flag_;  // Flag being registered (not owned).
-};
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_FLAG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag_msvc.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag_msvc.inc
deleted file mode 100644
index f9beb09f90..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag_msvc.inc
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-//  Copyright 2021 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.
-
-// Do not include this file directly.
-// Include y_absl/flags/flag.h instead.
-
-// MSVC debug builds do not implement initialization with constexpr constructors
-// correctly. To work around this we add a level of indirection, so that the
-// class `y_absl::Flag` contains an `internal::Flag*` (instead of being an alias
-// to that class) and dynamically allocates an instance when necessary. We also
-// forward all calls to internal::Flag methods via trampoline methods. In this
-// setup the `y_absl::Flag` class does not have constructor and virtual methods,
-// all the data members are public and thus MSVC is able to initialize it at
-// link time. To deal with multiple threads accessing the flag for the first
-// time concurrently we use an atomic boolean indicating if flag object is
-// initialized. We also employ the double-checked locking pattern where the
-// second level of protection is a global Mutex, so if two threads attempt to
-// construct the flag concurrently only one wins.
-//
-// This solution is based on a recomendation here:
-// https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html?childToView=648454#comment-648454
-
-namespace flags_internal {
-y_absl::Mutex* GetGlobalConstructionGuard();
-}  // namespace flags_internal
-
-// Public methods of `y_absl::Flag<T>` are NOT part of the Abseil Flags API.
-// See https://abseil.io/docs/cpp/guides/flags
-template <typename T>
-class Flag {
- public:
-  // No constructor and destructor to ensure this is an aggregate type.
-  // Visual Studio 2015 still requires the constructor for class to be
-  // constexpr initializable.
-#if _MSC_VER <= 1900
-  constexpr Flag(const char* name, const char* filename,
-                 const flags_internal::HelpGenFunc help_gen,
-                 const flags_internal::FlagDfltGenFunc default_value_gen)
-      : name_(name),
-        filename_(filename),
-        help_gen_(help_gen),
-        default_value_gen_(default_value_gen),
-        inited_(false),
-        impl_(nullptr) {}
-#endif
-
-  flags_internal::Flag<T>& GetImpl() const {
-    if (!inited_.load(std::memory_order_acquire)) {
-      y_absl::MutexLock l(flags_internal::GetGlobalConstructionGuard());
-
-      if (inited_.load(std::memory_order_acquire)) {
-        return *impl_;
-      }
-
-      impl_ = new flags_internal::Flag<T>(
-          name_, filename_,
-          {flags_internal::FlagHelpMsg(help_gen_),
-           flags_internal::FlagHelpKind::kGenFunc},
-          {flags_internal::FlagDefaultSrc(default_value_gen_),
-           flags_internal::FlagDefaultKind::kGenFunc});
-      inited_.store(true, std::memory_order_release);
-    }
-
-    return *impl_;
-  }
-
-  // Public methods of `y_absl::Flag<T>` are NOT part of the Abseil Flags API.
-  // See https://abseil.io/docs/cpp/guides/flags
-  bool IsRetired() const { return GetImpl().IsRetired(); }
-  y_absl::string_view Name() const { return GetImpl().Name(); }
-  TString Help() const { return GetImpl().Help(); }
-  bool IsModified() const { return GetImpl().IsModified(); }
-  bool IsSpecifiedOnCommandLine() const {
-    return GetImpl().IsSpecifiedOnCommandLine();
-  }
-  TString Filename() const { return GetImpl().Filename(); }
-  TString DefaultValue() const { return GetImpl().DefaultValue(); }
-  TString CurrentValue() const { return GetImpl().CurrentValue(); }
-  template <typename U>
-  inline bool IsOfType() const {
-    return GetImpl().template IsOfType<U>();
-  }
-  T Get() const {
-    return flags_internal::FlagImplPeer::InvokeGet<T>(GetImpl());
-  }
-  void Set(const T& v) {
-    flags_internal::FlagImplPeer::InvokeSet(GetImpl(), v);
-  }
-  void InvokeCallback() { GetImpl().InvokeCallback(); }
-
-  const CommandLineFlag& Reflect() const {
-    return flags_internal::FlagImplPeer::InvokeReflect(GetImpl());
-  }
-
-  // The data members are logically private, but they need to be public for
-  // this to be an aggregate type.
-  const char* name_;
-  const char* filename_;
-  const flags_internal::HelpGenFunc help_gen_;
-  const flags_internal::FlagDfltGenFunc default_value_gen_;
-
-  mutable std::atomic<bool> inited_;
-  mutable flags_internal::Flag<T>* impl_;
-};
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/parse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/parse.h
deleted file mode 100644
index 64125f1489..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/parse.h
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_PARSE_H_
-#define Y_ABSL_FLAGS_INTERNAL_PARSE_H_
-
-#include <util/generic/string.h>
-#include <vector>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/declare.h"
-#include "y_absl/strings/string_view.h"
-
-Y_ABSL_DECLARE_FLAG(std::vector<TString>, flagfile);
-Y_ABSL_DECLARE_FLAG(std::vector<TString>, fromenv);
-Y_ABSL_DECLARE_FLAG(std::vector<TString>, tryfromenv);
-Y_ABSL_DECLARE_FLAG(std::vector<TString>, undefok);
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-enum class ArgvListAction { kRemoveParsedArgs, kKeepParsedArgs };
-enum class UsageFlagsAction { kHandleUsage, kIgnoreUsage };
-enum class OnUndefinedFlag {
-  kIgnoreUndefined,
-  kReportUndefined,
-  kAbortIfUndefined
-};
-
-std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
-                                        ArgvListAction arg_list_act,
-                                        UsageFlagsAction usage_flag_act,
-                                        OnUndefinedFlag on_undef_flag);
-
-// --------------------------------------------------------------------
-// Inspect original command line
-
-// Returns true if flag with specified name was either present on the original
-// command line or specified in flag file present on the original command line.
-bool WasPresentOnCommandLine(y_absl::string_view flag_name);
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_PARSE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/path_util.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/path_util.h
deleted file mode 100644
index 7c382c87db..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/path_util.h
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-//  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 Y_ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
-#define Y_ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
-
-#include "y_absl/base/config.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// A portable interface that returns the basename of the filename passed as an
-// argument. It is similar to basename(3)
-// <https://linux.die.net/man/3/basename>.
-// For example:
-//     flags_internal::Basename("a/b/prog/file.cc")
-// returns "file.cc"
-//     flags_internal::Basename("file.cc")
-// returns "file.cc"
-inline y_absl::string_view Basename(y_absl::string_view filename) {
-  auto last_slash_pos = filename.find_last_of("/\\");
-
-  return last_slash_pos == y_absl::string_view::npos
-             ? filename
-             : filename.substr(last_slash_pos + 1);
-}
-
-// A portable interface that returns the directory name of the filename
-// passed as an argument, including the trailing slash.
-// Returns the empty string if a slash is not found in the input file name.
-// For example:
-//      flags_internal::Package("a/b/prog/file.cc")
-// returns "a/b/prog/"
-//      flags_internal::Package("file.cc")
-// returns ""
-inline y_absl::string_view Package(y_absl::string_view filename) {
-  auto last_slash_pos = filename.find_last_of("/\\");
-
-  return last_slash_pos == y_absl::string_view::npos
-             ? y_absl::string_view()
-             : filename.substr(0, last_slash_pos + 1);
-}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.cc
deleted file mode 100644
index 4bba3943dc..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// 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/flags/internal/private_handle_accessor.h"
-
-#include <memory>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-FlagFastTypeId PrivateHandleAccessor::TypeId(const CommandLineFlag& flag) {
-  return flag.TypeId();
-}
-
-std::unique_ptr<FlagStateInterface> PrivateHandleAccessor::SaveState(
-    CommandLineFlag& flag) {
-  return flag.SaveState();
-}
-
-bool PrivateHandleAccessor::IsSpecifiedOnCommandLine(
-    const CommandLineFlag& flag) {
-  return flag.IsSpecifiedOnCommandLine();
-}
-
-bool PrivateHandleAccessor::ValidateInputValue(const CommandLineFlag& flag,
-                                               y_absl::string_view value) {
-  return flag.ValidateInputValue(value);
-}
-
-void PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
-    const CommandLineFlag& flag) {
-  flag.CheckDefaultValueParsingRoundtrip();
-}
-
-bool PrivateHandleAccessor::ParseFrom(CommandLineFlag& flag,
-                                      y_absl::string_view value,
-                                      flags_internal::FlagSettingMode set_mode,
-                                      flags_internal::ValueSource source,
-                                      TString& error) {
-  return flag.ParseFrom(value, set_mode, source, error);
-}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.h
deleted file mode 100644
index 889a09537f..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor.h
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
-#define Y_ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
-
-#include <memory>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// This class serves as a trampoline to access private methods of
-// CommandLineFlag. This class is intended for use exclusively internally inside
-// of the Abseil Flags implementation.
-class PrivateHandleAccessor {
- public:
-  // Access to CommandLineFlag::TypeId.
-  static FlagFastTypeId TypeId(const CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::SaveState.
-  static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::IsSpecifiedOnCommandLine.
-  static bool IsSpecifiedOnCommandLine(const CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::ValidateInputValue.
-  static bool ValidateInputValue(const CommandLineFlag& flag,
-                                 y_absl::string_view value);
-
-  // Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
-  static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
-
-  static bool ParseFrom(CommandLineFlag& flag, y_absl::string_view value,
-                        flags_internal::FlagSettingMode set_mode,
-                        flags_internal::ValueSource source, TString& error);
-};
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.cc
deleted file mode 100644
index 7739f99089..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-//  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.
-
-#include "y_absl/flags/internal/program_name.h"
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/const_init.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/flags/internal/path_util.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/synchronization/mutex.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-Y_ABSL_CONST_INIT static y_absl::Mutex program_name_guard(y_absl::kConstInit);
-Y_ABSL_CONST_INIT static TString* program_name
-    Y_ABSL_GUARDED_BY(program_name_guard) = nullptr;
-
-TString ProgramInvocationName() {
-  y_absl::MutexLock l(&program_name_guard);
-
-  return program_name ? *program_name : "UNKNOWN";
-}
-
-TString ShortProgramInvocationName() {
-  y_absl::MutexLock l(&program_name_guard);
-
-  return program_name ? TString(flags_internal::Basename(*program_name))
-                      : "UNKNOWN";
-}
-
-void SetProgramInvocationName(y_absl::string_view prog_name_str) {
-  y_absl::MutexLock l(&program_name_guard);
-
-  if (!program_name)
-    program_name = new TString(prog_name_str);
-  else
-    program_name->assign(prog_name_str.data(), prog_name_str.size());
-}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.h
deleted file mode 100644
index 817f93e094..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-//  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 Y_ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
-#define Y_ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/strings/string_view.h"
-
-// --------------------------------------------------------------------
-// Program name
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Returns program invocation name or "UNKNOWN" if `SetProgramInvocationName()`
-// is never called. At the moment this is always set to argv[0] as part of
-// library initialization.
-TString ProgramInvocationName();
-
-// Returns base name for program invocation name. For example, if
-//   ProgramInvocationName() == "a/b/mybinary"
-// then
-//   ShortProgramInvocationName() == "mybinary"
-TString ShortProgramInvocationName();
-
-// Sets program invocation name to a new value. Should only be called once
-// during program initialization, before any threads are spawned.
-void SetProgramInvocationName(y_absl::string_view prog_name_str);
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/registry.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/registry.h
deleted file mode 100644
index cb3afdd890..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/registry.h
+++ /dev/null
@@ -1,97 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_REGISTRY_H_
-#define Y_ABSL_FLAGS_INTERNAL_REGISTRY_H_
-
-#include <functional>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/strings/string_view.h"
-
-// --------------------------------------------------------------------
-// Global flags registry API.
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Executes specified visitor for each non-retired flag in the registry. While
-// callback are executed, the registry is locked and can't be changed.
-void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
-
-//-----------------------------------------------------------------------------
-
-bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename);
-
-void FinalizeRegistry();
-
-//-----------------------------------------------------------------------------
-// Retired registrations:
-//
-// Retired flag registrations are treated specially. A 'retired' flag is
-// provided only for compatibility with automated invocations that still
-// name it.  A 'retired' flag:
-//   - is not bound to a C++ FLAGS_ reference.
-//   - has a type and a value, but that value is intentionally inaccessible.
-//   - does not appear in --help messages.
-//   - is fully supported by _all_ flag parsing routines.
-//   - consumes args normally, and complains about type mismatches in its
-//     argument.
-//   - emits a complaint but does not die (e.g. LOG(ERROR)) if it is
-//     accessed by name through the flags API for parsing or otherwise.
-//
-// The registrations for a flag happen in an unspecified order as the
-// initializers for the namespace-scope objects of a program are run.
-// Any number of weak registrations for a flag can weakly define the flag.
-// One non-weak registration will upgrade the flag from weak to non-weak.
-// Further weak registrations of a non-weak flag are ignored.
-//
-// This mechanism is designed to support moving dead flags into a
-// 'graveyard' library.  An example migration:
-//
-//   0: Remove references to this FLAGS_flagname in the C++ codebase.
-//   1: Register as 'retired' in old_lib.
-//   2: Make old_lib depend on graveyard.
-//   3: Add a redundant 'retired' registration to graveyard.
-//   4: Remove the old_lib 'retired' registration.
-//   5: Eventually delete the graveyard registration entirely.
-//
-
-// Retire flag with name "name" and type indicated by ops.
-void Retire(const char* name, FlagFastTypeId type_id, char* buf);
-
-constexpr size_t kRetiredFlagObjSize = 3 * sizeof(void*);
-constexpr size_t kRetiredFlagObjAlignment = alignof(void*);
-
-// Registered a retired flag with name 'flag_name' and type 'T'.
-template <typename T>
-class RetiredFlag {
- public:
-  void Retire(const char* flag_name) {
-    flags_internal::Retire(flag_name, base_internal::FastTypeId<T>(), buf_);
-  }
-
- private:
-  alignas(kRetiredFlagObjAlignment) char buf_[kRetiredFlagObjSize];
-};
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_REGISTRY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/sequence_lock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/sequence_lock.h
deleted file mode 100644
index 269b3413c8..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/sequence_lock.h
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// 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 Y_ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
-#define Y_ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
-#include <cassert>
-#include <cstring>
-
-#include "y_absl/base/optimization.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Align 'x' up to the nearest 'align' bytes.
-inline constexpr size_t AlignUp(size_t x, size_t align) {
-  return align * ((x + align - 1) / align);
-}
-
-// A SequenceLock implements lock-free reads. A sequence counter is incremented
-// before and after each write, and readers access the counter before and after
-// accessing the protected data. If the counter is verified to not change during
-// the access, and the sequence counter value was even, then the reader knows
-// that the read was race-free and valid. Otherwise, the reader must fall back
-// to a Mutex-based code path.
-//
-// This particular SequenceLock starts in an "uninitialized" state in which
-// TryRead() returns false. It must be enabled by calling MarkInitialized().
-// This serves as a marker that the associated flag value has not yet been
-// initialized and a slow path needs to be taken.
-//
-// The memory reads and writes protected by this lock must use the provided
-// `TryRead()` and `Write()` functions. These functions behave similarly to
-// `memcpy()`, with one oddity: the protected data must be an array of
-// `std::atomic<uint64>`. This is to comply with the C++ standard, which
-// considers data races on non-atomic objects to be undefined behavior. See "Can
-// Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J.
-// Boehm for more details.
-//
-// [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
-class SequenceLock {
- public:
-  constexpr SequenceLock() : lock_(kUninitialized) {}
-
-  // Mark that this lock is ready for use.
-  void MarkInitialized() {
-    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
-    lock_.store(0, std::memory_order_release);
-  }
-
-  // Copy "size" bytes of data from "src" to "dst", protected as a read-side
-  // critical section of the sequence lock.
-  //
-  // Unlike traditional sequence lock implementations which loop until getting a
-  // clean read, this implementation returns false in the case of concurrent
-  // calls to `Write`. In such a case, the caller should fall back to a
-  // locking-based slow path.
-  //
-  // Returns false if the sequence lock was not yet marked as initialized.
-  //
-  // NOTE: If this returns false, "dst" may be overwritten with undefined
-  // (potentially uninitialized) data.
-  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
-    // Acquire barrier ensures that no loads done by f() are reordered
-    // above the first load of the sequence counter.
-    int64_t seq_before = lock_.load(std::memory_order_acquire);
-    if (Y_ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
-    RelaxedCopyFromAtomic(dst, src, size);
-    // Another acquire fence ensures that the load of 'lock_' below is
-    // strictly ordered after the RelaxedCopyToAtomic call above.
-    std::atomic_thread_fence(std::memory_order_acquire);
-    int64_t seq_after = lock_.load(std::memory_order_relaxed);
-    return Y_ABSL_PREDICT_TRUE(seq_before == seq_after);
-  }
-
-  // Copy "size" bytes from "src" to "dst" as a write-side critical section
-  // of the sequence lock. Any concurrent readers will be forced to retry
-  // until they get a read that does not conflict with this write.
-  //
-  // This call must be externally synchronized against other calls to Write,
-  // but may proceed concurrently with reads.
-  void Write(std::atomic<uint64_t>* dst, const void* src, size_t size) {
-    // We can use relaxed instructions to increment the counter since we
-    // are extenally synchronized. The std::atomic_thread_fence below
-    // ensures that the counter updates don't get interleaved with the
-    // copy to the data.
-    int64_t orig_seq = lock_.load(std::memory_order_relaxed);
-    assert((orig_seq & 1) == 0);  // Must be initially unlocked.
-    lock_.store(orig_seq + 1, std::memory_order_relaxed);
-
-    // We put a release fence between update to lock_ and writes to shared data.
-    // Thus all stores to shared data are effectively release operations and
-    // update to lock_ above cannot be re-ordered past any of them. Note that
-    // this barrier is not for the fetch_add above.  A release barrier for the
-    // fetch_add would be before it, not after.
-    std::atomic_thread_fence(std::memory_order_release);
-    RelaxedCopyToAtomic(dst, src, size);
-    // "Release" semantics ensure that none of the writes done by
-    // RelaxedCopyToAtomic() can be reordered after the following modification.
-    lock_.store(orig_seq + 2, std::memory_order_release);
-  }
-
-  // Return the number of times that Write() has been called.
-  //
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `IncrementModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  int64_t ModificationCount() const {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized && (val & 1) == 0);
-    return val / 2;
-  }
-
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `ModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  void IncrementModificationCount() {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized);
-    lock_.store(val + 2, std::memory_order_relaxed);
-  }
-
- private:
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src,
-                                    size_t size) {
-    char* dst_byte = static_cast<char*>(dst);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, sizeof(word));
-      dst_byte += sizeof(word);
-      src++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, size);
-    }
-  }
-
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src,
-                                  size_t size) {
-    const char* src_byte = static_cast<const char*>(src);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word;
-      std::memcpy(&word, src_byte, sizeof(word));
-      dst->store(word, std::memory_order_relaxed);
-      src_byte += sizeof(word);
-      dst++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = 0;
-      std::memcpy(&word, src_byte, size);
-      dst->store(word, std::memory_order_relaxed);
-    }
-  }
-
-  static constexpr int64_t kUninitialized = -1;
-  std::atomic<int64_t> lock_;
-};
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.cc
deleted file mode 100644
index cf7eff8ec9..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.cc
+++ /dev/null
@@ -1,524 +0,0 @@
-//
-// 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.
-
-#include "y_absl/flags/internal/usage.h"
-
-#include <stdint.h>
-
-#include <functional>
-#include <map>
-#include <ostream>
-#include <util/generic/string.h>
-#include <utility>
-#include <vector>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/flag.h"
-#include "y_absl/flags/internal/flag.h"
-#include "y_absl/flags/internal/path_util.h"
-#include "y_absl/flags/internal/private_handle_accessor.h"
-#include "y_absl/flags/internal/program_name.h"
-#include "y_absl/flags/internal/registry.h"
-#include "y_absl/flags/usage_config.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_split.h"
-#include "y_absl/strings/string_view.h"
-
-// Dummy global variables to prevent anyone else defining these.
-bool FLAGS_help = false;
-bool FLAGS_helpfull = false;
-bool FLAGS_helpshort = false;
-bool FLAGS_helppackage = false;
-bool FLAGS_version = false;
-bool FLAGS_only_check_args = false;
-bool FLAGS_helpon = false;
-bool FLAGS_helpmatch = false;
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-namespace {
-
-using PerFlagFilter = std::function<bool(const y_absl::CommandLineFlag&)>;
-
-// Maximum length size in a human readable format.
-constexpr size_t kHrfMaxLineLength = 80;
-
-// This class is used to emit an XML element with `tag` and `text`.
-// It adds opening and closing tags and escapes special characters in the text.
-// For example:
-// std::cout << XMLElement("title", "Milk & Cookies");
-// prints "<title>Milk &amp; Cookies</title>"
-class XMLElement {
- public:
-  XMLElement(y_absl::string_view tag, y_absl::string_view txt)
-      : tag_(tag), txt_(txt) {}
-
-  friend std::ostream& operator<<(std::ostream& out,
-                                  const XMLElement& xml_elem) {
-    out << "<" << xml_elem.tag_ << ">";
-
-    for (auto c : xml_elem.txt_) {
-      switch (c) {
-        case '"':
-          out << "&quot;";
-          break;
-        case '\'':
-          out << "&apos;";
-          break;
-        case '&':
-          out << "&amp;";
-          break;
-        case '<':
-          out << "&lt;";
-          break;
-        case '>':
-          out << "&gt;";
-          break;
-        default:
-          out << c;
-          break;
-      }
-    }
-
-    return out << "</" << xml_elem.tag_ << ">";
-  }
-
- private:
-  y_absl::string_view tag_;
-  y_absl::string_view txt_;
-};
-
-// --------------------------------------------------------------------
-// Helper class to pretty-print info about a flag.
-
-class FlagHelpPrettyPrinter {
- public:
-  // Pretty printer holds on to the std::ostream& reference to direct an output
-  // to that stream.
-  FlagHelpPrettyPrinter(size_t max_line_len, size_t min_line_len,
-                        size_t wrapped_line_indent, std::ostream& out)
-      : out_(out),
-        max_line_len_(max_line_len),
-        min_line_len_(min_line_len),
-        wrapped_line_indent_(wrapped_line_indent),
-        line_len_(0),
-        first_line_(true) {}
-
-  void Write(y_absl::string_view str, bool wrap_line = false) {
-    // Empty string - do nothing.
-    if (str.empty()) return;
-
-    std::vector<y_absl::string_view> tokens;
-    if (wrap_line) {
-      for (auto line : y_absl::StrSplit(str, y_absl::ByAnyChar("\n\r"))) {
-        if (!tokens.empty()) {
-          // Keep line separators in the input string.
-          tokens.push_back("\n");
-        }
-        for (auto token :
-             y_absl::StrSplit(line, y_absl::ByAnyChar(" \t"), y_absl::SkipEmpty())) {
-          tokens.push_back(token);
-        }
-      }
-    } else {
-      tokens.push_back(str);
-    }
-
-    for (auto token : tokens) {
-      bool new_line = (line_len_ == 0);
-
-      // Respect line separators in the input string.
-      if (token == "\n") {
-        EndLine();
-        continue;
-      }
-
-      // Write the token, ending the string first if necessary/possible.
-      if (!new_line &&
-          (line_len_ + static_cast<int>(token.size()) >= max_line_len_)) {
-        EndLine();
-        new_line = true;
-      }
-
-      if (new_line) {
-        StartLine();
-      } else {
-        out_ << ' ';
-        ++line_len_;
-      }
-
-      out_ << token;
-      line_len_ += token.size();
-    }
-  }
-
-  void StartLine() {
-    if (first_line_) {
-      line_len_ = min_line_len_;
-      first_line_ = false;
-    } else {
-      line_len_ = min_line_len_ + wrapped_line_indent_;
-    }
-    out_ << TString(line_len_, ' ');
-  }
-  void EndLine() {
-    out_ << '\n';
-    line_len_ = 0;
-  }
-
- private:
-  std::ostream& out_;
-  const size_t max_line_len_;
-  const size_t min_line_len_;
-  const size_t wrapped_line_indent_;
-  size_t line_len_;
-  bool first_line_;
-};
-
-void FlagHelpHumanReadable(const CommandLineFlag& flag, std::ostream& out) {
-  FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 4, 2, out);
-
-  // Flag name.
-  printer.Write(y_absl::StrCat("--", flag.Name()));
-
-  // Flag help.
-  printer.Write(y_absl::StrCat("(", flag.Help(), ");"), /*wrap_line=*/true);
-
-  // The listed default value will be the actual default from the flag
-  // definition in the originating source file, unless the value has
-  // subsequently been modified using SetCommandLineOption() with mode
-  // SET_FLAGS_DEFAULT.
-  TString dflt_val = flag.DefaultValue();
-  TString curr_val = flag.CurrentValue();
-  bool is_modified = curr_val != dflt_val;
-
-  if (flag.IsOfType<TString>()) {
-    dflt_val = y_absl::StrCat("\"", dflt_val, "\"");
-  }
-  printer.Write(y_absl::StrCat("default: ", dflt_val, ";"));
-
-  if (is_modified) {
-    if (flag.IsOfType<TString>()) {
-      curr_val = y_absl::StrCat("\"", curr_val, "\"");
-    }
-    printer.Write(y_absl::StrCat("currently: ", curr_val, ";"));
-  }
-
-  printer.EndLine();
-}
-
-// Shows help for every filename which matches any of the filters
-// If filters are empty, shows help for every file.
-// If a flag's help message has been stripped (e.g. by adding '#define
-// STRIP_FLAG_HELP 1' then this flag will not be displayed by '--help'
-// and its variants.
-void FlagsHelpImpl(std::ostream& out, PerFlagFilter filter_cb,
-                   HelpFormat format, y_absl::string_view program_usage_message) {
-  if (format == HelpFormat::kHumanReadable) {
-    out << flags_internal::ShortProgramInvocationName() << ": "
-        << program_usage_message << "\n\n";
-  } else {
-    // XML schema is not a part of our public API for now.
-    out << "<?xml version=\"1.0\"?>\n"
-        << "<!-- This output should be used with care. We do not report type "
-           "names for flags with user defined types -->\n"
-        << "<!-- Prefer flag only_check_args for validating flag inputs -->\n"
-        // The document.
-        << "<AllFlags>\n"
-        // The program name and usage.
-        << XMLElement("program", flags_internal::ShortProgramInvocationName())
-        << '\n'
-        << XMLElement("usage", program_usage_message) << '\n';
-  }
-
-  // Ordered map of package name to
-  //   map of file name to
-  //     vector of flags in the file.
-  // This map is used to output matching flags grouped by package and file
-  // name.
-  std::map<TString,
-           std::map<TString, std::vector<const y_absl::CommandLineFlag*>>>
-      matching_flags;
-
-  flags_internal::ForEachFlag([&](y_absl::CommandLineFlag& flag) {
-    // Ignore retired flags.
-    if (flag.IsRetired()) return;
-
-    // If the flag has been stripped, pretend that it doesn't exist.
-    if (flag.Help() == flags_internal::kStrippedFlagHelp) return;
-
-    // Make sure flag satisfies the filter
-    if (!filter_cb(flag)) return;
-
-    TString flag_filename = flag.Filename();
-
-    matching_flags[TString(flags_internal::Package(flag_filename))]
-                  [flag_filename]
-                      .push_back(&flag);
-  });
-
-  y_absl::string_view package_separator;  // controls blank lines between packages
-  y_absl::string_view file_separator;     // controls blank lines between files
-  for (auto& package : matching_flags) {
-    if (format == HelpFormat::kHumanReadable) {
-      out << package_separator;
-      package_separator = "\n\n";
-    }
-
-    file_separator = "";
-    for (auto& flags_in_file : package.second) {
-      if (format == HelpFormat::kHumanReadable) {
-        out << file_separator << "  Flags from " << flags_in_file.first
-            << ":\n";
-        file_separator = "\n";
-      }
-
-      std::sort(std::begin(flags_in_file.second),
-                std::end(flags_in_file.second),
-                [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
-                  return lhs->Name() < rhs->Name();
-                });
-
-      for (const auto* flag : flags_in_file.second) {
-        flags_internal::FlagHelp(out, *flag, format);
-      }
-    }
-  }
-
-  if (format == HelpFormat::kHumanReadable) {
-    FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 0, 0, out);
-
-    if (filter_cb && matching_flags.empty()) {
-      printer.Write("No flags matched.\n", true);
-    }
-    printer.EndLine();
-    printer.Write(
-        "Try --helpfull to get a list of all flags or --help=substring "
-        "shows help for flags which include specified substring in either "
-        "in the name, or description or path.\n",
-        true);
-  } else {
-    // The end of the document.
-    out << "</AllFlags>\n";
-  }
-}
-
-void FlagsHelpImpl(std::ostream& out,
-                   flags_internal::FlagKindFilter filename_filter_cb,
-                   HelpFormat format, y_absl::string_view program_usage_message) {
-  FlagsHelpImpl(
-      out,
-      [&](const y_absl::CommandLineFlag& flag) {
-        return filename_filter_cb && filename_filter_cb(flag.Filename());
-      },
-      format, program_usage_message);
-}
-
-}  // namespace
-
-// --------------------------------------------------------------------
-// Produces the help message describing specific flag.
-void FlagHelp(std::ostream& out, const CommandLineFlag& flag,
-              HelpFormat format) {
-  if (format == HelpFormat::kHumanReadable)
-    flags_internal::FlagHelpHumanReadable(flag, out);
-}
-
-// --------------------------------------------------------------------
-// Produces the help messages for all flags matching the filename filter.
-// If filter is empty produces help messages for all flags.
-void FlagsHelp(std::ostream& out, y_absl::string_view filter, HelpFormat format,
-               y_absl::string_view program_usage_message) {
-  flags_internal::FlagKindFilter filter_cb = [&](y_absl::string_view filename) {
-    return filter.empty() || filename.find(filter) != y_absl::string_view::npos;
-  };
-  flags_internal::FlagsHelpImpl(out, filter_cb, format, program_usage_message);
-}
-
-// --------------------------------------------------------------------
-// Checks all the 'usage' command line flags to see if any have been set.
-// If so, handles them appropriately.
-int HandleUsageFlags(std::ostream& out,
-                     y_absl::string_view program_usage_message) {
-  switch (GetFlagsHelpMode()) {
-    case HelpMode::kNone:
-      break;
-    case HelpMode::kImportant:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_help_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-      return 1;
-
-    case HelpMode::kShort:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_helpshort_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-      return 1;
-
-    case HelpMode::kFull:
-      flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(),
-                                program_usage_message);
-      return 1;
-
-    case HelpMode::kPackage:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_helppackage_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-
-      return 1;
-
-    case HelpMode::kMatch: {
-      TString substr = GetFlagsHelpMatchSubstr();
-      if (substr.empty()) {
-        // show all options
-        flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(),
-                                  program_usage_message);
-      } else {
-        auto filter_cb = [&substr](const y_absl::CommandLineFlag& flag) {
-          if (y_absl::StrContains(flag.Name(), substr)) return true;
-          if (y_absl::StrContains(flag.Filename(), substr)) return true;
-          if (y_absl::StrContains(flag.Help(), substr)) return true;
-
-          return false;
-        };
-        flags_internal::FlagsHelpImpl(
-            out, filter_cb, HelpFormat::kHumanReadable, program_usage_message);
-      }
-
-      return 1;
-    }
-    case HelpMode::kVersion:
-      if (flags_internal::GetUsageConfig().version_string)
-        out << flags_internal::GetUsageConfig().version_string();
-      // Unlike help, we may be asking for version in a script, so return 0
-      return 0;
-
-    case HelpMode::kOnlyCheckArgs:
-      return 0;
-  }
-
-  return -1;
-}
-
-// --------------------------------------------------------------------
-// Globals representing usage reporting flags
-
-namespace {
-
-Y_ABSL_CONST_INIT y_absl::Mutex help_attributes_guard(y_absl::kConstInit);
-Y_ABSL_CONST_INIT TString* match_substr
-    Y_ABSL_GUARDED_BY(help_attributes_guard) = nullptr;
-Y_ABSL_CONST_INIT HelpMode help_mode Y_ABSL_GUARDED_BY(help_attributes_guard) =
-    HelpMode::kNone;
-Y_ABSL_CONST_INIT HelpFormat help_format Y_ABSL_GUARDED_BY(help_attributes_guard) =
-    HelpFormat::kHumanReadable;
-
-}  // namespace
-
-TString GetFlagsHelpMatchSubstr() {
-  y_absl::MutexLock l(&help_attributes_guard);
-  if (match_substr == nullptr) return "";
-  return *match_substr;
-}
-
-void SetFlagsHelpMatchSubstr(y_absl::string_view substr) {
-  y_absl::MutexLock l(&help_attributes_guard);
-  if (match_substr == nullptr) match_substr = new TString;
-  match_substr->assign(substr.data(), substr.size());
-}
-
-HelpMode GetFlagsHelpMode() {
-  y_absl::MutexLock l(&help_attributes_guard);
-  return help_mode;
-}
-
-void SetFlagsHelpMode(HelpMode mode) {
-  y_absl::MutexLock l(&help_attributes_guard);
-  help_mode = mode;
-}
-
-HelpFormat GetFlagsHelpFormat() {
-  y_absl::MutexLock l(&help_attributes_guard);
-  return help_format;
-}
-
-void SetFlagsHelpFormat(HelpFormat format) {
-  y_absl::MutexLock l(&help_attributes_guard);
-  help_format = format;
-}
-
-// Deduces usage flags from the input argument in a form --name=value or
-// --name. argument is already split into name and value before we call this
-// function.
-bool DeduceUsageFlags(y_absl::string_view name, y_absl::string_view value) {
-  if (y_absl::ConsumePrefix(&name, "help")) {
-    if (name == "") {
-      if (value.empty()) {
-        SetFlagsHelpMode(HelpMode::kImportant);
-      } else {
-        SetFlagsHelpMode(HelpMode::kMatch);
-        SetFlagsHelpMatchSubstr(value);
-      }
-      return true;
-    }
-
-    if (name == "match") {
-      SetFlagsHelpMode(HelpMode::kMatch);
-      SetFlagsHelpMatchSubstr(value);
-      return true;
-    }
-
-    if (name == "on") {
-      SetFlagsHelpMode(HelpMode::kMatch);
-      SetFlagsHelpMatchSubstr(y_absl::StrCat("/", value, "."));
-      return true;
-    }
-
-    if (name == "full") {
-      SetFlagsHelpMode(HelpMode::kFull);
-      return true;
-    }
-
-    if (name == "short") {
-      SetFlagsHelpMode(HelpMode::kShort);
-      return true;
-    }
-
-    if (name == "package") {
-      SetFlagsHelpMode(HelpMode::kPackage);
-      return true;
-    }
-
-    return false;
-  }
-
-  if (name == "version") {
-    SetFlagsHelpMode(HelpMode::kVersion);
-    return true;
-  }
-
-  if (name == "only_check_args") {
-    SetFlagsHelpMode(HelpMode::kOnlyCheckArgs);
-    return true;
-  }
-
-  return false;
-}
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.h
deleted file mode 100644
index cc7adf27cb..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage.h
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-//  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 Y_ABSL_FLAGS_INTERNAL_USAGE_H_
-#define Y_ABSL_FLAGS_INTERNAL_USAGE_H_
-
-#include <iosfwd>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/declare.h"
-#include "y_absl/strings/string_view.h"
-
-// --------------------------------------------------------------------
-// Usage reporting interfaces
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// The format to report the help messages in.
-enum class HelpFormat {
-  kHumanReadable,
-};
-
-// Streams the help message describing `flag` to `out`.
-// The default value for `flag` is included in the output.
-void FlagHelp(std::ostream& out, const CommandLineFlag& flag,
-              HelpFormat format = HelpFormat::kHumanReadable);
-
-// Produces the help messages for all flags matching the filter. A flag matches
-// the filter if it is defined in a file with a filename which includes
-// filter string as a substring. You can use '/' and '.' to restrict the
-// matching to a specific file names. For example:
-//   FlagsHelp(out, "/path/to/file.");
-// restricts help to only flags which resides in files named like:
-//  .../path/to/file.<ext>
-// for any extension 'ext'. If the filter is empty this function produces help
-// messages for all flags.
-void FlagsHelp(std::ostream& out, y_absl::string_view filter,
-               HelpFormat format, y_absl::string_view program_usage_message);
-
-// --------------------------------------------------------------------
-
-// If any of the 'usage' related command line flags (listed on the bottom of
-// this file) has been set this routine produces corresponding help message in
-// the specified output stream and returns:
-//  0 - if "version" or "only_check_flags" flags were set and handled.
-//  1 - if some other 'usage' related flag was set and handled.
-// -1 - if no usage flags were set on a commmand line.
-// Non negative return values are expected to be used as an exit code for a
-// binary.
-int HandleUsageFlags(std::ostream& out,
-                     y_absl::string_view program_usage_message);
-
-// --------------------------------------------------------------------
-// Globals representing usage reporting flags
-
-enum class HelpMode {
-  kNone,
-  kImportant,
-  kShort,
-  kFull,
-  kPackage,
-  kMatch,
-  kVersion,
-  kOnlyCheckArgs
-};
-
-// Returns substring to filter help output (--help=substr argument)
-TString GetFlagsHelpMatchSubstr();
-// Returns the requested help mode.
-HelpMode GetFlagsHelpMode();
-// Returns the requested help format.
-HelpFormat GetFlagsHelpFormat();
-
-// These are corresponding setters to the attributes above.
-void SetFlagsHelpMatchSubstr(y_absl::string_view);
-void SetFlagsHelpMode(HelpMode);
-void SetFlagsHelpFormat(HelpFormat);
-
-// Deduces usage flags from the input argument in a form --name=value or
-// --name. argument is already split into name and value before we call this
-// function.
-bool DeduceUsageFlags(y_absl::string_view name, y_absl::string_view value);
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_INTERNAL_USAGE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.cc
deleted file mode 100644
index 51abb779fb..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.cc
+++ /dev/null
@@ -1,241 +0,0 @@
-//
-//  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.
-
-#include "y_absl/flags/marshalling.h"
-
-#include <stddef.h>
-
-#include <cmath>
-#include <limits>
-#include <util/generic/string.h>
-#include <type_traits>
-#include <vector>
-
-#include "y_absl/base/config.h"
-#include "y_absl/base/log_severity.h"
-#include "y_absl/base/macros.h"
-#include "y_absl/strings/ascii.h"
-#include "y_absl/strings/match.h"
-#include "y_absl/strings/numbers.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-#include "y_absl/strings/str_split.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// --------------------------------------------------------------------
-// AbslParseFlag specializations for boolean type.
-
-bool AbslParseFlag(y_absl::string_view text, bool* dst, TString*) {
-  const char* kTrue[] = {"1", "t", "true", "y", "yes"};
-  const char* kFalse[] = {"0", "f", "false", "n", "no"};
-  static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
-
-  text = y_absl::StripAsciiWhitespace(text);
-
-  for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(kTrue); ++i) {
-    if (y_absl::EqualsIgnoreCase(text, kTrue[i])) {
-      *dst = true;
-      return true;
-    } else if (y_absl::EqualsIgnoreCase(text, kFalse[i])) {
-      *dst = false;
-      return true;
-    }
-  }
-  return false;  // didn't match a legal input
-}
-
-// --------------------------------------------------------------------
-// AbslParseFlag for integral types.
-
-// Return the base to use for parsing text as an integer.  Leading 0x
-// puts us in base 16.  But leading 0 does not put us in base 8. It
-// caused too many bugs when we had that behavior.
-static int NumericBase(y_absl::string_view text) {
-  const bool hex = (text.size() >= 2 && text[0] == '0' &&
-                    (text[1] == 'x' || text[1] == 'X'));
-  return hex ? 16 : 10;
-}
-
-template <typename IntType>
-inline bool ParseFlagImpl(y_absl::string_view text, IntType& dst) {
-  text = y_absl::StripAsciiWhitespace(text);
-
-  return y_absl::numbers_internal::safe_strtoi_base(text, &dst,
-                                                  NumericBase(text));
-}
-
-bool AbslParseFlag(y_absl::string_view text, short* dst, TString*) {
-  int val;
-  if (!ParseFlagImpl(text, val)) return false;
-  if (static_cast<short>(val) != val)  // worked, but number out of range
-    return false;
-  *dst = static_cast<short>(val);
-  return true;
-}
-
-bool AbslParseFlag(y_absl::string_view text, unsigned short* dst, TString*) {
-  unsigned int val;
-  if (!ParseFlagImpl(text, val)) return false;
-  if (static_cast<unsigned short>(val) !=
-      val)  // worked, but number out of range
-    return false;
-  *dst = static_cast<unsigned short>(val);
-  return true;
-}
-
-bool AbslParseFlag(y_absl::string_view text, int* dst, TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, unsigned int* dst, TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, long* dst, TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, unsigned long* dst, TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, long long* dst, TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, unsigned long long* dst,
-                   TString*) {
-  return ParseFlagImpl(text, *dst);
-}
-
-// --------------------------------------------------------------------
-// AbslParseFlag for floating point types.
-
-bool AbslParseFlag(y_absl::string_view text, float* dst, TString*) {
-  return y_absl::SimpleAtof(text, dst);
-}
-
-bool AbslParseFlag(y_absl::string_view text, double* dst, TString*) {
-  return y_absl::SimpleAtod(text, dst);
-}
-
-// --------------------------------------------------------------------
-// AbslParseFlag for strings.
-
-bool AbslParseFlag(y_absl::string_view text, TString* dst, TString*) {
-  dst->assign(text.data(), text.size());
-  return true;
-}
-
-// --------------------------------------------------------------------
-// AbslParseFlag for vector of strings.
-
-bool AbslParseFlag(y_absl::string_view text, std::vector<TString>* dst,
-                   TString*) {
-  // An empty flag value corresponds to an empty vector, not a vector
-  // with a single, empty TString.
-  if (text.empty()) {
-    dst->clear();
-    return true;
-  }
-  *dst = y_absl::StrSplit(text, ',', y_absl::AllowEmpty());
-  return true;
-}
-
-// --------------------------------------------------------------------
-// AbslUnparseFlag specializations for various builtin flag types.
-
-TString Unparse(bool v) { return v ? "true" : "false"; }
-TString Unparse(short v) { return y_absl::StrCat(v); }
-TString Unparse(unsigned short v) { return y_absl::StrCat(v); }
-TString Unparse(int v) { return y_absl::StrCat(v); }
-TString Unparse(unsigned int v) { return y_absl::StrCat(v); }
-TString Unparse(long v) { return y_absl::StrCat(v); }
-TString Unparse(unsigned long v) { return y_absl::StrCat(v); }
-TString Unparse(long long v) { return y_absl::StrCat(v); }
-TString Unparse(unsigned long long v) { return y_absl::StrCat(v); }
-template <typename T>
-TString UnparseFloatingPointVal(T v) {
-  // digits10 is guaranteed to roundtrip correctly in string -> value -> string
-  // conversions, but may not be enough to represent all the values correctly.
-  TString digit10_str =
-      y_absl::StrFormat("%.*g", std::numeric_limits<T>::digits10, v);
-  if (std::isnan(v) || std::isinf(v)) return digit10_str;
-
-  T roundtrip_val = 0;
-  TString err;
-  if (y_absl::ParseFlag(digit10_str, &roundtrip_val, &err) &&
-      roundtrip_val == v) {
-    return digit10_str;
-  }
-
-  // max_digits10 is the number of base-10 digits that are necessary to uniquely
-  // represent all distinct values.
-  return y_absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10, v);
-}
-TString Unparse(float v) { return UnparseFloatingPointVal(v); }
-TString Unparse(double v) { return UnparseFloatingPointVal(v); }
-TString AbslUnparseFlag(y_absl::string_view v) { return TString(v); }
-TString AbslUnparseFlag(const std::vector<TString>& v) {
-  return y_absl::StrJoin(v, ",");
-}
-
-}  // namespace flags_internal
-
-bool AbslParseFlag(y_absl::string_view text, y_absl::LogSeverity* dst,
-                   TString* err) {
-  text = y_absl::StripAsciiWhitespace(text);
-  if (text.empty()) {
-    *err = "no value provided";
-    return false;
-  }
-  if (text.front() == 'k' || text.front() == 'K') text.remove_prefix(1);
-  if (y_absl::EqualsIgnoreCase(text, "info")) {
-    *dst = y_absl::LogSeverity::kInfo;
-    return true;
-  }
-  if (y_absl::EqualsIgnoreCase(text, "warning")) {
-    *dst = y_absl::LogSeverity::kWarning;
-    return true;
-  }
-  if (y_absl::EqualsIgnoreCase(text, "error")) {
-    *dst = y_absl::LogSeverity::kError;
-    return true;
-  }
-  if (y_absl::EqualsIgnoreCase(text, "fatal")) {
-    *dst = y_absl::LogSeverity::kFatal;
-    return true;
-  }
-  std::underlying_type<y_absl::LogSeverity>::type numeric_value;
-  if (y_absl::ParseFlag(text, &numeric_value, err)) {
-    *dst = static_cast<y_absl::LogSeverity>(numeric_value);
-    return true;
-  }
-  *err = "only integers and y_absl::LogSeverity enumerators are accepted";
-  return false;
-}
-
-TString AbslUnparseFlag(y_absl::LogSeverity v) {
-  if (v == y_absl::NormalizeLogSeverity(v)) return y_absl::LogSeverityName(v);
-  return y_absl::UnparseFlag(static_cast<int>(v));
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.h
deleted file mode 100644
index be84b1ea72..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling.h
+++ /dev/null
@@ -1,356 +0,0 @@
-//
-//  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.
-//
-// -----------------------------------------------------------------------------
-// File: marshalling.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the API for extending Abseil flag support to
-// custom types, and defines the set of overloads for fundamental types.
-//
-// Out of the box, the Abseil flags library supports the following types:
-//
-// * `bool`
-// * `int16_t`
-// * `uint16_t`
-// * `int32_t`
-// * `uint32_t`
-// * `int64_t`
-// * `uint64_t`
-// * `float`
-// * `double`
-// * `TString`
-// * `std::vector<TString>`
-// * `std::optional<T>`
-// * `y_absl::LogSeverity` (provided natively for layering reasons)
-//
-// Note that support for integral types is implemented using overloads for
-// variable-width fundamental types (`short`, `int`, `long`, etc.). However,
-// you should prefer the fixed-width integral types (`int32_t`, `uint64_t`,
-// etc.) we've noted above within flag definitions.
-//
-// In addition, several Abseil libraries provide their own custom support for
-// Abseil flags. Documentation for these formats is provided in the type's
-// `AbslParseFlag()` definition.
-//
-// The Abseil time library provides the following support for civil time values:
-//
-// * `y_absl::CivilSecond`
-// * `y_absl::CivilMinute`
-// * `y_absl::CivilHour`
-// * `y_absl::CivilDay`
-// * `y_absl::CivilMonth`
-// * `y_absl::CivilYear`
-//
-// and also provides support for the following absolute time values:
-//
-// * `y_absl::Duration`
-// * `y_absl::Time`
-//
-// Additional support for Abseil types will be noted here as it is added.
-//
-// You can also provide your own custom flags by adding overloads for
-// `AbslParseFlag()` and `AbslUnparseFlag()` to your type definitions. (See
-// below.)
-//
-// -----------------------------------------------------------------------------
-// Optional Flags
-// -----------------------------------------------------------------------------
-//
-// The Abseil flags library supports flags of type `std::optional<T>` where
-// `T` is a type of one of the supported flags. We refer to this flag type as
-// an "optional flag." An optional flag is either "valueless", holding no value
-// of type `T` (indicating that the flag has not been set) or a value of type
-// `T`. The valueless state in C++ code is represented by a value of
-// `std::nullopt` for the optional flag.
-//
-// Using `std::nullopt` as an optional flag's default value allows you to check
-// whether such a flag was ever specified on the command line:
-//
-//   if (y_absl::GetFlag(FLAGS_foo).has_value()) {
-//     // flag was set on command line
-//   } else {
-//     // flag was not passed on command line
-//   }
-//
-// Using an optional flag in this manner avoids common workarounds for
-// indicating such an unset flag (such as using sentinal values to indicate this
-// state).
-//
-// An optional flag also allows a developer to pass a flag in an "unset"
-// valueless state on the command line, allowing the flag to later be set in
-// binary logic. An optional flag's valueless state is indicated by the special
-// notation of passing the value as an empty string through the syntax `--flag=`
-// or `--flag ""`.
-//
-//   $ binary_with_optional --flag_in_unset_state=
-//   $ binary_with_optional --flag_in_unset_state ""
-//
-// Note: as a result of the above syntax requirements, an optional flag cannot
-// be set to a `T` of any value which unparses to the empty string.
-//
-// -----------------------------------------------------------------------------
-// Adding Type Support for Abseil Flags
-// -----------------------------------------------------------------------------
-//
-// To add support for your user-defined type, add overloads of `AbslParseFlag()`
-// and `AbslUnparseFlag()` as free (non-member) functions to your type. If `T`
-// is a class type, these functions can be friend function definitions. These
-// overloads must be added to the same namespace where the type is defined, so
-// that they can be discovered by Argument-Dependent Lookup (ADL).
-//
-// Example:
-//
-//   namespace foo {
-//
-//   enum OutputMode { kPlainText, kHtml };
-//
-//   // AbslParseFlag converts from a string to OutputMode.
-//   // Must be in same namespace as OutputMode.
-//
-//   // Parses an OutputMode from the command line flag value `text`. Returns
-//   // `true` and sets `*mode` on success; returns `false` and sets `*error`
-//   // on failure.
-//   bool AbslParseFlag(y_absl::string_view text,
-//                      OutputMode* mode,
-//                      TString* error) {
-//     if (text == "plaintext") {
-//       *mode = kPlainText;
-//       return true;
-//     }
-//     if (text == "html") {
-//       *mode = kHtml;
-//      return true;
-//     }
-//     *error = "unknown value for enumeration";
-//     return false;
-//  }
-//
-//  // AbslUnparseFlag converts from an OutputMode to a string.
-//  // Must be in same namespace as OutputMode.
-//
-//  // Returns a textual flag value corresponding to the OutputMode `mode`.
-//  TString AbslUnparseFlag(OutputMode mode) {
-//    switch (mode) {
-//      case kPlainText: return "plaintext";
-//      case kHtml: return "html";
-//    }
-//    return y_absl::StrCat(mode);
-//  }
-//
-// Notice that neither `AbslParseFlag()` nor `AbslUnparseFlag()` are class
-// members, but free functions. `AbslParseFlag/AbslUnparseFlag()` overloads
-// for a type should only be declared in the same file and namespace as said
-// type. The proper `AbslParseFlag/AbslUnparseFlag()` implementations for a
-// given type will be discovered via Argument-Dependent Lookup (ADL).
-//
-// `AbslParseFlag()` may need, in turn, to parse simpler constituent types
-// using `y_absl::ParseFlag()`. For example, a custom struct `MyFlagType`
-// consisting of a `std::pair<int, TString>` would add an `AbslParseFlag()`
-// overload for its `MyFlagType` like so:
-//
-// Example:
-//
-//   namespace my_flag_type {
-//
-//   struct MyFlagType {
-//     std::pair<int, TString> my_flag_data;
-//   };
-//
-//   bool AbslParseFlag(y_absl::string_view text, MyFlagType* flag,
-//                      TString* err);
-//
-//   TString AbslUnparseFlag(const MyFlagType&);
-//
-//   // Within the implementation, `AbslParseFlag()` will, in turn invoke
-//   // `y_absl::ParseFlag()` on its constituent `int` and `TString` types
-//   // (which have built-in Abseil flag support).
-//
-//   bool AbslParseFlag(y_absl::string_view text, MyFlagType* flag,
-//                      TString* err) {
-//     std::pair<y_absl::string_view, y_absl::string_view> tokens =
-//         y_absl::StrSplit(text, ',');
-//     if (!y_absl::ParseFlag(tokens.first, &flag->my_flag_data.first, err))
-//         return false;
-//     if (!y_absl::ParseFlag(tokens.second, &flag->my_flag_data.second, err))
-//         return false;
-//     return true;
-//   }
-//
-//   // Similarly, for unparsing, we can simply invoke `y_absl::UnparseFlag()` on
-//   // the constituent types.
-//   TString AbslUnparseFlag(const MyFlagType& flag) {
-//     return y_absl::StrCat(y_absl::UnparseFlag(flag.my_flag_data.first),
-//                         ",",
-//                         y_absl::UnparseFlag(flag.my_flag_data.second));
-//   }
-#ifndef Y_ABSL_FLAGS_MARSHALLING_H_
-#define Y_ABSL_FLAGS_MARSHALLING_H_
-
-#include "y_absl/base/config.h"
-
-#if defined(Y_ABSL_HAVE_STD_OPTIONAL) && !defined(Y_ABSL_USES_STD_OPTIONAL)
-#include <optional>
-#endif
-#include <util/generic/string.h>
-#include <vector>
-
-#include "y_absl/strings/string_view.h"
-#include "y_absl/types/optional.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-// Forward declaration to be used inside composable flag parse/unparse
-// implementations
-template <typename T>
-inline bool ParseFlag(y_absl::string_view input, T* dst, TString* error);
-template <typename T>
-inline TString UnparseFlag(const T& v);
-
-namespace flags_internal {
-
-// Overloads of `AbslParseFlag()` and `AbslUnparseFlag()` for fundamental types.
-bool AbslParseFlag(y_absl::string_view, bool*, TString*);
-bool AbslParseFlag(y_absl::string_view, short*, TString*);           // NOLINT
-bool AbslParseFlag(y_absl::string_view, unsigned short*, TString*);  // NOLINT
-bool AbslParseFlag(y_absl::string_view, int*, TString*);             // NOLINT
-bool AbslParseFlag(y_absl::string_view, unsigned int*, TString*);    // NOLINT
-bool AbslParseFlag(y_absl::string_view, long*, TString*);            // NOLINT
-bool AbslParseFlag(y_absl::string_view, unsigned long*, TString*);   // NOLINT
-bool AbslParseFlag(y_absl::string_view, long long*, TString*);       // NOLINT
-bool AbslParseFlag(y_absl::string_view, unsigned long long*,             // NOLINT
-                   TString*);
-bool AbslParseFlag(y_absl::string_view, float*, TString*);
-bool AbslParseFlag(y_absl::string_view, double*, TString*);
-bool AbslParseFlag(y_absl::string_view, TString*, TString*);
-bool AbslParseFlag(y_absl::string_view, std::vector<TString>*, TString*);
-
-template <typename T>
-bool AbslParseFlag(y_absl::string_view text, y_absl::optional<T>* f,
-                   TString* err) {
-  if (text.empty()) {
-    *f = y_absl::nullopt;
-    return true;
-  }
-  T value;
-  if (!y_absl::ParseFlag(text, &value, err)) return false;
-
-  *f = std::move(value);
-  return true;
-}
-
-#if defined(Y_ABSL_HAVE_STD_OPTIONAL) && !defined(Y_ABSL_USES_STD_OPTIONAL)
-template <typename T>
-bool AbslParseFlag(y_absl::string_view text, std::optional<T>* f,
-                   TString* err) {
-  if (text.empty()) {
-    *f = std::nullopt;
-    return true;
-  }
-  T value;
-  if (!y_absl::ParseFlag(text, &value, err)) return false;
-
-  *f = std::move(value);
-  return true;
-}
-#endif
-
-template <typename T>
-bool InvokeParseFlag(y_absl::string_view input, T* dst, TString* err) {
-  // Comment on next line provides a good compiler error message if T
-  // does not have AbslParseFlag(y_absl::string_view, T*, TString*).
-  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
-}
-
-// Strings and std:: containers do not have the same overload resolution
-// considerations as fundamental types. Naming these 'AbslUnparseFlag' means we
-// can avoid the need for additional specializations of Unparse (below).
-TString AbslUnparseFlag(y_absl::string_view v);
-TString AbslUnparseFlag(const std::vector<TString>&);
-
-template <typename T>
-TString AbslUnparseFlag(const y_absl::optional<T>& f) {
-  return f.has_value() ? y_absl::UnparseFlag(*f) : "";
-}
-
-#if defined(Y_ABSL_HAVE_STD_OPTIONAL) && !defined(Y_ABSL_USES_STD_OPTIONAL)
-template <typename T>
-TString AbslUnparseFlag(const std::optional<T>& f) {
-  return f.has_value() ? y_absl::UnparseFlag(*f) : "";
-}
-#endif
-
-template <typename T>
-TString Unparse(const T& v) {
-  // Comment on next line provides a good compiler error message if T does not
-  // have UnparseFlag.
-  return AbslUnparseFlag(v);  // Is T missing AbslUnparseFlag?
-}
-
-// Overloads for builtin types.
-TString Unparse(bool v);
-TString Unparse(short v);               // NOLINT
-TString Unparse(unsigned short v);      // NOLINT
-TString Unparse(int v);                 // NOLINT
-TString Unparse(unsigned int v);        // NOLINT
-TString Unparse(long v);                // NOLINT
-TString Unparse(unsigned long v);       // NOLINT
-TString Unparse(long long v);           // NOLINT
-TString Unparse(unsigned long long v);  // NOLINT
-TString Unparse(float v);
-TString Unparse(double v);
-
-}  // namespace flags_internal
-
-// ParseFlag()
-//
-// Parses a string value into a flag value of type `T`. Do not add overloads of
-// this function for your type directly; instead, add an `AbslParseFlag()`
-// free function as documented above.
-//
-// Some implementations of `AbslParseFlag()` for types which consist of other,
-// constituent types which already have Abseil flag support, may need to call
-// `y_absl::ParseFlag()` on those consituent string values. (See above.)
-template <typename T>
-inline bool ParseFlag(y_absl::string_view input, T* dst, TString* error) {
-  return flags_internal::InvokeParseFlag(input, dst, error);
-}
-
-// UnparseFlag()
-//
-// Unparses a flag value of type `T` into a string value. Do not add overloads
-// of this function for your type directly; instead, add an `AbslUnparseFlag()`
-// free function as documented above.
-//
-// Some implementations of `AbslUnparseFlag()` for types which consist of other,
-// constituent types which already have Abseil flag support, may want to call
-// `y_absl::UnparseFlag()` on those constituent types. (See above.)
-template <typename T>
-inline TString UnparseFlag(const T& v) {
-  return flags_internal::Unparse(v);
-}
-
-// Overloads for `y_absl::LogSeverity` can't (easily) appear alongside that type's
-// definition because it is layered below flags.  See proper documentation in
-// base/log_severity.h.
-enum class LogSeverity : int;
-bool AbslParseFlag(y_absl::string_view, y_absl::LogSeverity*, TString*);
-TString AbslUnparseFlag(y_absl::LogSeverity);
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_MARSHALLING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.cc
deleted file mode 100644
index 07ad9f5779..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.cc
+++ /dev/null
@@ -1,823 +0,0 @@
-//
-// 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.
-
-#include "y_absl/flags/parse.h"
-
-#include <stdlib.h>
-
-#include <algorithm>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <util/generic/string.h>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/const_init.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/config.h"
-#include "y_absl/flags/flag.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-#include "y_absl/flags/internal/flag.h"
-#include "y_absl/flags/internal/parse.h"
-#include "y_absl/flags/internal/private_handle_accessor.h"
-#include "y_absl/flags/internal/program_name.h"
-#include "y_absl/flags/internal/usage.h"
-#include "y_absl/flags/reflection.h"
-#include "y_absl/flags/usage.h"
-#include "y_absl/flags/usage_config.h"
-#include "y_absl/strings/ascii.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/strings/strip.h"
-#include "y_absl/synchronization/mutex.h"
-
-// --------------------------------------------------------------------
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-namespace {
-
-Y_ABSL_CONST_INIT y_absl::Mutex processing_checks_guard(y_absl::kConstInit);
-
-Y_ABSL_CONST_INIT bool flagfile_needs_processing
-    Y_ABSL_GUARDED_BY(processing_checks_guard) = false;
-Y_ABSL_CONST_INIT bool fromenv_needs_processing
-    Y_ABSL_GUARDED_BY(processing_checks_guard) = false;
-Y_ABSL_CONST_INIT bool tryfromenv_needs_processing
-    Y_ABSL_GUARDED_BY(processing_checks_guard) = false;
-
-Y_ABSL_CONST_INIT y_absl::Mutex specified_flags_guard(y_absl::kConstInit);
-Y_ABSL_CONST_INIT std::vector<const CommandLineFlag*>* specified_flags
-    Y_ABSL_GUARDED_BY(specified_flags_guard) = nullptr;
-
-struct SpecifiedFlagsCompare {
-  bool operator()(const CommandLineFlag* a, const CommandLineFlag* b) const {
-    return a->Name() < b->Name();
-  }
-  bool operator()(const CommandLineFlag* a, y_absl::string_view b) const {
-    return a->Name() < b;
-  }
-  bool operator()(y_absl::string_view a, const CommandLineFlag* b) const {
-    return a < b->Name();
-  }
-};
-
-}  // namespace
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-Y_ABSL_FLAG(std::vector<TString>, flagfile, {},
-          "comma-separated list of files to load flags from")
-    .OnUpdate([]() {
-      if (y_absl::GetFlag(FLAGS_flagfile).empty()) return;
-
-      y_absl::MutexLock l(&y_absl::flags_internal::processing_checks_guard);
-
-      // Setting this flag twice before it is handled most likely an internal
-      // error and should be reviewed by developers.
-      if (y_absl::flags_internal::flagfile_needs_processing) {
-        Y_ABSL_INTERNAL_LOG(WARNING, "flagfile set twice before it is handled");
-      }
-
-      y_absl::flags_internal::flagfile_needs_processing = true;
-    });
-Y_ABSL_FLAG(std::vector<TString>, fromenv, {},
-          "comma-separated list of flags to set from the environment"
-          " [use 'export FLAGS_flag1=value']")
-    .OnUpdate([]() {
-      if (y_absl::GetFlag(FLAGS_fromenv).empty()) return;
-
-      y_absl::MutexLock l(&y_absl::flags_internal::processing_checks_guard);
-
-      // Setting this flag twice before it is handled most likely an internal
-      // error and should be reviewed by developers.
-      if (y_absl::flags_internal::fromenv_needs_processing) {
-        Y_ABSL_INTERNAL_LOG(WARNING, "fromenv set twice before it is handled.");
-      }
-
-      y_absl::flags_internal::fromenv_needs_processing = true;
-    });
-Y_ABSL_FLAG(std::vector<TString>, tryfromenv, {},
-          "comma-separated list of flags to try to set from the environment if "
-          "present")
-    .OnUpdate([]() {
-      if (y_absl::GetFlag(FLAGS_tryfromenv).empty()) return;
-
-      y_absl::MutexLock l(&y_absl::flags_internal::processing_checks_guard);
-
-      // Setting this flag twice before it is handled most likely an internal
-      // error and should be reviewed by developers.
-      if (y_absl::flags_internal::tryfromenv_needs_processing) {
-        Y_ABSL_INTERNAL_LOG(WARNING,
-                          "tryfromenv set twice before it is handled.");
-      }
-
-      y_absl::flags_internal::tryfromenv_needs_processing = true;
-    });
-
-Y_ABSL_FLAG(std::vector<TString>, undefok, {},
-          "comma-separated list of flag names that it is okay to specify "
-          "on the command line even if the program does not define a flag "
-          "with that name");
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-namespace {
-
-class ArgsList {
- public:
-  ArgsList() : next_arg_(0) {}
-  ArgsList(int argc, char* argv[]) : args_(argv, argv + argc), next_arg_(0) {}
-  explicit ArgsList(const std::vector<TString>& args)
-      : args_(args), next_arg_(0) {}
-
-  // Returns success status: true if parsing successful, false otherwise.
-  bool ReadFromFlagfile(const TString& flag_file_name);
-
-  int Size() const { return args_.size() - next_arg_; }
-  int FrontIndex() const { return next_arg_; }
-  y_absl::string_view Front() const { return args_[next_arg_]; }
-  void PopFront() { next_arg_++; }
-
- private:
-  std::vector<TString> args_;
-  int next_arg_;
-};
-
-bool ArgsList::ReadFromFlagfile(const TString& flag_file_name) {
-  std::ifstream flag_file(flag_file_name);
-
-  if (!flag_file) {
-    flags_internal::ReportUsageError(
-        y_absl::StrCat("Can't open flagfile ", flag_file_name), true);
-
-    return false;
-  }
-
-  // This argument represents fake argv[0], which should be present in all arg
-  // lists.
-  args_.push_back("");
-
-  std::string line;
-  bool success = true;
-
-  while (std::getline(flag_file, line)) {
-    y_absl::string_view stripped = y_absl::StripLeadingAsciiWhitespace(line);
-
-    if (stripped.empty() || stripped[0] == '#') {
-      // Comment or empty line; just ignore.
-      continue;
-    }
-
-    if (stripped[0] == '-') {
-      if (stripped == "--") {
-        flags_internal::ReportUsageError(
-            "Flagfile can't contain position arguments or --", true);
-
-        success = false;
-        break;
-      }
-
-      args_.push_back(TString(stripped));
-      continue;
-    }
-
-    flags_internal::ReportUsageError(
-        y_absl::StrCat("Unexpected line in the flagfile ", flag_file_name, ": ",
-                     line),
-        true);
-
-    success = false;
-  }
-
-  return success;
-}
-
-// --------------------------------------------------------------------
-
-// Reads the environment variable with name `name` and stores results in
-// `value`. If variable is not present in environment returns false, otherwise
-// returns true.
-bool GetEnvVar(const char* var_name, TString& var_value) {
-#ifdef _WIN32
-  char buf[1024];
-  auto get_res = GetEnvironmentVariableA(var_name, buf, sizeof(buf));
-  if (get_res >= sizeof(buf)) {
-    return false;
-  }
-
-  if (get_res == 0) {
-    return false;
-  }
-
-  var_value = TString(buf, get_res);
-#else
-  const char* val = ::getenv(var_name);
-  if (val == nullptr) {
-    return false;
-  }
-
-  var_value = val;
-#endif
-
-  return true;
-}
-
-// --------------------------------------------------------------------
-
-// Returns:
-//  Flag name or empty if arg= --
-//  Flag value after = in --flag=value (empty if --foo)
-//  "Is empty value" status. True if arg= --foo=, false otherwise. This is
-//  required to separate --foo from --foo=.
-// For example:
-//      arg           return values
-//   "--foo=bar" -> {"foo", "bar", false}.
-//   "--foo"     -> {"foo", "", false}.
-//   "--foo="    -> {"foo", "", true}.
-std::tuple<y_absl::string_view, y_absl::string_view, bool> SplitNameAndValue(
-    y_absl::string_view arg) {
-  // Allow -foo and --foo
-  y_absl::ConsumePrefix(&arg, "-");
-
-  if (arg.empty()) {
-    return std::make_tuple("", "", false);
-  }
-
-  auto equal_sign_pos = arg.find("=");
-
-  y_absl::string_view flag_name = arg.substr(0, equal_sign_pos);
-
-  y_absl::string_view value;
-  bool is_empty_value = false;
-
-  if (equal_sign_pos != y_absl::string_view::npos) {
-    value = arg.substr(equal_sign_pos + 1);
-    is_empty_value = value.empty();
-  }
-
-  return std::make_tuple(flag_name, value, is_empty_value);
-}
-
-// --------------------------------------------------------------------
-
-// Returns:
-//  found flag or nullptr
-//  is negative in case of --nofoo
-std::tuple<CommandLineFlag*, bool> LocateFlag(y_absl::string_view flag_name) {
-  CommandLineFlag* flag = y_absl::FindCommandLineFlag(flag_name);
-  bool is_negative = false;
-
-  if (!flag && y_absl::ConsumePrefix(&flag_name, "no")) {
-    flag = y_absl::FindCommandLineFlag(flag_name);
-    is_negative = true;
-  }
-
-  return std::make_tuple(flag, is_negative);
-}
-
-// --------------------------------------------------------------------
-
-// Verify that default values of typed flags must be convertible to string and
-// back.
-void CheckDefaultValuesParsingRoundtrip() {
-#ifndef NDEBUG
-  flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
-    if (flag.IsRetired()) return;
-
-#define Y_ABSL_FLAGS_INTERNAL_IGNORE_TYPE(T, _) \
-  if (flag.IsOfType<T>()) return;
-
-    Y_ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(Y_ABSL_FLAGS_INTERNAL_IGNORE_TYPE)
-#undef Y_ABSL_FLAGS_INTERNAL_IGNORE_TYPE
-
-    flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
-        flag);
-  });
-#endif
-}
-
-// --------------------------------------------------------------------
-
-// Returns success status, which is true if we successfully read all flag files,
-// in which case new ArgLists are appended to the input_args in a reverse order
-// of file names in the input flagfiles list. This order ensures that flags from
-// the first flagfile in the input list are processed before the second flagfile
-// etc.
-bool ReadFlagfiles(const std::vector<TString>& flagfiles,
-                   std::vector<ArgsList>& input_args) {
-  bool success = true;
-  for (auto it = flagfiles.rbegin(); it != flagfiles.rend(); ++it) {
-    ArgsList al;
-
-    if (al.ReadFromFlagfile(*it)) {
-      input_args.push_back(al);
-    } else {
-      success = false;
-    }
-  }
-
-  return success;
-}
-
-// Returns success status, which is true if were able to locate all environment
-// variables correctly or if fail_on_absent_in_env is false. The environment
-// variable names are expected to be of the form `FLAGS_<flag_name>`, where
-// `flag_name` is a string from the input flag_names list. If successful we
-// append a single ArgList at the end of the input_args.
-bool ReadFlagsFromEnv(const std::vector<TString>& flag_names,
-                      std::vector<ArgsList>& input_args,
-                      bool fail_on_absent_in_env) {
-  bool success = true;
-  std::vector<TString> args;
-
-  // This argument represents fake argv[0], which should be present in all arg
-  // lists.
-  args.push_back("");
-
-  for (const auto& flag_name : flag_names) {
-    // Avoid infinite recursion.
-    if (flag_name == "fromenv" || flag_name == "tryfromenv") {
-      flags_internal::ReportUsageError(
-          y_absl::StrCat("Infinite recursion on flag ", flag_name), true);
-
-      success = false;
-      continue;
-    }
-
-    const TString envname = y_absl::StrCat("FLAGS_", flag_name);
-    TString envval;
-    if (!GetEnvVar(envname.c_str(), envval)) {
-      if (fail_on_absent_in_env) {
-        flags_internal::ReportUsageError(
-            y_absl::StrCat(envname, " not found in environment"), true);
-
-        success = false;
-      }
-
-      continue;
-    }
-
-    args.push_back(y_absl::StrCat("--", flag_name, "=", envval));
-  }
-
-  if (success) {
-    input_args.emplace_back(args);
-  }
-
-  return success;
-}
-
-// --------------------------------------------------------------------
-
-// Returns success status, which is true if were able to handle all generator
-// flags (flagfile, fromenv, tryfromemv) successfully.
-bool HandleGeneratorFlags(std::vector<ArgsList>& input_args,
-                          std::vector<TString>& flagfile_value) {
-  bool success = true;
-
-  y_absl::MutexLock l(&flags_internal::processing_checks_guard);
-
-  // flagfile could have been set either on a command line or
-  // programmatically before invoking ParseCommandLine. Note that we do not
-  // actually process arguments specified in the flagfile, but instead
-  // create a secondary arguments list to be processed along with the rest
-  // of the comamnd line arguments. Since we always the process most recently
-  // created list of arguments first, this will result in flagfile argument
-  // being processed before any other argument in the command line. If
-  // FLAGS_flagfile contains more than one file name we create multiple new
-  // levels of arguments in a reverse order of file names. Thus we always
-  // process arguments from first file before arguments containing in a
-  // second file, etc. If flagfile contains another
-  // --flagfile inside of it, it will produce new level of arguments and
-  // processed before the rest of the flagfile. We are also collecting all
-  // flagfiles set on original command line. Unlike the rest of the flags,
-  // this flag can be set multiple times and is expected to be handled
-  // multiple times. We are collecting them all into a single list and set
-  // the value of FLAGS_flagfile to that value at the end of the parsing.
-  if (flags_internal::flagfile_needs_processing) {
-    auto flagfiles = y_absl::GetFlag(FLAGS_flagfile);
-
-    if (input_args.size() == 1) {
-      flagfile_value.insert(flagfile_value.end(), flagfiles.begin(),
-                            flagfiles.end());
-    }
-
-    success &= ReadFlagfiles(flagfiles, input_args);
-
-    flags_internal::flagfile_needs_processing = false;
-  }
-
-  // Similar to flagfile fromenv/tryfromemv can be set both
-  // programmatically and at runtime on a command line. Unlike flagfile these
-  // can't be recursive.
-  if (flags_internal::fromenv_needs_processing) {
-    auto flags_list = y_absl::GetFlag(FLAGS_fromenv);
-
-    success &= ReadFlagsFromEnv(flags_list, input_args, true);
-
-    flags_internal::fromenv_needs_processing = false;
-  }
-
-  if (flags_internal::tryfromenv_needs_processing) {
-    auto flags_list = y_absl::GetFlag(FLAGS_tryfromenv);
-
-    success &= ReadFlagsFromEnv(flags_list, input_args, false);
-
-    flags_internal::tryfromenv_needs_processing = false;
-  }
-
-  return success;
-}
-
-// --------------------------------------------------------------------
-
-void ResetGeneratorFlags(const std::vector<TString>& flagfile_value) {
-  // Setting flagfile to the value which collates all the values set on a
-  // command line and programmatically. So if command line looked like
-  // --flagfile=f1 --flagfile=f2 the final value of the FLAGS_flagfile flag is
-  // going to be {"f1", "f2"}
-  if (!flagfile_value.empty()) {
-    y_absl::SetFlag(&FLAGS_flagfile, flagfile_value);
-    y_absl::MutexLock l(&flags_internal::processing_checks_guard);
-    flags_internal::flagfile_needs_processing = false;
-  }
-
-  // fromenv/tryfromenv are set to <undefined> value.
-  if (!y_absl::GetFlag(FLAGS_fromenv).empty()) {
-    y_absl::SetFlag(&FLAGS_fromenv, {});
-  }
-  if (!y_absl::GetFlag(FLAGS_tryfromenv).empty()) {
-    y_absl::SetFlag(&FLAGS_tryfromenv, {});
-  }
-
-  y_absl::MutexLock l(&flags_internal::processing_checks_guard);
-  flags_internal::fromenv_needs_processing = false;
-  flags_internal::tryfromenv_needs_processing = false;
-}
-
-// --------------------------------------------------------------------
-
-// Returns:
-//  success status
-//  deduced value
-// We are also mutating curr_list in case if we need to get a hold of next
-// argument in the input.
-std::tuple<bool, y_absl::string_view> DeduceFlagValue(const CommandLineFlag& flag,
-                                                    y_absl::string_view value,
-                                                    bool is_negative,
-                                                    bool is_empty_value,
-                                                    ArgsList* curr_list) {
-  // Value is either an argument suffix after `=` in "--foo=<value>"
-  // or separate argument in case of "--foo" "<value>".
-
-  // boolean flags have these forms:
-  //   --foo
-  //   --nofoo
-  //   --foo=true
-  //   --foo=false
-  //   --nofoo=<value> is not supported
-  //   --foo <value> is not supported
-
-  // non boolean flags have these forms:
-  // --foo=<value>
-  // --foo <value>
-  // --nofoo is not supported
-
-  if (flag.IsOfType<bool>()) {
-    if (value.empty()) {
-      if (is_empty_value) {
-        // "--bool_flag=" case
-        flags_internal::ReportUsageError(
-            y_absl::StrCat(
-                "Missing the value after assignment for the boolean flag '",
-                flag.Name(), "'"),
-            true);
-        return std::make_tuple(false, "");
-      }
-
-      // "--bool_flag" case
-      value = is_negative ? "0" : "1";
-    } else if (is_negative) {
-      // "--nobool_flag=Y" case
-      flags_internal::ReportUsageError(
-          y_absl::StrCat("Negative form with assignment is not valid for the "
-                       "boolean flag '",
-                       flag.Name(), "'"),
-          true);
-      return std::make_tuple(false, "");
-    }
-  } else if (is_negative) {
-    // "--noint_flag=1" case
-    flags_internal::ReportUsageError(
-        y_absl::StrCat("Negative form is not valid for the flag '", flag.Name(),
-                     "'"),
-        true);
-    return std::make_tuple(false, "");
-  } else if (value.empty() && (!is_empty_value)) {
-    if (curr_list->Size() == 1) {
-      // "--int_flag" case
-      flags_internal::ReportUsageError(
-          y_absl::StrCat("Missing the value for the flag '", flag.Name(), "'"),
-          true);
-      return std::make_tuple(false, "");
-    }
-
-    // "--int_flag" "10" case
-    curr_list->PopFront();
-    value = curr_list->Front();
-
-    // Heuristic to detect the case where someone treats a string arg
-    // like a bool or just forgets to pass a value:
-    // --my_string_var --foo=bar
-    // We look for a flag of string type, whose value begins with a
-    // dash and corresponds to known flag or standalone --.
-    if (!value.empty() && value[0] == '-' && flag.IsOfType<TString>()) {
-      auto maybe_flag_name = std::get<0>(SplitNameAndValue(value.substr(1)));
-
-      if (maybe_flag_name.empty() ||
-          std::get<0>(LocateFlag(maybe_flag_name)) != nullptr) {
-        // "--string_flag" "--known_flag" case
-        Y_ABSL_INTERNAL_LOG(
-            WARNING,
-            y_absl::StrCat("Did you really mean to set flag '", flag.Name(),
-                         "' to the value '", value, "'?"));
-      }
-    }
-  }
-
-  return std::make_tuple(true, value);
-}
-
-// --------------------------------------------------------------------
-
-bool CanIgnoreUndefinedFlag(y_absl::string_view flag_name) {
-  auto undefok = y_absl::GetFlag(FLAGS_undefok);
-  if (std::find(undefok.begin(), undefok.end(), flag_name) != undefok.end()) {
-    return true;
-  }
-
-  if (y_absl::ConsumePrefix(&flag_name, "no") &&
-      std::find(undefok.begin(), undefok.end(), flag_name) != undefok.end()) {
-    return true;
-  }
-
-  return false;
-}
-
-}  // namespace
-
-// --------------------------------------------------------------------
-
-bool WasPresentOnCommandLine(y_absl::string_view flag_name) {
-  y_absl::MutexLock l(&specified_flags_guard);
-  Y_ABSL_INTERNAL_CHECK(specified_flags != nullptr,
-                      "ParseCommandLine is not invoked yet");
-
-  return std::binary_search(specified_flags->begin(), specified_flags->end(),
-                            flag_name, SpecifiedFlagsCompare{});
-}
-
-// --------------------------------------------------------------------
-
-std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
-                                        ArgvListAction arg_list_act,
-                                        UsageFlagsAction usage_flag_act,
-                                        OnUndefinedFlag on_undef_flag) {
-  Y_ABSL_INTERNAL_CHECK(argc > 0, "Missing argv[0]");
-
-  // Once parsing has started we will not have more flag registrations.
-  // If we did, they would be missing during parsing, which is a problem on
-  // itself.
-  flags_internal::FinalizeRegistry();
-
-  // This routine does not return anything since we abort on failure.
-  CheckDefaultValuesParsingRoundtrip();
-
-  std::vector<TString> flagfile_value;
-
-  std::vector<ArgsList> input_args;
-  input_args.push_back(ArgsList(argc, argv));
-
-  std::vector<char*> output_args;
-  std::vector<char*> positional_args;
-  output_args.reserve(argc);
-
-  // This is the list of undefined flags. The element of the list is the pair
-  // consisting of boolean indicating if flag came from command line (vs from
-  // some flag file we've read) and flag name.
-  // TODO(rogeeff): Eliminate the first element in the pair after cleanup.
-  std::vector<std::pair<bool, TString>> undefined_flag_names;
-
-  // Set program invocation name if it is not set before.
-  if (ProgramInvocationName() == "UNKNOWN") {
-    flags_internal::SetProgramInvocationName(argv[0]);
-  }
-  output_args.push_back(argv[0]);
-
-  y_absl::MutexLock l(&specified_flags_guard);
-  if (specified_flags == nullptr) {
-    specified_flags = new std::vector<const CommandLineFlag*>;
-  } else {
-    specified_flags->clear();
-  }
-
-  // Iterate through the list of the input arguments. First level are arguments
-  // originated from argc/argv. Following levels are arguments originated from
-  // recursive parsing of flagfile(s).
-  bool success = true;
-  while (!input_args.empty()) {
-    // 10. First we process the built-in generator flags.
-    success &= HandleGeneratorFlags(input_args, flagfile_value);
-
-    // 30. Select top-most (most recent) arguments list. If it is empty drop it
-    // and re-try.
-    ArgsList& curr_list = input_args.back();
-
-    curr_list.PopFront();
-
-    if (curr_list.Size() == 0) {
-      input_args.pop_back();
-      continue;
-    }
-
-    // 40. Pick up the front remaining argument in the current list. If current
-    // stack of argument lists contains only one element - we are processing an
-    // argument from the original argv.
-    y_absl::string_view arg(curr_list.Front());
-    bool arg_from_argv = input_args.size() == 1;
-
-    // 50. If argument does not start with - or is just "-" - this is
-    // positional argument.
-    if (!y_absl::ConsumePrefix(&arg, "-") || arg.empty()) {
-      Y_ABSL_INTERNAL_CHECK(arg_from_argv,
-                          "Flagfile cannot contain positional argument");
-
-      positional_args.push_back(argv[curr_list.FrontIndex()]);
-      continue;
-    }
-
-    if (arg_from_argv && (arg_list_act == ArgvListAction::kKeepParsedArgs)) {
-      output_args.push_back(argv[curr_list.FrontIndex()]);
-    }
-
-    // 60. Split the current argument on '=' to figure out the argument
-    // name and value. If flag name is empty it means we've got "--". value
-    // can be empty either if there were no '=' in argument string at all or
-    // an argument looked like "--foo=". In a latter case is_empty_value is
-    // true.
-    y_absl::string_view flag_name;
-    y_absl::string_view value;
-    bool is_empty_value = false;
-
-    std::tie(flag_name, value, is_empty_value) = SplitNameAndValue(arg);
-
-    // 70. "--" alone means what it does for GNU: stop flags parsing. We do
-    // not support positional arguments in flagfiles, so we just drop them.
-    if (flag_name.empty()) {
-      Y_ABSL_INTERNAL_CHECK(arg_from_argv,
-                          "Flagfile cannot contain positional argument");
-
-      curr_list.PopFront();
-      break;
-    }
-
-    // 80. Locate the flag based on flag name. Handle both --foo and --nofoo
-    CommandLineFlag* flag = nullptr;
-    bool is_negative = false;
-    std::tie(flag, is_negative) = LocateFlag(flag_name);
-
-    if (flag == nullptr) {
-      // Usage flags are not modeled as Abseil flags. Locate them separately.
-      if (flags_internal::DeduceUsageFlags(flag_name, value)) {
-        continue;
-      }
-
-      if (on_undef_flag != OnUndefinedFlag::kIgnoreUndefined) {
-        undefined_flag_names.emplace_back(arg_from_argv,
-                                          TString(flag_name));
-      }
-      continue;
-    }
-
-    // 90. Deduce flag's value (from this or next argument)
-    auto curr_index = curr_list.FrontIndex();
-    bool value_success = true;
-    std::tie(value_success, value) =
-        DeduceFlagValue(*flag, value, is_negative, is_empty_value, &curr_list);
-    success &= value_success;
-
-    // If above call consumed an argument, it was a standalone value
-    if (arg_from_argv && (arg_list_act == ArgvListAction::kKeepParsedArgs) &&
-        (curr_index != curr_list.FrontIndex())) {
-      output_args.push_back(argv[curr_list.FrontIndex()]);
-    }
-
-    // 100. Set the located flag to a new new value, unless it is retired.
-    // Setting retired flag fails, but we ignoring it here while also reporting
-    // access to retired flag.
-    TString error;
-    if (!flags_internal::PrivateHandleAccessor::ParseFrom(
-            *flag, value, SET_FLAGS_VALUE, kCommandLine, error)) {
-      if (flag->IsRetired()) continue;
-
-      flags_internal::ReportUsageError(error, true);
-      success = false;
-    } else {
-      specified_flags->push_back(flag);
-    }
-  }
-
-  for (const auto& flag_name : undefined_flag_names) {
-    if (CanIgnoreUndefinedFlag(flag_name.second)) continue;
-
-    flags_internal::ReportUsageError(
-        y_absl::StrCat("Unknown command line flag '", flag_name.second, "'"),
-        true);
-
-    success = false;
-  }
-
-#if Y_ABSL_FLAGS_STRIP_NAMES
-  if (!success) {
-    flags_internal::ReportUsageError(
-        "NOTE: command line flags are disabled in this build", true);
-  }
-#endif
-
-  if (!success) {
-    flags_internal::HandleUsageFlags(std::cout,
-                                     ProgramUsageMessage());
-    std::exit(1);
-  }
-
-  if (usage_flag_act == UsageFlagsAction::kHandleUsage) {
-    int exit_code = flags_internal::HandleUsageFlags(
-        std::cout, ProgramUsageMessage());
-
-    if (exit_code != -1) {
-      std::exit(exit_code);
-    }
-  }
-
-  ResetGeneratorFlags(flagfile_value);
-
-  // Reinstate positional args which were intermixed with flags in the arguments
-  // list.
-  for (auto arg : positional_args) {
-    output_args.push_back(arg);
-  }
-
-  // All the remaining arguments are positional.
-  if (!input_args.empty()) {
-    for (int arg_index = input_args.back().FrontIndex(); arg_index < argc;
-         ++arg_index) {
-      output_args.push_back(argv[arg_index]);
-    }
-  }
-
-  // Trim and sort the vector.
-  specified_flags->shrink_to_fit();
-  std::sort(specified_flags->begin(), specified_flags->end(),
-            SpecifiedFlagsCompare{});
-  return output_args;
-}
-
-}  // namespace flags_internal
-
-// --------------------------------------------------------------------
-
-std::vector<char*> ParseCommandLine(int argc, char* argv[]) {
-  return flags_internal::ParseCommandLineImpl(
-      argc, argv, flags_internal::ArgvListAction::kRemoveParsedArgs,
-      flags_internal::UsageFlagsAction::kHandleUsage,
-      flags_internal::OnUndefinedFlag::kAbortIfUndefined);
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.h
deleted file mode 100644
index c8ee5b21d3..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse.h
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: parse.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the main parsing function for Abseil flags:
-// `y_absl::ParseCommandLine()`.
-
-#ifndef Y_ABSL_FLAGS_PARSE_H_
-#define Y_ABSL_FLAGS_PARSE_H_
-
-#include <vector>
-
-#include "y_absl/base/config.h"
-#include "y_absl/flags/internal/parse.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-// ParseCommandLine()
-//
-// Parses the set of command-line arguments passed in the `argc` (argument
-// count) and `argv[]` (argument vector) parameters from `main()`, assigning
-// values to any defined Abseil flags. (Any arguments passed after the
-// flag-terminating delimiter (`--`) are treated as positional arguments and
-// ignored.)
-//
-// Any command-line flags (and arguments to those flags) are parsed into Abseil
-// Flag values, if those flags are defined. Any undefined flags will either
-// return an error, or be ignored if that flag is designated using `undefok` to
-// indicate "undefined is OK."
-//
-// Any command-line positional arguments not part of any command-line flag (or
-// arguments to a flag) are returned in a vector, with the program invocation
-// name at position 0 of that vector. (Note that this includes positional
-// arguments after the flag-terminating delimiter `--`.)
-//
-// After all flags and flag arguments are parsed, this function looks for any
-// built-in usage flags (e.g. `--help`), and if any were specified, it reports
-// help messages and then exits the program.
-std::vector<char*> ParseCommandLine(int argc, char* argv[]);
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_PARSE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.cc
deleted file mode 100644
index 8776612249..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.cc
+++ /dev/null
@@ -1,354 +0,0 @@
-//
-//  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/flags/reflection.h"
-
-#include <assert.h>
-
-#include <atomic>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/container/flat_hash_map.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/internal/private_handle_accessor.h"
-#include "y_absl/flags/internal/registry.h"
-#include "y_absl/flags/usage_config.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/synchronization/mutex.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// --------------------------------------------------------------------
-// FlagRegistry
-//    A FlagRegistry singleton object holds all flag objects indexed by their
-//    names so that if you know a flag's name, you can access or set it. If the
-//    function is named FooLocked(), you must own the registry lock before
-//    calling the function; otherwise, you should *not* hold the lock, and the
-//    function will acquire it itself if needed.
-// --------------------------------------------------------------------
-
-class FlagRegistry {
- public:
-  FlagRegistry() = default;
-  ~FlagRegistry() = default;
-
-  // Store a flag in this registry. Takes ownership of *flag.
-  void RegisterFlag(CommandLineFlag& flag, const char* filename);
-
-  void Lock() Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
-  void Unlock() Y_ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
-
-  // Returns the flag object for the specified name, or nullptr if not found.
-  // Will emit a warning if a 'retired' flag is specified.
-  CommandLineFlag* FindFlag(y_absl::string_view name);
-
-  static FlagRegistry& GlobalRegistry();  // returns a singleton registry
-
- private:
-  friend class flags_internal::FlagSaverImpl;  // reads all the flags in order
-                                               // to copy them
-  friend void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
-  friend void FinalizeRegistry();
-
-  // The map from name to flag, for FindFlag().
-  using FlagMap = y_absl::flat_hash_map<y_absl::string_view, CommandLineFlag*>;
-  using FlagIterator = FlagMap::iterator;
-  using FlagConstIterator = FlagMap::const_iterator;
-  FlagMap flags_;
-  std::vector<CommandLineFlag*> flat_flags_;
-  std::atomic<bool> finalized_flags_{false};
-
-  y_absl::Mutex lock_;
-
-  // Disallow
-  FlagRegistry(const FlagRegistry&);
-  FlagRegistry& operator=(const FlagRegistry&);
-};
-
-namespace {
-
-class FlagRegistryLock {
- public:
-  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); }
-  ~FlagRegistryLock() { fr_.Unlock(); }
-
- private:
-  FlagRegistry& fr_;
-};
-
-}  // namespace
-
-CommandLineFlag* FlagRegistry::FindFlag(y_absl::string_view name) {
-  if (finalized_flags_.load(std::memory_order_acquire)) {
-    // We could save some gcus here if we make `Name()` be non-virtual.
-    // We could move the `const char*` name to the base class.
-    auto it = std::partition_point(
-        flat_flags_.begin(), flat_flags_.end(),
-        [=](CommandLineFlag* f) { return f->Name() < name; });
-    if (it != flat_flags_.end() && (*it)->Name() == name) return *it;
-  }
-
-  FlagRegistryLock frl(*this);
-  auto it = flags_.find(name);
-  return it != flags_.end() ? it->second : nullptr;
-}
-
-void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) {
-  if (filename != nullptr &&
-      flag.Filename() != GetUsageConfig().normalize_filename(filename)) {
-    flags_internal::ReportUsageError(
-        y_absl::StrCat(
-            "Inconsistency between flag object and registration for flag '",
-            flag.Name(),
-            "', likely due to duplicate flags or an ODR violation. Relevant "
-            "files: ",
-            flag.Filename(), " and ", filename),
-        true);
-    std::exit(1);
-  }
-
-  FlagRegistryLock registry_lock(*this);
-
-  std::pair<FlagIterator, bool> ins =
-      flags_.insert(FlagMap::value_type(flag.Name(), &flag));
-  if (ins.second == false) {  // means the name was already in the map
-    CommandLineFlag& old_flag = *ins.first->second;
-    if (flag.IsRetired() != old_flag.IsRetired()) {
-      // All registrations must agree on the 'retired' flag.
-      flags_internal::ReportUsageError(
-          y_absl::StrCat(
-              "Retired flag '", flag.Name(), "' was defined normally in file '",
-              (flag.IsRetired() ? old_flag.Filename() : flag.Filename()), "'."),
-          true);
-    } else if (flags_internal::PrivateHandleAccessor::TypeId(flag) !=
-               flags_internal::PrivateHandleAccessor::TypeId(old_flag)) {
-      flags_internal::ReportUsageError(
-          y_absl::StrCat("Flag '", flag.Name(),
-                       "' was defined more than once but with "
-                       "differing types. Defined in files '",
-                       old_flag.Filename(), "' and '", flag.Filename(), "'."),
-          true);
-    } else if (old_flag.IsRetired()) {
-      return;
-    } else if (old_flag.Filename() != flag.Filename()) {
-      flags_internal::ReportUsageError(
-          y_absl::StrCat("Flag '", flag.Name(),
-                       "' was defined more than once (in files '",
-                       old_flag.Filename(), "' and '", flag.Filename(), "')."),
-          true);
-    } else {
-      flags_internal::ReportUsageError(
-          y_absl::StrCat(
-              "Something is wrong with flag '", flag.Name(), "' in file '",
-              flag.Filename(), "'. One possibility: file '", flag.Filename(),
-              "' is being linked both statically and dynamically into this "
-              "executable. e.g. some files listed as srcs to a test and also "
-              "listed as srcs of some shared lib deps of the same test."),
-          true);
-    }
-    // All cases above are fatal, except for the retired flags.
-    std::exit(1);
-  }
-}
-
-FlagRegistry& FlagRegistry::GlobalRegistry() {
-  static FlagRegistry* global_registry = new FlagRegistry;
-  return *global_registry;
-}
-
-// --------------------------------------------------------------------
-
-void ForEachFlag(std::function<void(CommandLineFlag&)> visitor) {
-  FlagRegistry& registry = FlagRegistry::GlobalRegistry();
-
-  if (registry.finalized_flags_.load(std::memory_order_acquire)) {
-    for (const auto& i : registry.flat_flags_) visitor(*i);
-  }
-
-  FlagRegistryLock frl(registry);
-  for (const auto& i : registry.flags_) visitor(*i.second);
-}
-
-// --------------------------------------------------------------------
-
-bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) {
-  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename);
-  return true;
-}
-
-void FinalizeRegistry() {
-  auto& registry = FlagRegistry::GlobalRegistry();
-  FlagRegistryLock frl(registry);
-  if (registry.finalized_flags_.load(std::memory_order_relaxed)) {
-    // Was already finalized. Ignore the second time.
-    return;
-  }
-  registry.flat_flags_.reserve(registry.flags_.size());
-  for (const auto& f : registry.flags_) {
-    registry.flat_flags_.push_back(f.second);
-  }
-  std::sort(std::begin(registry.flat_flags_), std::end(registry.flat_flags_),
-            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
-              return lhs->Name() < rhs->Name();
-            });
-  registry.flags_.clear();
-  registry.finalized_flags_.store(true, std::memory_order_release);
-}
-
-// --------------------------------------------------------------------
-
-namespace {
-
-class RetiredFlagObj final : public CommandLineFlag {
- public:
-  constexpr RetiredFlagObj(const char* name, FlagFastTypeId type_id)
-      : name_(name), type_id_(type_id) {}
-
- private:
-  y_absl::string_view Name() const override { return name_; }
-  TString Filename() const override {
-    OnAccess();
-    return "RETIRED";
-  }
-  FlagFastTypeId TypeId() const override { return type_id_; }
-  TString Help() const override {
-    OnAccess();
-    return "";
-  }
-  bool IsRetired() const override { return true; }
-  bool IsSpecifiedOnCommandLine() const override {
-    OnAccess();
-    return false;
-  }
-  TString DefaultValue() const override {
-    OnAccess();
-    return "";
-  }
-  TString CurrentValue() const override {
-    OnAccess();
-    return "";
-  }
-
-  // Any input is valid
-  bool ValidateInputValue(y_absl::string_view) const override {
-    OnAccess();
-    return true;
-  }
-
-  std::unique_ptr<flags_internal::FlagStateInterface> SaveState() override {
-    return nullptr;
-  }
-
-  bool ParseFrom(y_absl::string_view, flags_internal::FlagSettingMode,
-                 flags_internal::ValueSource, TString&) override {
-    OnAccess();
-    return false;
-  }
-
-  void CheckDefaultValueParsingRoundtrip() const override { OnAccess(); }
-
-  void Read(void*) const override { OnAccess(); }
-
-  void OnAccess() const {
-    flags_internal::ReportUsageError(
-        y_absl::StrCat("Accessing retired flag '", name_, "'"), false);
-  }
-
-  // Data members
-  const char* const name_;
-  const FlagFastTypeId type_id_;
-};
-
-}  // namespace
-
-void Retire(const char* name, FlagFastTypeId type_id, char* buf) {
-  static_assert(sizeof(RetiredFlagObj) == kRetiredFlagObjSize, "");
-  static_assert(alignof(RetiredFlagObj) == kRetiredFlagObjAlignment, "");
-  auto* flag = ::new (static_cast<void*>(buf))
-      flags_internal::RetiredFlagObj(name, type_id);
-  FlagRegistry::GlobalRegistry().RegisterFlag(*flag, nullptr);
-}
-
-// --------------------------------------------------------------------
-
-class FlagSaverImpl {
- public:
-  FlagSaverImpl() = default;
-  FlagSaverImpl(const FlagSaverImpl&) = delete;
-  void operator=(const FlagSaverImpl&) = delete;
-
-  // Saves the flag states from the flag registry into this object.
-  // It's an error to call this more than once.
-  void SaveFromRegistry() {
-    assert(backup_registry_.empty());  // call only once!
-    flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
-      if (auto flag_state =
-              flags_internal::PrivateHandleAccessor::SaveState(flag)) {
-        backup_registry_.emplace_back(std::move(flag_state));
-      }
-    });
-  }
-
-  // Restores the saved flag states into the flag registry.
-  void RestoreToRegistry() {
-    for (const auto& flag_state : backup_registry_) {
-      flag_state->Restore();
-    }
-  }
-
- private:
-  std::vector<std::unique_ptr<flags_internal::FlagStateInterface>>
-      backup_registry_;
-};
-
-}  // namespace flags_internal
-
-FlagSaver::FlagSaver() : impl_(new flags_internal::FlagSaverImpl) {
-  impl_->SaveFromRegistry();
-}
-
-FlagSaver::~FlagSaver() {
-  if (!impl_) return;
-
-  impl_->RestoreToRegistry();
-  delete impl_;
-}
-
-// --------------------------------------------------------------------
-
-CommandLineFlag* FindCommandLineFlag(y_absl::string_view name) {
-  if (name.empty()) return nullptr;
-  flags_internal::FlagRegistry& registry =
-      flags_internal::FlagRegistry::GlobalRegistry();
-  return registry.FindFlag(name);
-}
-
-// --------------------------------------------------------------------
-
-y_absl::flat_hash_map<y_absl::string_view, y_absl::CommandLineFlag*> GetAllFlags() {
-  y_absl::flat_hash_map<y_absl::string_view, y_absl::CommandLineFlag*> res;
-  flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
-    if (!flag.IsRetired()) res.insert({flag.Name(), &flag});
-  });
-  return res;
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.h
deleted file mode 100644
index d2456590da..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection.h
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// 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: reflection.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the routines to access and operate on an Abseil Flag's
-// reflection handle.
-
-#ifndef Y_ABSL_FLAGS_REFLECTION_H_
-#define Y_ABSL_FLAGS_REFLECTION_H_
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/container/flat_hash_map.h"
-#include "y_absl/flags/commandlineflag.h"
-#include "y_absl/flags/internal/commandlineflag.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-class FlagSaverImpl;
-}  // namespace flags_internal
-
-// FindCommandLineFlag()
-//
-// Returns the reflection handle of an Abseil flag of the specified name, or
-// `nullptr` if not found. This function will emit a warning if the name of a
-// 'retired' flag is specified.
-y_absl::CommandLineFlag* FindCommandLineFlag(y_absl::string_view name);
-
-// Returns current state of the Flags registry in a form of mapping from flag
-// name to a flag reflection handle.
-y_absl::flat_hash_map<y_absl::string_view, y_absl::CommandLineFlag*> GetAllFlags();
-
-//------------------------------------------------------------------------------
-// FlagSaver
-//------------------------------------------------------------------------------
-//
-// A FlagSaver object stores the state of flags in the scope where the FlagSaver
-// is defined, allowing modification of those flags within that scope and
-// automatic restoration of the flags to their previous state upon leaving the
-// scope.
-//
-// A FlagSaver can be used within tests to temporarily change the test
-// environment and restore the test case to its previous state.
-//
-// Example:
-//
-//   void MyFunc() {
-//    y_absl::FlagSaver fs;
-//    ...
-//    y_absl::SetFlag(&FLAGS_myFlag, otherValue);
-//    ...
-//  } // scope of FlagSaver left, flags return to previous state
-//
-// This class is thread-safe.
-
-class FlagSaver {
- public:
-  FlagSaver();
-  ~FlagSaver();
-
-  FlagSaver(const FlagSaver&) = delete;
-  void operator=(const FlagSaver&) = delete;
-
- private:
-  flags_internal::FlagSaverImpl* impl_;
-};
-
-//-----------------------------------------------------------------------------
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_REFLECTION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.cc
deleted file mode 100644
index 495bd01fa3..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// 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.
-#include "y_absl/flags/usage.h"
-
-#include <stdlib.h>
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/const_init.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/flags/internal/usage.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/synchronization/mutex.h"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-namespace {
-Y_ABSL_CONST_INIT y_absl::Mutex usage_message_guard(y_absl::kConstInit);
-Y_ABSL_CONST_INIT TString* program_usage_message
-    Y_ABSL_GUARDED_BY(usage_message_guard) = nullptr;
-}  // namespace
-}  // namespace flags_internal
-
-// --------------------------------------------------------------------
-// Sets the "usage" message to be used by help reporting routines.
-void SetProgramUsageMessage(y_absl::string_view new_usage_message) {
-  y_absl::MutexLock l(&flags_internal::usage_message_guard);
-
-  if (flags_internal::program_usage_message != nullptr) {
-    Y_ABSL_INTERNAL_LOG(FATAL, "SetProgramUsageMessage() called twice.");
-    std::exit(1);
-  }
-
-  flags_internal::program_usage_message = new TString(new_usage_message);
-}
-
-// --------------------------------------------------------------------
-// Returns the usage message set by SetProgramUsageMessage().
-// Note: We able to return string_view here only because calling
-// SetProgramUsageMessage twice is prohibited.
-y_absl::string_view ProgramUsageMessage() {
-  y_absl::MutexLock l(&flags_internal::usage_message_guard);
-
-  return flags_internal::program_usage_message != nullptr
-             ? y_absl::string_view(*flags_internal::program_usage_message)
-             : "Warning: SetProgramUsageMessage() never called";
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.h
deleted file mode 100644
index 8ce0f1195f..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage.h
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-//  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 Y_ABSL_FLAGS_USAGE_H_
-#define Y_ABSL_FLAGS_USAGE_H_
-
-#include "y_absl/base/config.h"
-#include "y_absl/strings/string_view.h"
-
-// --------------------------------------------------------------------
-// Usage reporting interfaces
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-// Sets the "usage" message to be used by help reporting routines.
-// For example:
-//  y_absl::SetProgramUsageMessage(
-//      y_absl::StrCat("This program does nothing.  Sample usage:\n", argv[0],
-//                   " <uselessarg1> <uselessarg2>"));
-// Do not include commandline flags in the usage: we do that for you!
-// Note: Calling SetProgramUsageMessage twice will trigger a call to std::exit.
-void SetProgramUsageMessage(y_absl::string_view new_usage_message);
-
-// Returns the usage message set by SetProgramUsageMessage().
-y_absl::string_view ProgramUsageMessage();
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // Y_ABSL_FLAGS_USAGE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.cc
deleted file mode 100644
index c6cf8296d6..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-//  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.
-
-#include "y_absl/flags/usage_config.h"
-
-#include <functional>
-#include <iostream>
-#include <util/generic/string.h>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/base/const_init.h"
-#include "y_absl/base/thread_annotations.h"
-#include "y_absl/flags/internal/path_util.h"
-#include "y_absl/flags/internal/program_name.h"
-#include "y_absl/strings/match.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/strings/strip.h"
-#include "y_absl/synchronization/mutex.h"
-
-extern "C" {
-
-// Additional report of fatal usage error message before we std::exit. Error is
-// fatal if is_fatal argument to ReportUsageError is true.
-Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalReportFatalUsageError)(y_absl::string_view) {}
-
-}  // extern "C"
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-namespace {
-
-// --------------------------------------------------------------------
-// Returns true if flags defined in the filename should be reported with
-// -helpshort flag.
-
-bool ContainsHelpshortFlags(y_absl::string_view filename) {
-  // By default we only want flags in binary's main. We expect the main
-  // routine to reside in <program>.cc or <program>-main.cc or
-  // <program>_main.cc, where the <program> is the name of the binary
-  // (without .exe on Windows).
-  auto suffix = flags_internal::Basename(filename);
-  auto program_name = flags_internal::ShortProgramInvocationName();
-  y_absl::string_view program_name_ref = program_name;
-#if defined(_WIN32)
-  y_absl::ConsumeSuffix(&program_name_ref, ".exe");
-#endif
-  if (!y_absl::ConsumePrefix(&suffix, program_name_ref))
-    return false;
-  return y_absl::StartsWith(suffix, ".") || y_absl::StartsWith(suffix, "-main.") ||
-         y_absl::StartsWith(suffix, "_main.");
-}
-
-// --------------------------------------------------------------------
-// Returns true if flags defined in the filename should be reported with
-// -helppackage flag.
-
-bool ContainsHelppackageFlags(y_absl::string_view filename) {
-  // TODO(rogeeff): implement properly when registry is available.
-  return ContainsHelpshortFlags(filename);
-}
-
-// --------------------------------------------------------------------
-// Generates program version information into supplied output.
-
-TString VersionString() {
-  TString version_str(flags_internal::ShortProgramInvocationName());
-
-  version_str += "\n";
-
-#if !defined(NDEBUG)
-  version_str += "Debug build (NDEBUG not #defined)\n";
-#endif
-
-  return version_str;
-}
-
-// --------------------------------------------------------------------
-// Normalizes the filename specific to the build system/filesystem used.
-
-TString NormalizeFilename(y_absl::string_view filename) {
-  // Skip any leading slashes
-  auto pos = filename.find_first_not_of("\\/");
-  if (pos == y_absl::string_view::npos) return "";
-
-  filename.remove_prefix(pos);
-  return TString(filename);
-}
-
-// --------------------------------------------------------------------
-
-Y_ABSL_CONST_INIT y_absl::Mutex custom_usage_config_guard(y_absl::kConstInit);
-Y_ABSL_CONST_INIT FlagsUsageConfig* custom_usage_config
-    Y_ABSL_GUARDED_BY(custom_usage_config_guard) = nullptr;
-
-}  // namespace
-
-FlagsUsageConfig GetUsageConfig() {
-  y_absl::MutexLock l(&custom_usage_config_guard);
-
-  if (custom_usage_config) return *custom_usage_config;
-
-  FlagsUsageConfig default_config;
-  default_config.contains_helpshort_flags = &ContainsHelpshortFlags;
-  default_config.contains_help_flags = &ContainsHelppackageFlags;
-  default_config.contains_helppackage_flags = &ContainsHelppackageFlags;
-  default_config.version_string = &VersionString;
-  default_config.normalize_filename = &NormalizeFilename;
-
-  return default_config;
-}
-
-void ReportUsageError(y_absl::string_view msg, bool is_fatal) {
-  std::cerr << "ERROR: " << msg << std::endl;
-
-  if (is_fatal) {
-    Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(msg);
-  }
-}
-
-}  // namespace flags_internal
-
-void SetFlagsUsageConfig(FlagsUsageConfig usage_config) {
-  y_absl::MutexLock l(&flags_internal::custom_usage_config_guard);
-
-  if (!usage_config.contains_helpshort_flags)
-    usage_config.contains_helpshort_flags =
-        flags_internal::ContainsHelpshortFlags;
-
-  if (!usage_config.contains_help_flags)
-    usage_config.contains_help_flags = flags_internal::ContainsHelppackageFlags;
-
-  if (!usage_config.contains_helppackage_flags)
-    usage_config.contains_helppackage_flags =
-        flags_internal::ContainsHelppackageFlags;
-
-  if (!usage_config.version_string)
-    usage_config.version_string = flags_internal::VersionString;
-
-  if (!usage_config.normalize_filename)
-    usage_config.normalize_filename = flags_internal::NormalizeFilename;
-
-  if (flags_internal::custom_usage_config)
-    *flags_internal::custom_usage_config = usage_config;
-  else
-    flags_internal::custom_usage_config = new FlagsUsageConfig(usage_config);
-}
-
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.h
deleted file mode 100644
index 99b862f5d6..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config.h
+++ /dev/null
@@ -1,135 +0,0 @@
-//
-//  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.
-//
-// -----------------------------------------------------------------------------
-// File: usage_config.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the main usage reporting configuration interfaces and
-// documents Abseil's supported built-in usage flags. If these flags are found
-// when parsing a command-line, Abseil will exit the program and display
-// appropriate help messages.
-#ifndef Y_ABSL_FLAGS_USAGE_CONFIG_H_
-#define Y_ABSL_FLAGS_USAGE_CONFIG_H_
-
-#include <functional>
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-#include "y_absl/strings/string_view.h"
-
-// -----------------------------------------------------------------------------
-// Built-in Usage Flags
-// -----------------------------------------------------------------------------
-//
-// Abseil supports the following built-in usage flags. When passed, these flags
-// exit the program and :
-//
-// * --help
-//     Shows help on important flags for this binary
-// * --helpfull
-//     Shows help on all flags
-// * --helpshort
-//     Shows help on only the main module for this program
-// * --helppackage
-//     Shows help on all modules in the main package
-// * --version
-//     Shows the version and build info for this binary and exits
-// * --only_check_args
-//     Exits after checking all flags
-// * --helpon
-//     Shows help on the modules named by this flag value
-// * --helpmatch
-//     Shows help on modules whose name contains the specified substring
-
-namespace y_absl {
-Y_ABSL_NAMESPACE_BEGIN
-
-namespace flags_internal {
-using FlagKindFilter = std::function<bool (y_absl::string_view)>;
-}  // namespace flags_internal
-
-// FlagsUsageConfig
-//
-// This structure contains the collection of callbacks for changing the behavior
-// of the usage reporting routines in Abseil Flags.
-struct FlagsUsageConfig {
-  // Returns true if flags defined in the given source code file should be
-  // reported with --helpshort flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_helpshort_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --helpshort will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_helpshort_flags;
-
-  // Returns true if flags defined in the filename should be reported with
-  // --help flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_help_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --help will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_help_flags;
-
-  // Returns true if flags defined in the filename should be reported with
-  // --helppackage flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_helppackage_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --helppackage will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_helppackage_flags;
-
-  // Generates string containing program version. This is the string reported
-  // when user specifies --version in a command line.
-  std::function<TString()> version_string;
-
-  // Normalizes the filename specific to the build system/filesystem used. This
-  // routine is used when we report the information about the flag definition
-  // location. For instance, if your build resides at some location you do not
-  // want to expose in the usage output, you can trim it to show only relevant
-  // part.
-  // For example:
-  //   normalize_filename("/my_company/some_long_path/src/project/file.cc")
-  // might produce
-  //   "project/file.cc".
-  std::function<TString(y_absl::string_view)> normalize_filename;
-};
-
-// SetFlagsUsageConfig()
-//
-// Sets the usage reporting configuration callbacks. If any of the callbacks are
-// not set in usage_config instance, then the default value of the callback is
-// used.
-void SetFlagsUsageConfig(FlagsUsageConfig usage_config);
-
-namespace flags_internal {
-
-FlagsUsageConfig GetUsageConfig();
-
-void ReportUsageError(y_absl::string_view msg, bool is_fatal);
-
-}  // namespace flags_internal
-Y_ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-extern "C" {
-
-// Additional report of fatal usage error message before we std::exit. Error is
-// fatal if is_fatal argument to ReportUsageError is true.
-void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(
-    y_absl::string_view);
-
-}  // extern "C"
-
-#endif  // Y_ABSL_FLAGS_USAGE_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/flags/ya.make
deleted file mode 100644
index f8e0a201f7..0000000000
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/flags/ya.make
+++ /dev/null
@@ -1,44 +0,0 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/container
-    contrib/restricted/abseil-cpp-tstring/y_absl/debugging
-    contrib/restricted/abseil-cpp-tstring/y_absl/hash
-    contrib/restricted/abseil-cpp-tstring/y_absl/memory
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/profiling
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
-    contrib/restricted/abseil-cpp-tstring/y_absl/synchronization
-    contrib/restricted/abseil-cpp-tstring/y_absl/time
-    contrib/restricted/abseil-cpp-tstring/y_absl/types
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
-SRCS(
-    commandlineflag.cc
-    flag.cc
-    internal/commandlineflag.cc
-    internal/flag.cc
-    internal/private_handle_accessor.cc
-    internal/program_name.cc
-    internal/usage.cc
-    marshalling.cc
-    parse.cc
-    reflection.cc
-    usage.cc
-    usage_config.cc
-)
-
-END()