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

12 files changed, 463 insertions, 463 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
index aac6c71d05..68f928b27c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
@@ -1,18 +1,18 @@
 ====================Apache-2.0====================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-
-
-====================Apache-2.0====================
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License. 
+ * You may obtain a copy of the License at 
+ * 
+ *      https://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License. 
+ 
+ 
+====================Apache-2.0==================== 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
index 0a4daa2f5c..622460ebb1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
@@ -1617,7 +1617,7 @@ static bool ParseUnresolvedName(State *state) {
 //              ::= <2-ary operator-name> <expression> <expression>
 //              ::= <3-ary operator-name> <expression> <expression> <expression>
 //              ::= cl <expression>+ E
-//              ::= cp <simple-id> <expression>* E # Clang-specific.
+//              ::= cp <simple-id> <expression>* E # Clang-specific. 
 //              ::= cv <type> <expression>      # type (expression)
 //              ::= cv <type> _ <expression>* E # type (expr-list)
 //              ::= st <type>
@@ -1640,8 +1640,8 @@ static bool ParseExpression(State *state) {
     return true;
   }
 
-  ParseState copy = state->parse_state;
-
+  ParseState copy = state->parse_state; 
+ 
   // Object/function call expression.
   if (ParseTwoCharToken(state, "cl") && OneOrMore(ParseExpression, state) &&
       ParseOneCharToken(state, 'E')) {
@@ -1649,14 +1649,14 @@ static bool ParseExpression(State *state) {
   }
   state->parse_state = copy;
 
-  // Clang-specific "cp <simple-id> <expression>* E"
-  //   https://clang.llvm.org/doxygen/ItaniumMangle_8cpp_source.html#l04338
-  if (ParseTwoCharToken(state, "cp") && ParseSimpleId(state) &&
-      ZeroOrMore(ParseExpression, state) && ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  state->parse_state = copy;
-
+  // Clang-specific "cp <simple-id> <expression>* E" 
+  //   https://clang.llvm.org/doxygen/ItaniumMangle_8cpp_source.html#l04338 
+  if (ParseTwoCharToken(state, "cp") && ParseSimpleId(state) && 
+      ZeroOrMore(ParseExpression, state) && ParseOneCharToken(state, 'E')) { 
+    return true; 
+  } 
+  state->parse_state = copy; 
+ 
   // Function-param expression (level 0).
   if (ParseTwoCharToken(state, "fp") && Optional(ParseCVQualifiers(state)) &&
       Optional(ParseNumber(state, nullptr)) && ParseOneCharToken(state, '_')) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
index ba4bbc3855..1db568e3a4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
@@ -22,7 +22,7 @@
 #include <string.h>
 #include <cassert>
 #include <cstddef>
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/base/internal/raw_logging.h"
 
 // From binutils/include/elf/common.h (this doesn't appear to be documented
@@ -44,11 +44,11 @@ namespace debugging_internal {
 
 namespace {
 
-#if __SIZEOF_POINTER__ == 4
+#if __SIZEOF_POINTER__ == 4 
 const int kElfClass = ELFCLASS32;
 int ElfBind(const ElfW(Sym) *symbol) { return ELF32_ST_BIND(symbol->st_info); }
 int ElfType(const ElfW(Sym) *symbol) { return ELF32_ST_TYPE(symbol->st_info); }
-#elif __SIZEOF_POINTER__ == 8
+#elif __SIZEOF_POINTER__ == 8 
 const int kElfClass = ELFCLASS64;
 int ElfBind(const ElfW(Sym) *symbol) { return ELF64_ST_BIND(symbol->st_info); }
 int ElfType(const ElfW(Sym) *symbol) { return ELF64_ST_TYPE(symbol->st_info); }
@@ -176,17 +176,17 @@ void ElfMemImage::Init(const void *base) {
   }
   switch (base_as_char[EI_DATA]) {
     case ELFDATA2LSB: {
-#ifndef ABSL_IS_LITTLE_ENDIAN
-      assert(false);
-      return;
-#endif
+#ifndef ABSL_IS_LITTLE_ENDIAN 
+      assert(false); 
+      return; 
+#endif 
       break;
     }
     case ELFDATA2MSB: {
-#ifndef ABSL_IS_BIG_ENDIAN
-      assert(false);
-      return;
-#endif
+#ifndef ABSL_IS_BIG_ENDIAN 
+      assert(false); 
+      return; 
+#endif 
       break;
     }
     default: {
@@ -222,7 +222,7 @@ void ElfMemImage::Init(const void *base) {
       reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr +
                                     relocation);
   for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
-    const auto value = dynamic_entry->d_un.d_val + relocation;
+    const auto value = dynamic_entry->d_un.d_val + relocation; 
     switch (dynamic_entry->d_tag) {
       case DT_HASH:
         hash_ = reinterpret_cast<ElfW(Word) *>(value);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
index 13a6b2e664..c7a189e95f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
@@ -31,8 +31,8 @@
 #error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
 #endif
 
-#if defined(__ELF__) && !defined(__native_client__) && !defined(__asmjs__) && \
-    !defined(__wasm__)
+#if defined(__ELF__) && !defined(__native_client__) && !defined(__asmjs__) && \ 
+    !defined(__wasm__) 
 #define ABSL_HAVE_ELF_MEM_IMAGE 1
 #endif
 
@@ -40,10 +40,10 @@
 
 #include <link.h>  // for ElfW
 
-#if defined(__FreeBSD__) && !defined(ElfW)
-#define ElfW(x) __ElfN(x)
-#endif
-
+#if defined(__FreeBSD__) && !defined(ElfW) 
+#define ElfW(x) __ElfN(x) 
+#endif 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
index 80137ad0eb..846c1b9ced 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
@@ -26,7 +26,7 @@
 #error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
 #elif !defined(__APPLE__) && !defined(_WIN32) &&                     \
     (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \
-     defined(__aarch64__) || defined(__riscv))
+     defined(__aarch64__) || defined(__riscv)) 
 #define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
 
 namespace y_absl {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
index 7ba212ab03..83705649d4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
@@ -35,12 +35,12 @@
 // Thread local support required for UnwindImpl.
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // defined(ABSL_HAVE_THREAD_LOCAL)
-
-#elif defined(__EMSCRIPTEN__)
-#define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_emscripten-inl.inc"
+#endif  // defined(ABSL_HAVE_THREAD_LOCAL) 
 
+#elif defined(__EMSCRIPTEN__) 
+#define ABSL_STACKTRACE_INL_HEADER \ 
+  "y_absl/debugging/internal/stacktrace_emscripten-inl.inc" 
+ 
 #elif defined(__linux__) && !defined(__ANDROID__)
 
 #if defined(NO_FRAME_POINTER) && \
@@ -55,7 +55,7 @@
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
+#endif  // __has_include(<execinfo.h>) 
 #elif defined(__i386__) || defined(__x86_64__)
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_x86-inl.inc"
@@ -65,18 +65,18 @@
 #elif defined(__aarch64__)
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_aarch64-inl.inc"
-#elif defined(__riscv)
-#define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_riscv-inl.inc"
+#elif defined(__riscv) 
+#define ABSL_STACKTRACE_INL_HEADER \ 
+  "y_absl/debugging/internal/stacktrace_riscv-inl.inc" 
 #elif defined(__has_include)
 #if __has_include(<execinfo.h>)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
-#endif  // defined(__has_include)
+#endif  // __has_include(<execinfo.h>) 
+#endif  // defined(__has_include) 
 
-#endif  // defined(__linux__) && !defined(__ANDROID__)
+#endif  // defined(__linux__) && !defined(__ANDROID__) 
 
 // Fallback to the empty implementation.
 #if !defined(ABSL_STACKTRACE_INL_HEADER)
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
index cdb5557134..6d9a9a1ee7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
@@ -1,110 +1,110 @@
-// Copyright 2017 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.
-//
-// Portable implementation - just use glibc
-//
-// Note:  The glibc implementation may cause a call to malloc.
-// This can cause a deadlock in HeapProfiler.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
-
-#error #include <emscripten.h>
-
-#include <atomic>
-#include <cstring>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/debugging/stacktrace.h"
-
-extern "C" {
-uintptr_t emscripten_stack_snapshot();
-uint32_t emscripten_stack_unwind_buffer(uintptr_t pc, void *buffer,
-                                        uint32_t depth);
-}
-
-// Sometimes, we can try to get a stack trace from within a stack
-// trace, which can cause a self-deadlock.
-// Protect against such reentrant call by failing to get a stack trace.
-//
-// We use __thread here because the code here is extremely low level -- it is
-// called while collecting stack traces from within malloc and mmap, and thus
-// can not call anything which might call malloc or mmap itself.
-static __thread int recursive = 0;
-
-// The stack trace function might be invoked very early in the program's
-// execution (e.g. from the very first malloc).
-// As such, we suppress usage of backtrace during this early stage of execution.
-static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
-// Waiting until static initializers run seems to be late enough.
-// This file is included into stacktrace.cc so this will only run once.
-ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
-  // Check if we can even create stacktraces. If not, bail early and leave
-  // disable_stacktraces set as-is.
-  // clang-format off
-  if (!EM_ASM_INT({ return (typeof wasmOffsetConverter !== 'undefined'); })) {
-    return 0;
-  }
-  // clang-format on
-  disable_stacktraces.store(false, std::memory_order_relaxed);
-  return 0;
-}();
-
-template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
-  if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) {
-    return 0;
-  }
-  ++recursive;
-
-  static_cast<void>(ucp);  // Unused.
-  constexpr int kStackLength = 64;
-  void *stack[kStackLength];
-
-  int size;
-  uintptr_t pc = emscripten_stack_snapshot();
-  size = emscripten_stack_unwind_buffer(pc, stack, kStackLength);
-
-  int result_count = size - skip_count;
-  if (result_count < 0) result_count = 0;
-  if (result_count > max_depth) result_count = max_depth;
-  for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count];
-
-  if (IS_STACK_FRAMES) {
-    // No implementation for finding out the stack frame sizes yet.
-    memset(sizes, 0, sizeof(*sizes) * result_count);
-  }
-  if (min_dropped_frames != nullptr) {
-    if (size - skip_count - max_depth > 0) {
-      *min_dropped_frames = size - skip_count - max_depth;
-    } else {
-      *min_dropped_frames = 0;
-    }
-  }
-
-  --recursive;
-
-  return result_count;
-}
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-bool StackTraceWorksForTest() { return true; }
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+// Copyright 2017 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. 
+// 
+// Portable implementation - just use glibc 
+// 
+// Note:  The glibc implementation may cause a call to malloc. 
+// This can cause a deadlock in HeapProfiler. 
+ 
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ 
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ 
+ 
+#error #include <emscripten.h> 
+ 
+#include <atomic> 
+#include <cstring> 
+ 
+#include "y_absl/base/attributes.h" 
+#include "y_absl/debugging/stacktrace.h" 
+ 
+extern "C" { 
+uintptr_t emscripten_stack_snapshot(); 
+uint32_t emscripten_stack_unwind_buffer(uintptr_t pc, void *buffer, 
+                                        uint32_t depth); 
+} 
+ 
+// Sometimes, we can try to get a stack trace from within a stack 
+// trace, which can cause a self-deadlock. 
+// Protect against such reentrant call by failing to get a stack trace. 
+// 
+// We use __thread here because the code here is extremely low level -- it is 
+// called while collecting stack traces from within malloc and mmap, and thus 
+// can not call anything which might call malloc or mmap itself. 
+static __thread int recursive = 0; 
+ 
+// The stack trace function might be invoked very early in the program's 
+// execution (e.g. from the very first malloc). 
+// As such, we suppress usage of backtrace during this early stage of execution. 
+static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy. 
+// Waiting until static initializers run seems to be late enough. 
+// This file is included into stacktrace.cc so this will only run once. 
+ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() { 
+  // Check if we can even create stacktraces. If not, bail early and leave 
+  // disable_stacktraces set as-is. 
+  // clang-format off 
+  if (!EM_ASM_INT({ return (typeof wasmOffsetConverter !== 'undefined'); })) { 
+    return 0; 
+  } 
+  // clang-format on 
+  disable_stacktraces.store(false, std::memory_order_relaxed); 
+  return 0; 
+}(); 
+ 
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> 
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, 
+                      const void *ucp, int *min_dropped_frames) { 
+  if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) { 
+    return 0; 
+  } 
+  ++recursive; 
+ 
+  static_cast<void>(ucp);  // Unused. 
+  constexpr int kStackLength = 64; 
+  void *stack[kStackLength]; 
+ 
+  int size; 
+  uintptr_t pc = emscripten_stack_snapshot(); 
+  size = emscripten_stack_unwind_buffer(pc, stack, kStackLength); 
+ 
+  int result_count = size - skip_count; 
+  if (result_count < 0) result_count = 0; 
+  if (result_count > max_depth) result_count = max_depth; 
+  for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count]; 
+ 
+  if (IS_STACK_FRAMES) { 
+    // No implementation for finding out the stack frame sizes yet. 
+    memset(sizes, 0, sizeof(*sizes) * result_count); 
+  } 
+  if (min_dropped_frames != nullptr) { 
+    if (size - skip_count - max_depth > 0) { 
+      *min_dropped_frames = size - skip_count - max_depth; 
+    } else { 
+      *min_dropped_frames = 0; 
+    } 
+  } 
+ 
+  --recursive; 
+ 
+  return result_count; 
+} 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace debugging_internal { 
+bool StackTraceWorksForTest() { return true; } 
+}  // namespace debugging_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
index 8571c8cbfd..f65ea7f507 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
@@ -1,234 +1,234 @@
-// 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.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
-
-// Generate stack trace for riscv
-
-#include <sys/ucontext.h>
-
-#include "y_absl/base/config.h"
-#if defined(__linux__)
-#include <sys/mman.h>
-#include <ucontext.h>
-#include <unistd.h>
-#endif
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <iostream>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/debugging/internal/address_is_readable.h"
-#include "y_absl/debugging/internal/vdso_support.h"
-#include "y_absl/debugging/stacktrace.h"
-
-static const uintptr_t kUnknownFrameSize = 0;
-
-#if defined(__linux__)
-// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
-static const unsigned char *GetKernelRtSigreturnAddress() {
-  constexpr uintptr_t kImpossibleAddress = 0;
-  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
-  uintptr_t address = memoized.load(std::memory_order_relaxed);
-  if (address != kImpossibleAddress) {
-    return reinterpret_cast<const unsigned char *>(address);
-  }
-
-  address = reinterpret_cast<uintptr_t>(nullptr);
-
-#if ABSL_HAVE_VDSO_SUPPORT
-  y_absl::debugging_internal::VDSOSupport vdso;
-  if (vdso.IsPresent()) {
-    y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
-    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10.
-    auto lookup = [&](int type) {
-      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_4.15", type,
-                               &symbol_info);
-    };
-    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
-        symbol_info.address == nullptr) {
-      // Unexpected: VDSO is present, yet the expected symbol is missing or
-      // null.
-      assert(false && "VDSO is present, but doesn't have expected symbol");
-    } else {
-      if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
-          kImpossibleAddress) {
-        address = reinterpret_cast<uintptr_t>(symbol_info.address);
-      } else {
-        assert(false && "VDSO returned invalid address");
-      }
-    }
-  }
-#endif
-
-  memoized.store(address, std::memory_order_relaxed);
-  return reinterpret_cast<const unsigned char *>(address);
-}
-#endif  // __linux__
-
-// Compute the size of a stack frame in [low..high).  We assume that low < high.
-// Return size of kUnknownFrameSize.
-template <typename T>
-static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) {
-  const char *low_char_ptr = reinterpret_cast<const char *>(low);
-  const char *high_char_ptr = reinterpret_cast<const char *>(high);
-  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize;
-}
-
-// Given a pointer to a stack frame, locate and return the calling stackframe,
-// or return null if no stackframe can be found. Perform sanity checks (the
-// strictness of which is controlled by the boolean parameter
-// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
-template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
-  //               .
-  //               .
-  //               .
-  //   +-> +----------------+
-  //   |   | return address |
-  //   |   |   previous fp  |
-  //   |   |      ...       |
-  //   |   +----------------+ <-+
-  //   |   | return address |   |
-  //   +---|-  previous fp  |   |
-  //       |      ...       |   |
-  // $fp ->|----------------+   |
-  //       | return address |   |
-  //       |   previous fp -|---+
-  // $sp ->|      ...       |
-  //       +----------------+
-  void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]);
-  bool check_frame_size = true;
-
-#if defined(__linux__)
-  if (WITH_CONTEXT && uc != nullptr) {
-    // Check to see if next frame's return address is __kernel_rt_sigreturn.
-    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) {
-      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
-      // old_frame_pointer is not suitable for unwinding, look at ucontext to
-      // discover frame pointer before signal.
-      //
-      // RISCV ELF psABI has the frame pointer at x8/fp/s0.
-      // -- RISCV psABI Table 18.2
-      void **const pre_signal_frame_pointer =
-          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]);
-
-      // Check the alleged frame pointer is actually readable. This is to
-      // prevent "double fault" in case we hit the first fault due to stack
-      // corruption.
-      if (!y_absl::debugging_internal::AddressIsReadable(
-              pre_signal_frame_pointer))
-        return nullptr;
-
-      // Alleged frame pointer is readable, use it for further unwinding.
-      new_frame_pointer = pre_signal_frame_pointer;
-
-      // Skip frame size check if we return from a signal.  We may be using an
-      // alterate stack for signals.
-      check_frame_size = false;
-    }
-  }
-#endif
-
-  // The RISCV ELF psABI mandates that the stack pointer is always 16-byte
-  // aligned.
-  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte
-  // alignment.
-  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
-    return nullptr;
-
-  // Check frame size.  In strict mode, we assume frames to be under 100,000
-  // bytes.  In non-strict mode, we relax the limit to 1MB.
-  if (check_frame_size) {
-    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
-    const uintptr_t frame_size =
-        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
-    if (frame_size == kUnknownFrameSize || frame_size > max_size)
-      return nullptr;
-  }
-
-  return new_frame_pointer;
-}
-
-template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
-#if defined(__GNUC__)
-  void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0));
-#else
-#error reading stack pointer not yet supported on this platform
-#endif
-
-  skip_count++;  // Skip the frame for this function.
-  int n = 0;
-
-  // The `frame_pointer` that is computed here points to the top of the frame.
-  // The two words preceding the address are the return address and the previous
-  // frame pointer.  To find a PC value associated with the current frame, we
-  // need to go down a level in the call chain.  So we remember the return
-  // address of the last frame seen.  This does not work for the first stack
-  // frame, which belongs to `UnwindImp()` but we skip the frame for
-  // `UnwindImp()` anyway.
-  void *prev_return_address = nullptr;
-
-  while (frame_pointer && n < max_depth) {
-    // The y_absl::GetStackFrames routine si called when we are in some
-    // informational context (the failure signal handler for example).  Use the
-    // non-strict unwinding rules to produce a stack trace that is as complete
-    // as possible (even if it contains a few bogus entries in some rare cases).
-    void **next_frame_pointer =
-        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
-
-    if (skip_count > 0) {
-      skip_count--;
-    } else {
-      result[n] = prev_return_address;
-      if (IS_STACK_FRAMES) {
-        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
-      }
-      n++;
-    }
-    prev_return_address = frame_pointer[-1];
-    frame_pointer = next_frame_pointer;
-  }
-  if (min_dropped_frames != nullptr) {
-    // Implementation detail: we clamp the max of frames we are willing to
-    // count, so as not to spend too much time in the loop below.
-    const int kMaxUnwind = 200;
-    int j = 0;
-    for (; frame_pointer != nullptr && j < kMaxUnwind; j++) {
-      frame_pointer =
-          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
-    }
-    *min_dropped_frames = j;
-  }
-  return n;
-}
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-bool StackTraceWorksForTest() { return true; }
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif
+// 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. 
+ 
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ 
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ 
+ 
+// Generate stack trace for riscv 
+ 
+#include <sys/ucontext.h> 
+ 
+#include "y_absl/base/config.h" 
+#if defined(__linux__) 
+#include <sys/mman.h> 
+#include <ucontext.h> 
+#include <unistd.h> 
+#endif 
+ 
+#include <atomic> 
+#include <cassert> 
+#include <cstdint> 
+#include <iostream> 
+ 
+#include "y_absl/base/attributes.h" 
+#include "y_absl/debugging/internal/address_is_readable.h" 
+#include "y_absl/debugging/internal/vdso_support.h" 
+#include "y_absl/debugging/stacktrace.h" 
+ 
+static const uintptr_t kUnknownFrameSize = 0; 
+ 
+#if defined(__linux__) 
+// Returns the address of the VDSO __kernel_rt_sigreturn function, if present. 
+static const unsigned char *GetKernelRtSigreturnAddress() { 
+  constexpr uintptr_t kImpossibleAddress = 0; 
+  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress); 
+  uintptr_t address = memoized.load(std::memory_order_relaxed); 
+  if (address != kImpossibleAddress) { 
+    return reinterpret_cast<const unsigned char *>(address); 
+  } 
+ 
+  address = reinterpret_cast<uintptr_t>(nullptr); 
+ 
+#if ABSL_HAVE_VDSO_SUPPORT 
+  y_absl::debugging_internal::VDSOSupport vdso; 
+  if (vdso.IsPresent()) { 
+    y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; 
+    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10. 
+    auto lookup = [&](int type) { 
+      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_4.15", type, 
+                               &symbol_info); 
+    }; 
+    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) || 
+        symbol_info.address == nullptr) { 
+      // Unexpected: VDSO is present, yet the expected symbol is missing or 
+      // null. 
+      assert(false && "VDSO is present, but doesn't have expected symbol"); 
+    } else { 
+      if (reinterpret_cast<uintptr_t>(symbol_info.address) != 
+          kImpossibleAddress) { 
+        address = reinterpret_cast<uintptr_t>(symbol_info.address); 
+      } else { 
+        assert(false && "VDSO returned invalid address"); 
+      } 
+    } 
+  } 
+#endif 
+ 
+  memoized.store(address, std::memory_order_relaxed); 
+  return reinterpret_cast<const unsigned char *>(address); 
+} 
+#endif  // __linux__ 
+ 
+// Compute the size of a stack frame in [low..high).  We assume that low < high. 
+// Return size of kUnknownFrameSize. 
+template <typename T> 
+static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) { 
+  const char *low_char_ptr = reinterpret_cast<const char *>(low); 
+  const char *high_char_ptr = reinterpret_cast<const char *>(high); 
+  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize; 
+} 
+ 
+// Given a pointer to a stack frame, locate and return the calling stackframe, 
+// or return null if no stackframe can be found. Perform sanity checks (the 
+// strictness of which is controlled by the boolean parameter 
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. 
+template <bool STRICT_UNWINDING, bool WITH_CONTEXT> 
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
+static void ** NextStackFrame(void **old_frame_pointer, const void *uc) { 
+  //               . 
+  //               . 
+  //               . 
+  //   +-> +----------------+ 
+  //   |   | return address | 
+  //   |   |   previous fp  | 
+  //   |   |      ...       | 
+  //   |   +----------------+ <-+ 
+  //   |   | return address |   | 
+  //   +---|-  previous fp  |   | 
+  //       |      ...       |   | 
+  // $fp ->|----------------+   | 
+  //       | return address |   | 
+  //       |   previous fp -|---+ 
+  // $sp ->|      ...       | 
+  //       +----------------+ 
+  void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]); 
+  bool check_frame_size = true; 
+ 
+#if defined(__linux__) 
+  if (WITH_CONTEXT && uc != nullptr) { 
+    // Check to see if next frame's return address is __kernel_rt_sigreturn. 
+    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) { 
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc); 
+      // old_frame_pointer is not suitable for unwinding, look at ucontext to 
+      // discover frame pointer before signal. 
+      // 
+      // RISCV ELF psABI has the frame pointer at x8/fp/s0. 
+      // -- RISCV psABI Table 18.2 
+      void **const pre_signal_frame_pointer = 
+          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]); 
+ 
+      // Check the alleged frame pointer is actually readable. This is to 
+      // prevent "double fault" in case we hit the first fault due to stack 
+      // corruption. 
+      if (!y_absl::debugging_internal::AddressIsReadable( 
+              pre_signal_frame_pointer)) 
+        return nullptr; 
+ 
+      // Alleged frame pointer is readable, use it for further unwinding. 
+      new_frame_pointer = pre_signal_frame_pointer; 
+ 
+      // Skip frame size check if we return from a signal.  We may be using an 
+      // alterate stack for signals. 
+      check_frame_size = false; 
+    } 
+  } 
+#endif 
+ 
+  // The RISCV ELF psABI mandates that the stack pointer is always 16-byte 
+  // aligned. 
+  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte 
+  // alignment. 
+  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0) 
+    return nullptr; 
+ 
+  // Check frame size.  In strict mode, we assume frames to be under 100,000 
+  // bytes.  In non-strict mode, we relax the limit to 1MB. 
+  if (check_frame_size) { 
+    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000; 
+    const uintptr_t frame_size = 
+        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer); 
+    if (frame_size == kUnknownFrameSize || frame_size > max_size) 
+      return nullptr; 
+  } 
+ 
+  return new_frame_pointer; 
+} 
+ 
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> 
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, 
+                      const void *ucp, int *min_dropped_frames) { 
+#if defined(__GNUC__) 
+  void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0)); 
+#else 
+#error reading stack pointer not yet supported on this platform 
+#endif 
+ 
+  skip_count++;  // Skip the frame for this function. 
+  int n = 0; 
+ 
+  // The `frame_pointer` that is computed here points to the top of the frame. 
+  // The two words preceding the address are the return address and the previous 
+  // frame pointer.  To find a PC value associated with the current frame, we 
+  // need to go down a level in the call chain.  So we remember the return 
+  // address of the last frame seen.  This does not work for the first stack 
+  // frame, which belongs to `UnwindImp()` but we skip the frame for 
+  // `UnwindImp()` anyway. 
+  void *prev_return_address = nullptr; 
+ 
+  while (frame_pointer && n < max_depth) { 
+    // The y_absl::GetStackFrames routine si called when we are in some 
+    // informational context (the failure signal handler for example).  Use the 
+    // non-strict unwinding rules to produce a stack trace that is as complete 
+    // as possible (even if it contains a few bogus entries in some rare cases). 
+    void **next_frame_pointer = 
+        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp); 
+ 
+    if (skip_count > 0) { 
+      skip_count--; 
+    } else { 
+      result[n] = prev_return_address; 
+      if (IS_STACK_FRAMES) { 
+        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer); 
+      } 
+      n++; 
+    } 
+    prev_return_address = frame_pointer[-1]; 
+    frame_pointer = next_frame_pointer; 
+  } 
+  if (min_dropped_frames != nullptr) { 
+    // Implementation detail: we clamp the max of frames we are willing to 
+    // count, so as not to spend too much time in the loop below. 
+    const int kMaxUnwind = 200; 
+    int j = 0; 
+    for (; frame_pointer != nullptr && j < kMaxUnwind; j++) { 
+      frame_pointer = 
+          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp); 
+    } 
+    *min_dropped_frames = j; 
+  } 
+  return n; 
+} 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace debugging_internal { 
+bool StackTraceWorksForTest() { return true; } 
+}  // namespace debugging_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
index 8936f8ca70..9348161a6c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
@@ -27,7 +27,7 @@
 
 #include <cassert>
 #include <cstdint>
-#include <limits>
+#include <limits> 
 
 #include "y_absl/base/macros.h"
 #include "y_absl/base/port.h"
@@ -133,8 +133,8 @@ static uintptr_t GetFP(const void *vuc) {
     const uintptr_t bp = 0;
     const uintptr_t sp = 0;
 #endif
-    // Sanity-check that the base pointer is valid. It's possible that some
-    // code in the process is compiled with --copt=-fomit-frame-pointer or
+    // Sanity-check that the base pointer is valid. It's possible that some 
+    // code in the process is compiled with --copt=-fomit-frame-pointer or 
     // --copt=-momit-leaf-frame-pointer.
     //
     // TODO(bcmills): -momit-leaf-frame-pointer is currently the default
@@ -159,8 +159,8 @@ static uintptr_t GetFP(const void *vuc) {
 template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static void **NextStackFrame(void **old_fp, const void *uc,
-                             size_t stack_low, size_t stack_high) {
+static void **NextStackFrame(void **old_fp, const void *uc, 
+                             size_t stack_low, size_t stack_high) { 
   void **new_fp = (void **)*old_fp;
 
 #if defined(__linux__) && defined(__i386__)
@@ -248,7 +248,7 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   // using an alternate signal stack.
   //
   // TODO(bcmills): The GetFP call should be completely unnecessary when
-  // ENABLE_COMBINED_UNWINDER is set (because we should be back in the thread's
+  // ENABLE_COMBINED_UNWINDER is set (because we should be back in the thread's 
   // stack by this point), but it is empirically still needed (e.g. when the
   // stack includes a call to abort).  unw_get_reg returns UNW_EBADREG for some
   // frames.  Figure out why GetValidFrameAddr and/or libunwind isn't doing what
@@ -259,18 +259,18 @@ static void **NextStackFrame(void **old_fp, const void *uc,
     // at a greater address that the current one.
     if (new_fp_u <= old_fp_u) return nullptr;
     if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr;
-
-    if (stack_low < old_fp_u && old_fp_u <= stack_high) {
-      // Old BP was in the expected stack region...
-      if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
-        // ... but new BP is outside of expected stack region.
-        // It is most likely bogus.
-        return nullptr;
-      }
-    } else {
-      // We may be here if we are executing in a co-routine with a
-      // separate stack. We can't do safety checks in this case.
-    }
+ 
+    if (stack_low < old_fp_u && old_fp_u <= stack_high) { 
+      // Old BP was in the expected stack region... 
+      if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) { 
+        // ... but new BP is outside of expected stack region. 
+        // It is most likely bogus. 
+        return nullptr; 
+      } 
+    } else { 
+      // We may be here if we are executing in a co-routine with a 
+      // separate stack. We can't do safety checks in this case. 
+    } 
   } else {
     if (new_fp == nullptr) return nullptr;  // skip AddressIsReadable() below
     // In the non-strict mode, allow discontiguous stack frames.
@@ -310,17 +310,17 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
   int n = 0;
   void **fp = reinterpret_cast<void **>(__builtin_frame_address(0));
 
-  size_t stack_low = getpagesize();  // Assume that the first page is not stack.
-  size_t stack_high = std::numeric_limits<size_t>::max() - sizeof(void *);
-
+  size_t stack_low = getpagesize();  // Assume that the first page is not stack. 
+  size_t stack_high = std::numeric_limits<size_t>::max() - sizeof(void *); 
+ 
   while (fp && n < max_depth) {
     if (*(fp + 1) == reinterpret_cast<void *>(0)) {
       // In 64-bit code, we often see a frame that
       // points to itself and has a return address of 0.
       break;
     }
-    void **next_fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(
-        fp, ucp, stack_low, stack_high);
+    void **next_fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>( 
+        fp, ucp, stack_low, stack_high); 
     if (skip_count > 0) {
       skip_count--;
     } else {
@@ -343,8 +343,8 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
     const int kMaxUnwind = 1000;
     int j = 0;
     for (; fp != nullptr && j < kMaxUnwind; j++) {
-      fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp, stack_low,
-                                                             stack_high);
+      fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp, stack_low, 
+                                                             stack_high); 
     }
     *min_dropped_frames = j;
   }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
index e6e2b0724a..b9baf92d1a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
@@ -28,8 +28,8 @@
 
 #ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
-#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
-      && !defined(__asmjs__) && !defined(__wasm__)
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \ 
+      && !defined(__asmjs__) && !defined(__wasm__) 
 #define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
 
 #include <elf.h>
@@ -68,12 +68,12 @@ ABSL_NAMESPACE_END
 #define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE
-#error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set
-#elif defined(__EMSCRIPTEN__)
-#define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1
-#endif
-
+#ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 
+#error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set 
+#elif defined(__EMSCRIPTEN__) 
+#define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1 
+#endif 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
index 7905eba32f..451be5fde1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
@@ -20,25 +20,25 @@
 
 #ifdef ABSL_HAVE_VDSO_SUPPORT     // defined in vdso_support.h
 
-#if !defined(__has_include)
-#define __has_include(header) 0
-#endif
-
+#if !defined(__has_include) 
+#define __has_include(header) 0 
+#endif 
+ 
 #include <errno.h>
 #include <fcntl.h>
-#if __has_include(<syscall.h>)
-#include <syscall.h>
-#elif __has_include(<sys/syscall.h>)
+#if __has_include(<syscall.h>) 
+#include <syscall.h> 
+#elif __has_include(<sys/syscall.h>) 
 #include <sys/syscall.h>
-#endif
+#endif 
 #include <unistd.h>
 
-#if defined(__GLIBC__) && \
-    (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
-#define ABSL_HAVE_GETAUXVAL
-#endif
-
-#ifdef ABSL_HAVE_GETAUXVAL
+#if defined(__GLIBC__) && \ 
+    (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16)) 
+#define ABSL_HAVE_GETAUXVAL 
+#endif 
+ 
+#ifdef ABSL_HAVE_GETAUXVAL 
 #include <sys/auxv.h>
 #endif
 
@@ -50,11 +50,11 @@
 #define AT_SYSINFO_EHDR 33  // for crosstoolv10
 #endif
 
-#if defined(__FreeBSD__)
-using Elf64_auxv_t = Elf64_Auxinfo;
-using Elf32_auxv_t = Elf32_Auxinfo;
-#endif
-
+#if defined(__FreeBSD__) 
+using Elf64_auxv_t = Elf64_Auxinfo; 
+using Elf32_auxv_t = Elf32_Auxinfo; 
+#endif 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
@@ -83,7 +83,7 @@ VDSOSupport::VDSOSupport()
 // the operation should be idempotent.
 const void *VDSOSupport::Init() {
   const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase;
-#ifdef ABSL_HAVE_GETAUXVAL
+#ifdef ABSL_HAVE_GETAUXVAL 
   if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
     errno = 0;
     const void *const sysinfo_ehdr =
@@ -92,7 +92,7 @@ const void *VDSOSupport::Init() {
       vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed);
     }
   }
-#endif  // ABSL_HAVE_GETAUXVAL
+#endif  // ABSL_HAVE_GETAUXVAL 
   if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
     int fd = open("/proc/self/auxv", O_RDONLY);
     if (fd == -1) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
index e07162537b..2fdd0c721e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
@@ -9,22 +9,22 @@ OWNER(
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
-    contrib/restricted/abseil-cpp-tstring/y_absl/debugging
-    contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
-    contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
-    contrib/restricted/abseil-cpp-tstring/y_absl/demangle
+    contrib/restricted/abseil-cpp-tstring/y_absl/debugging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace 
+    contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize 
+    contrib/restricted/abseil-cpp-tstring/y_absl/demangle 
     contrib/restricted/abseil-cpp-tstring/y_absl/numeric
     contrib/restricted/abseil-cpp-tstring/y_absl/strings
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal 
 )
 
 ADDINCL(
@@ -34,7 +34,7 @@ ADDINCL(
 NO_COMPILER_WARNINGS()
 
 SRCS(
-    examine_stack.cc
+    examine_stack.cc 
 )
 
 END()