Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.

24 files changed, 2181 insertions, 2181 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/src/support/ibm/mbsnrtowcs.cpp b/contrib/libs/cxxsupp/libcxx/src/support/ibm/mbsnrtowcs.cpp
index 125bdbea1c..fc1bdead17 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/ibm/mbsnrtowcs.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/ibm/mbsnrtowcs.cpp
@@ -1,95 +1,95 @@
-//===----------------------- mbsnrtowcs.cpp -------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstddef> // size_t
-#include <cwchar>  // mbstate_t
-#include <limits.h> // MB_LEN_MAX
-#include <string.h> // wmemcpy
-
-// Returns the number of wide characters found in the multi byte sequence `src`
-// (of `src_size_bytes`), that fit in the buffer `dst` (of `max_dest_chars`
-// elements size). The count returned excludes the null terminator.
-// When `dst` is NULL, no characters are copied to `dst`.
-// Returns (size_t) -1 when an invalid sequence is encountered.
-// Leaves *`src` pointing to the next character to convert or NULL
-// if a null character was converted from *`src`.
-_LIBCPP_FUNC_VIS
-size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
-                   size_t src_size_bytes, size_t max_dest_chars,
-                   mbstate_t *__restrict ps) {
-  const size_t terminated_sequence = static_cast<size_t>(0);
-  const size_t invalid_sequence = static_cast<size_t>(-1);
-  const size_t incomplete_sequence = static_cast<size_t>(-2);
-
-  size_t source_converted;
-  size_t dest_converted;
-  size_t result = 0;
-
-  // If `dst` is null then `max_dest_chars` should be ignored according to the
-  // standard. Setting `max_dest_chars` to a large value has this effect.
-  if (dst == nullptr)
-    max_dest_chars = static_cast<size_t>(-1);
-
-  for (dest_converted = source_converted = 0;
-       source_converted < src_size_bytes && (!dst || dest_converted < max_dest_chars);
-       ++dest_converted, source_converted += result) {
-    // Converts one multi byte character.
-    // If result (char_size) is greater than 0, it's the size in bytes of that character.
-    // If result (char_size) is zero, it indicates that the null character has been found.
-    // Otherwise, it's an error and errno may be set.
-    size_t source_remaining = src_size_bytes - source_converted;
-    size_t dest_remaining = max_dest_chars - dest_converted;
-
-    if (dst == nullptr) {
-      result = mbrtowc(NULL, *src + source_converted, source_remaining, ps);
-    } else if (dest_remaining >= source_remaining) {
-      // dst has enough space to translate in-place.
-      result = mbrtowc(dst + dest_converted, *src + source_converted, source_remaining, ps);
-    } else {
-      /*
-      * dst may not have enough space, so use a temporary buffer.
-      *
-      * We need to save a copy of the conversion state
-      * here so we can restore it if the multibyte
-      * character is too long for the buffer.
-      */
-      wchar_t buff[MB_LEN_MAX];
-      mbstate_t mbstate_tmp;
-
-      if (ps != nullptr)
-        mbstate_tmp = *ps;
-      result = mbrtowc(buff, *src + source_converted, source_remaining, ps);
-
-      if (result > dest_remaining) {
-        // Multi-byte sequence for character won't fit.
-        if (ps != nullptr)
-          *ps = mbstate_tmp;
-        break;
-      } else {
-        // The buffer was used, so we need copy the translation to dst.
-        wmemcpy(dst, buff, result);
-      }
-    }
-
-    // Don't do anything to change errno from here on.
-    if (result == invalid_sequence || result == terminated_sequence || result == incomplete_sequence) {
-      break;
-    }
-  }
-
-  if (dst) {
-    if (result == terminated_sequence)
-      *src = NULL;
-    else
-      *src += source_converted;
-  }
-  if (result == invalid_sequence)
-    return invalid_sequence;
-
-  return dest_converted;
-}
+//===----------------------- mbsnrtowcs.cpp -------------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <cstddef> // size_t 
+#include <cwchar>  // mbstate_t 
+#include <limits.h> // MB_LEN_MAX 
+#include <string.h> // wmemcpy 
+ 
+// Returns the number of wide characters found in the multi byte sequence `src` 
+// (of `src_size_bytes`), that fit in the buffer `dst` (of `max_dest_chars` 
+// elements size). The count returned excludes the null terminator. 
+// When `dst` is NULL, no characters are copied to `dst`. 
+// Returns (size_t) -1 when an invalid sequence is encountered. 
+// Leaves *`src` pointing to the next character to convert or NULL 
+// if a null character was converted from *`src`. 
+_LIBCPP_FUNC_VIS 
+size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src, 
+                   size_t src_size_bytes, size_t max_dest_chars, 
+                   mbstate_t *__restrict ps) { 
+  const size_t terminated_sequence = static_cast<size_t>(0); 
+  const size_t invalid_sequence = static_cast<size_t>(-1); 
+  const size_t incomplete_sequence = static_cast<size_t>(-2); 
+ 
+  size_t source_converted; 
+  size_t dest_converted; 
+  size_t result = 0; 
+ 
+  // If `dst` is null then `max_dest_chars` should be ignored according to the 
+  // standard. Setting `max_dest_chars` to a large value has this effect. 
+  if (dst == nullptr) 
+    max_dest_chars = static_cast<size_t>(-1); 
+ 
+  for (dest_converted = source_converted = 0; 
+       source_converted < src_size_bytes && (!dst || dest_converted < max_dest_chars); 
+       ++dest_converted, source_converted += result) { 
+    // Converts one multi byte character. 
+    // If result (char_size) is greater than 0, it's the size in bytes of that character. 
+    // If result (char_size) is zero, it indicates that the null character has been found. 
+    // Otherwise, it's an error and errno may be set. 
+    size_t source_remaining = src_size_bytes - source_converted; 
+    size_t dest_remaining = max_dest_chars - dest_converted; 
+ 
+    if (dst == nullptr) { 
+      result = mbrtowc(NULL, *src + source_converted, source_remaining, ps); 
+    } else if (dest_remaining >= source_remaining) { 
+      // dst has enough space to translate in-place. 
+      result = mbrtowc(dst + dest_converted, *src + source_converted, source_remaining, ps); 
+    } else { 
+      /* 
+      * dst may not have enough space, so use a temporary buffer. 
+      * 
+      * We need to save a copy of the conversion state 
+      * here so we can restore it if the multibyte 
+      * character is too long for the buffer. 
+      */ 
+      wchar_t buff[MB_LEN_MAX]; 
+      mbstate_t mbstate_tmp; 
+ 
+      if (ps != nullptr) 
+        mbstate_tmp = *ps; 
+      result = mbrtowc(buff, *src + source_converted, source_remaining, ps); 
+ 
+      if (result > dest_remaining) { 
+        // Multi-byte sequence for character won't fit. 
+        if (ps != nullptr) 
+          *ps = mbstate_tmp; 
+        break; 
+      } else { 
+        // The buffer was used, so we need copy the translation to dst. 
+        wmemcpy(dst, buff, result); 
+      } 
+    } 
+ 
+    // Don't do anything to change errno from here on. 
+    if (result == invalid_sequence || result == terminated_sequence || result == incomplete_sequence) { 
+      break; 
+    } 
+  } 
+ 
+  if (dst) { 
+    if (result == terminated_sequence) 
+      *src = NULL; 
+    else 
+      *src += source_converted; 
+  } 
+  if (result == invalid_sequence) 
+    return invalid_sequence; 
+ 
+  return dest_converted; 
+} 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/ibm/wcsnrtombs.cpp b/contrib/libs/cxxsupp/libcxx/src/support/ibm/wcsnrtombs.cpp
index 01c6241dc5..6497fb7b98 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/ibm/wcsnrtombs.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/ibm/wcsnrtombs.cpp
@@ -1,93 +1,93 @@
-//===----------------------- wcsnrtombs.cpp -------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cwchar>  // mbstate_t
-#include <limits.h> // MB_LEN_MAX
-#include <stdlib.h> // MB_CUR_MAX, size_t
-#include <string.h> // memcpy
-
-// Converts `max_source_chars` from the wide character buffer pointer to by *`src`,
-// into the multi byte character sequence buffer stored at `dst`, which must be
-// `dst_size_bytes` bytes in size. Returns the number of bytes in the sequence
-// converted from *src, excluding the null terminator.
-// Returns (size_t) -1 if an error occurs and sets errno.
-// If `dst` is NULL, `dst_size_bytes` is ignored and no bytes are copied to `dst`.
-_LIBCPP_FUNC_VIS
-size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
-                   size_t max_source_chars, size_t dst_size_bytes,
-                   mbstate_t *__restrict ps) {
-
-  const size_t invalid_wchar = static_cast<size_t>(-1);
-
-  size_t source_converted;
-  size_t dest_converted;
-  size_t result = 0;
-
-  // If `dst` is null then `dst_size_bytes` should be ignored according to the
-  // standard. Setting dst_size_bytes to a large value has this effect.
-  if (dst == nullptr)
-    dst_size_bytes = static_cast<size_t>(-1);
-
-  for (dest_converted = source_converted = 0;
-       source_converted < max_source_chars && (!dst || dest_converted < dst_size_bytes);
-       ++source_converted, dest_converted += result) {
-    wchar_t c = (*src)[source_converted];
-    size_t dest_remaining = dst_size_bytes - dest_converted;
-
-    if (dst == nullptr) {
-      result = wcrtomb(NULL, c, ps);
-    } else if (dest_remaining >= static_cast<size_t>(MB_CUR_MAX)) {
-      // dst has enough space to translate in-place.
-      result = wcrtomb(dst + dest_converted, c, ps);
-    } else {
-      /*
-      * dst may not have enough space, so use a temporary buffer.
-      *
-      * We need to save a copy of the conversion state
-      * here so we can restore it if the multibyte
-      * character is too long for the buffer.
-      */
-      char buff[MB_LEN_MAX];
-      mbstate_t mbstate_tmp;
-
-      if (ps != nullptr)
-        mbstate_tmp = *ps;
-      result = wcrtomb(buff, c, ps);
-
-      if (result > dest_remaining) {
-        // Multi-byte sequence for character won't fit.
-        if (ps != nullptr)
-          *ps = mbstate_tmp;
-        if (result != invalid_wchar)
-          break;
-      } else {
-        // The buffer was used, so we need copy the translation to dst.
-        memcpy(dst, buff, result);
-      }
-    }
-
-    // result (char_size) contains the size of the multi-byte-sequence converted.
-    // Otherwise, result (char_size) is (size_t) -1 and wcrtomb() sets the errno.
-    if (result == invalid_wchar) {
-      if (dst)
-        *src = *src + source_converted;
-      return invalid_wchar;
-    }
-
-    if (c == L'\0') {
-      if (dst)
-        *src = NULL;
-      return dest_converted;
-    }
-  }
-
-  if (dst)
-    *src = *src + source_converted;
-
-  return dest_converted;
-}
+//===----------------------- wcsnrtombs.cpp -------------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <cwchar>  // mbstate_t 
+#include <limits.h> // MB_LEN_MAX 
+#include <stdlib.h> // MB_CUR_MAX, size_t 
+#include <string.h> // memcpy 
+ 
+// Converts `max_source_chars` from the wide character buffer pointer to by *`src`, 
+// into the multi byte character sequence buffer stored at `dst`, which must be 
+// `dst_size_bytes` bytes in size. Returns the number of bytes in the sequence 
+// converted from *src, excluding the null terminator. 
+// Returns (size_t) -1 if an error occurs and sets errno. 
+// If `dst` is NULL, `dst_size_bytes` is ignored and no bytes are copied to `dst`. 
+_LIBCPP_FUNC_VIS 
+size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src, 
+                   size_t max_source_chars, size_t dst_size_bytes, 
+                   mbstate_t *__restrict ps) { 
+ 
+  const size_t invalid_wchar = static_cast<size_t>(-1); 
+ 
+  size_t source_converted; 
+  size_t dest_converted; 
+  size_t result = 0; 
+ 
+  // If `dst` is null then `dst_size_bytes` should be ignored according to the 
+  // standard. Setting dst_size_bytes to a large value has this effect. 
+  if (dst == nullptr) 
+    dst_size_bytes = static_cast<size_t>(-1); 
+ 
+  for (dest_converted = source_converted = 0; 
+       source_converted < max_source_chars && (!dst || dest_converted < dst_size_bytes); 
+       ++source_converted, dest_converted += result) { 
+    wchar_t c = (*src)[source_converted]; 
+    size_t dest_remaining = dst_size_bytes - dest_converted; 
+ 
+    if (dst == nullptr) { 
+      result = wcrtomb(NULL, c, ps); 
+    } else if (dest_remaining >= static_cast<size_t>(MB_CUR_MAX)) { 
+      // dst has enough space to translate in-place. 
+      result = wcrtomb(dst + dest_converted, c, ps); 
+    } else { 
+      /* 
+      * dst may not have enough space, so use a temporary buffer. 
+      * 
+      * We need to save a copy of the conversion state 
+      * here so we can restore it if the multibyte 
+      * character is too long for the buffer. 
+      */ 
+      char buff[MB_LEN_MAX]; 
+      mbstate_t mbstate_tmp; 
+ 
+      if (ps != nullptr) 
+        mbstate_tmp = *ps; 
+      result = wcrtomb(buff, c, ps); 
+ 
+      if (result > dest_remaining) { 
+        // Multi-byte sequence for character won't fit. 
+        if (ps != nullptr) 
+          *ps = mbstate_tmp; 
+        if (result != invalid_wchar) 
+          break; 
+      } else { 
+        // The buffer was used, so we need copy the translation to dst. 
+        memcpy(dst, buff, result); 
+      } 
+    } 
+ 
+    // result (char_size) contains the size of the multi-byte-sequence converted. 
+    // Otherwise, result (char_size) is (size_t) -1 and wcrtomb() sets the errno. 
+    if (result == invalid_wchar) { 
+      if (dst) 
+        *src = *src + source_converted; 
+      return invalid_wchar; 
+    } 
+ 
+    if (c == L'\0') { 
+      if (dst) 
+        *src = NULL; 
+      return dest_converted; 
+    } 
+  } 
+ 
+  if (dst) 
+    *src = *src + source_converted; 
+ 
+  return dest_converted; 
+} 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/ibm/xlocale_zos.cpp b/contrib/libs/cxxsupp/libcxx/src/support/ibm/xlocale_zos.cpp
index 90c1ba95a3..7649ab0c9f 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/ibm/xlocale_zos.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/ibm/xlocale_zos.cpp
@@ -1,137 +1,137 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__support/ibm/xlocale.h>
-#include <sstream>
-#include <vector>
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-locale_t newlocale(int category_mask, const char* locale, locale_t base) {
-  // Maintain current locale name(s) to restore later.
-  std::string current_loc_name(setlocale(LC_ALL, 0));
-
-  // Check for errors.
-  if (category_mask == LC_ALL_MASK && setlocale(LC_ALL, locale) == NULL) {
-    errno = EINVAL;
-    return (locale_t)0;
-  } else {
-    for (int _Cat = 0; _Cat <= _LC_MAX; ++_Cat) {
-      if ((_CATMASK(_Cat) & category_mask) != 0 && setlocale(_Cat, locale) == NULL) {
-        setlocale(LC_ALL, current_loc_name.c_str());
-        errno = EINVAL;
-        return (locale_t)0;
-      }
-    }
-  }
-
-  // Create new locale.
-  locale_t newloc = new locale_struct();
-
-  if (base) {
-    if (category_mask != LC_ALL_MASK) {
-      // Copy base when it will not be overwritten.
-      memcpy(newloc, base, sizeof (locale_struct));
-      newloc->category_mask = category_mask | base->category_mask;
-    }
-    delete base;
-  } else {
-    newloc->category_mask = category_mask;
-  }
-
-  if (category_mask & LC_COLLATE_MASK)
-    newloc->lc_collate = locale;
-  if (category_mask & LC_CTYPE_MASK)
-    newloc->lc_ctype = locale;
-  if (category_mask & LC_MONETARY_MASK)
-    newloc->lc_monetary = locale;
-  if (category_mask & LC_NUMERIC_MASK)
-    newloc->lc_numeric = locale;
-  if (category_mask & LC_TIME_MASK)
-    newloc->lc_time = locale;
-  if (category_mask & LC_MESSAGES_MASK)
-    newloc->lc_messages = locale;
-
-  // Restore current locale.
-  setlocale(LC_ALL, current_loc_name.c_str());
-  return (locale_t)newloc;
-}
-
-void freelocale(locale_t locobj) {
-  delete locobj;
-}
-
-locale_t uselocale(locale_t newloc) {
-  // Maintain current locale name(s).
-  std::string current_loc_name(setlocale(LC_ALL, 0));
-
-  if (newloc) {
-    // Set locales and check for errors.
-    bool is_error =
-      (newloc->category_mask & LC_COLLATE_MASK &&
-        setlocale(LC_COLLATE, newloc->lc_collate.c_str()) == NULL) ||
-      (newloc->category_mask & LC_CTYPE_MASK &&
-        setlocale(LC_CTYPE, newloc->lc_ctype.c_str()) == NULL) ||
-      (newloc->category_mask & LC_MONETARY_MASK &&
-        setlocale(LC_MONETARY, newloc->lc_monetary.c_str()) == NULL) ||
-      (newloc->category_mask & LC_NUMERIC_MASK &&
-        setlocale(LC_NUMERIC, newloc->lc_numeric.c_str()) == NULL) ||
-      (newloc->category_mask & LC_TIME_MASK &&
-        setlocale(LC_TIME, newloc->lc_time.c_str()) == NULL) ||
-      (newloc->category_mask & LC_MESSAGES_MASK &&
-        setlocale(LC_MESSAGES, newloc->lc_messages.c_str()) == NULL);
-
-    if (is_error) {
-      setlocale(LC_ALL, current_loc_name.c_str());
-      errno = EINVAL;
-      return (locale_t)0;
-    }
-  }
-
-  // Construct and return previous locale.
-  locale_t previous_loc = new locale_struct();
-
-  // current_loc_name might be a comma-separated locale name list.
-  if (current_loc_name.find(',') != std::string::npos) {
-    // Tokenize locale name list.
-    const char delimiter = ',';
-    std::vector<std::string> tokenized;
-    std::stringstream ss(current_loc_name);
-    std::string s;
-
-    while (std::getline(ss, s, delimiter)) {
-        tokenized.push_back(s);
-    }
-
-    _LIBCPP_ASSERT(tokenized.size() >= _NCAT, "locale-name list is too short");
-
-    previous_loc->lc_collate = tokenized[LC_COLLATE];
-    previous_loc->lc_ctype = tokenized[LC_CTYPE];
-    previous_loc->lc_monetary = tokenized[LC_MONETARY];
-    previous_loc->lc_numeric = tokenized[LC_NUMERIC];
-    previous_loc->lc_time = tokenized[LC_TIME];
-    // Skip LC_TOD.
-    previous_loc->lc_messages = tokenized[LC_MESSAGES];
-  } else {
-    previous_loc->lc_collate = current_loc_name;
-    previous_loc->lc_ctype = current_loc_name;
-    previous_loc->lc_monetary = current_loc_name;
-    previous_loc->lc_numeric = current_loc_name;
-    previous_loc->lc_time = current_loc_name;
-    previous_loc->lc_messages = current_loc_name;
-  }
-
-  previous_loc->category_mask = LC_ALL_MASK;
-  return previous_loc;
-}
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
+//===----------------------------------------------------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <__support/ibm/xlocale.h> 
+#include <sstream> 
+#include <vector> 
+ 
+#ifdef __cplusplus 
+extern "C" { 
+#endif // __cplusplus 
+ 
+locale_t newlocale(int category_mask, const char* locale, locale_t base) { 
+  // Maintain current locale name(s) to restore later. 
+  std::string current_loc_name(setlocale(LC_ALL, 0)); 
+ 
+  // Check for errors. 
+  if (category_mask == LC_ALL_MASK && setlocale(LC_ALL, locale) == NULL) { 
+    errno = EINVAL; 
+    return (locale_t)0; 
+  } else { 
+    for (int _Cat = 0; _Cat <= _LC_MAX; ++_Cat) { 
+      if ((_CATMASK(_Cat) & category_mask) != 0 && setlocale(_Cat, locale) == NULL) { 
+        setlocale(LC_ALL, current_loc_name.c_str()); 
+        errno = EINVAL; 
+        return (locale_t)0; 
+      } 
+    } 
+  } 
+ 
+  // Create new locale. 
+  locale_t newloc = new locale_struct(); 
+ 
+  if (base) { 
+    if (category_mask != LC_ALL_MASK) { 
+      // Copy base when it will not be overwritten. 
+      memcpy(newloc, base, sizeof (locale_struct)); 
+      newloc->category_mask = category_mask | base->category_mask; 
+    } 
+    delete base; 
+  } else { 
+    newloc->category_mask = category_mask; 
+  } 
+ 
+  if (category_mask & LC_COLLATE_MASK) 
+    newloc->lc_collate = locale; 
+  if (category_mask & LC_CTYPE_MASK) 
+    newloc->lc_ctype = locale; 
+  if (category_mask & LC_MONETARY_MASK) 
+    newloc->lc_monetary = locale; 
+  if (category_mask & LC_NUMERIC_MASK) 
+    newloc->lc_numeric = locale; 
+  if (category_mask & LC_TIME_MASK) 
+    newloc->lc_time = locale; 
+  if (category_mask & LC_MESSAGES_MASK) 
+    newloc->lc_messages = locale; 
+ 
+  // Restore current locale. 
+  setlocale(LC_ALL, current_loc_name.c_str()); 
+  return (locale_t)newloc; 
+} 
+ 
+void freelocale(locale_t locobj) { 
+  delete locobj; 
+} 
+ 
+locale_t uselocale(locale_t newloc) { 
+  // Maintain current locale name(s). 
+  std::string current_loc_name(setlocale(LC_ALL, 0)); 
+ 
+  if (newloc) { 
+    // Set locales and check for errors. 
+    bool is_error = 
+      (newloc->category_mask & LC_COLLATE_MASK && 
+        setlocale(LC_COLLATE, newloc->lc_collate.c_str()) == NULL) || 
+      (newloc->category_mask & LC_CTYPE_MASK && 
+        setlocale(LC_CTYPE, newloc->lc_ctype.c_str()) == NULL) || 
+      (newloc->category_mask & LC_MONETARY_MASK && 
+        setlocale(LC_MONETARY, newloc->lc_monetary.c_str()) == NULL) || 
+      (newloc->category_mask & LC_NUMERIC_MASK && 
+        setlocale(LC_NUMERIC, newloc->lc_numeric.c_str()) == NULL) || 
+      (newloc->category_mask & LC_TIME_MASK && 
+        setlocale(LC_TIME, newloc->lc_time.c_str()) == NULL) || 
+      (newloc->category_mask & LC_MESSAGES_MASK && 
+        setlocale(LC_MESSAGES, newloc->lc_messages.c_str()) == NULL); 
+ 
+    if (is_error) { 
+      setlocale(LC_ALL, current_loc_name.c_str()); 
+      errno = EINVAL; 
+      return (locale_t)0; 
+    } 
+  } 
+ 
+  // Construct and return previous locale. 
+  locale_t previous_loc = new locale_struct(); 
+ 
+  // current_loc_name might be a comma-separated locale name list. 
+  if (current_loc_name.find(',') != std::string::npos) { 
+    // Tokenize locale name list. 
+    const char delimiter = ','; 
+    std::vector<std::string> tokenized; 
+    std::stringstream ss(current_loc_name); 
+    std::string s; 
+ 
+    while (std::getline(ss, s, delimiter)) { 
+        tokenized.push_back(s); 
+    } 
+ 
+    _LIBCPP_ASSERT(tokenized.size() >= _NCAT, "locale-name list is too short"); 
+ 
+    previous_loc->lc_collate = tokenized[LC_COLLATE]; 
+    previous_loc->lc_ctype = tokenized[LC_CTYPE]; 
+    previous_loc->lc_monetary = tokenized[LC_MONETARY]; 
+    previous_loc->lc_numeric = tokenized[LC_NUMERIC]; 
+    previous_loc->lc_time = tokenized[LC_TIME]; 
+    // Skip LC_TOD. 
+    previous_loc->lc_messages = tokenized[LC_MESSAGES]; 
+  } else { 
+    previous_loc->lc_collate = current_loc_name; 
+    previous_loc->lc_ctype = current_loc_name; 
+    previous_loc->lc_monetary = current_loc_name; 
+    previous_loc->lc_numeric = current_loc_name; 
+    previous_loc->lc_time = current_loc_name; 
+    previous_loc->lc_messages = current_loc_name; 
+  } 
+ 
+  previous_loc->category_mask = LC_ALL_MASK; 
+  return previous_loc; 
+} 
+ 
+#ifdef __cplusplus 
+} 
+#endif // __cplusplus 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_fallback.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_fallback.ipp
index 6ebaeee2a5..f70445af55 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_fallback.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_fallback.ipp
@@ -1,161 +1,161 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstdio>
-#include "../../include/atomic_support.h"
-
-namespace std {
-
-_LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
-_LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
-
-
-// libcxxrt provides implementations of these functions itself.
-unexpected_handler
-set_unexpected(unexpected_handler func) noexcept
-{
-  return __libcpp_atomic_exchange(&__unexpected_handler, func);
-}
-
-unexpected_handler
-get_unexpected() noexcept
-{
-  return __libcpp_atomic_load(&__unexpected_handler);
-
-}
-
-_LIBCPP_NORETURN
-void unexpected()
-{
-    (*get_unexpected())();
-    // unexpected handler should not return
-    terminate();
-}
-
-terminate_handler
-set_terminate(terminate_handler func) noexcept
-{
-  return __libcpp_atomic_exchange(&__terminate_handler, func);
-}
-
-terminate_handler
-get_terminate() noexcept
-{
-  return __libcpp_atomic_load(&__terminate_handler);
-}
-
-_LIBCPP_NORETURN
-void
-terminate() noexcept
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_NO_EXCEPTIONS
-        (*get_terminate())();
-        // handler should not return
-        fprintf(stderr, "terminate_handler unexpectedly returned\n");
-        ::abort();
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
-        ::abort();
-    }
-#endif // _LIBCPP_NO_EXCEPTIONS
-}
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept
-{
-#warning uncaught_exception not yet implemented
-  fprintf(stderr, "uncaught_exceptions not yet implemented\n");
-  ::abort();
-}
-
-
-exception::~exception() noexcept
-{
-}
-
-const char* exception::what() const noexcept
-{
-  return "std::exception";
-}
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_alloc::~bad_alloc() noexcept
-{
-}
-
-const char*
-bad_alloc::what() const noexcept
-{
-    return "std::bad_alloc";
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_array_new_length::~bad_array_new_length() noexcept
-{
-}
-
-const char*
-bad_array_new_length::what() const noexcept
-{
-    return "bad_array_new_length";
-}
-
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-bad_cast::~bad_cast() noexcept
-{
-}
-
-const char*
-bad_cast::what() const noexcept
-{
-  return "std::bad_cast";
-}
-
-bad_typeid::~bad_typeid() noexcept
-{
-}
-
-const char*
-bad_typeid::what() const noexcept
-{
-  return "std::bad_typeid";
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <cstdio> 
+#include "../../include/atomic_support.h" 
+ 
+namespace std { 
+ 
+_LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler; 
+_LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler; 
+ 
+ 
+// libcxxrt provides implementations of these functions itself. 
+unexpected_handler 
+set_unexpected(unexpected_handler func) noexcept 
+{ 
+  return __libcpp_atomic_exchange(&__unexpected_handler, func); 
+} 
+ 
+unexpected_handler 
+get_unexpected() noexcept 
+{ 
+  return __libcpp_atomic_load(&__unexpected_handler); 
+ 
+} 
+ 
+_LIBCPP_NORETURN 
+void unexpected() 
+{ 
+    (*get_unexpected())(); 
+    // unexpected handler should not return 
+    terminate(); 
+} 
+ 
+terminate_handler 
+set_terminate(terminate_handler func) noexcept 
+{ 
+  return __libcpp_atomic_exchange(&__terminate_handler, func); 
+} 
+ 
+terminate_handler 
+get_terminate() noexcept 
+{ 
+  return __libcpp_atomic_load(&__terminate_handler); 
+} 
+ 
+_LIBCPP_NORETURN 
+void 
+terminate() noexcept 
+{ 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+    try 
+    { 
+#endif // _LIBCPP_NO_EXCEPTIONS 
+        (*get_terminate())(); 
+        // handler should not return 
+        fprintf(stderr, "terminate_handler unexpectedly returned\n"); 
+        ::abort(); 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+    } 
+    catch (...) 
+    { 
+        // handler should not throw exception 
+        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n"); 
+        ::abort(); 
+    } 
+#endif // _LIBCPP_NO_EXCEPTIONS 
+} 
+ 
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; } 
+ 
+int uncaught_exceptions() noexcept 
+{ 
+#warning uncaught_exception not yet implemented 
+  fprintf(stderr, "uncaught_exceptions not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+ 
+exception::~exception() noexcept 
+{ 
+} 
+ 
+const char* exception::what() const noexcept 
+{ 
+  return "std::exception"; 
+} 
+ 
+bad_exception::~bad_exception() noexcept 
+{ 
+} 
+ 
+const char* bad_exception::what() const noexcept 
+{ 
+  return "std::bad_exception"; 
+} 
+ 
+ 
+bad_alloc::bad_alloc() noexcept 
+{ 
+} 
+ 
+bad_alloc::~bad_alloc() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_alloc::what() const noexcept 
+{ 
+    return "std::bad_alloc"; 
+} 
+ 
+bad_array_new_length::bad_array_new_length() noexcept 
+{ 
+} 
+ 
+bad_array_new_length::~bad_array_new_length() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_array_new_length::what() const noexcept 
+{ 
+    return "bad_array_new_length"; 
+} 
+ 
+bad_cast::bad_cast() noexcept 
+{ 
+} 
+ 
+bad_typeid::bad_typeid() noexcept 
+{ 
+} 
+ 
+bad_cast::~bad_cast() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_cast::what() const noexcept 
+{ 
+  return "std::bad_cast"; 
+} 
+ 
+bad_typeid::~bad_typeid() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_typeid::what() const noexcept 
+{ 
+  return "std::bad_typeid"; 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_glibcxx.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_glibcxx.ipp
index e478ccbb6e..7cc665a8bc 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_glibcxx.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_glibcxx.ipp
@@ -1,32 +1,32 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __GLIBCXX__
-#error header can only be used when targeting libstdc++ or libsupc++
-#endif
-
-namespace std {
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef __GLIBCXX__ 
+#error header can only be used when targeting libstdc++ or libsupc++ 
+#endif 
+ 
+namespace std { 
+ 
+bad_alloc::bad_alloc() noexcept 
+{ 
+} 
+ 
+bad_array_new_length::bad_array_new_length() noexcept 
+{ 
+} 
+ 
+bad_cast::bad_cast() noexcept 
+{ 
+} 
+ 
+bad_typeid::bad_typeid() noexcept 
+{ 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxabi.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxabi.ipp
index ee15e437e6..a85a59f0a5 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxabi.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxabi.ipp
@@ -1,27 +1,27 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPPABI_VERSION
-#error this header can only be used with libc++abi
-#endif
-
-namespace std {
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept
-{
-# if _LIBCPPABI_VERSION > 1001
-    return __cxa_uncaught_exceptions();
-# else
-    return __cxa_uncaught_exception() ? 1 : 0;
-# endif
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPPABI_VERSION 
+#error this header can only be used with libc++abi 
+#endif 
+ 
+namespace std { 
+ 
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; } 
+ 
+int uncaught_exceptions() noexcept 
+{ 
+# if _LIBCPPABI_VERSION > 1001 
+    return __cxa_uncaught_exceptions(); 
+# else 
+    return __cxa_uncaught_exception() ? 1 : 0; 
+# endif 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxrt.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxrt.ipp
index 4e428d216c..bcca118c9c 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxrt.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_libcxxrt.ipp
@@ -1,25 +1,25 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
+// 
+//===----------------------------------------------------------------------===// 
+ 
 #ifndef LIBCXX_BUILDING_LIBCXXRT
-#error this header may only be used when targeting libcxxrt
-#endif
-
-namespace std {
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-} // namespace std
+#error this header may only be used when targeting libcxxrt 
+#endif 
+ 
+namespace std { 
+ 
+bad_exception::~bad_exception() noexcept 
+{ 
+} 
+ 
+const char* bad_exception::what() const noexcept 
+{ 
+  return "std::bad_exception"; 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_msvc.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_msvc.ipp
index 4eb1803f0b..ebfbe86b40 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_msvc.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_msvc.ipp
@@ -1,173 +1,173 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_ABI_MICROSOFT
-#error this header can only be used when targeting the MSVC ABI
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPP_ABI_MICROSOFT 
+#error this header can only be used when targeting the MSVC ABI 
+#endif 
+ 
+#include <stdio.h> 
+#include <stdlib.h> 
+ 
 #include <__config>
 
 #ifdef _LIBCPP_COMPILER_MSVC
-// We don't want to depend on MSVC headers but
-// we have conflicting definitions otherwise due to
-// some other dependency on eh.h.
-#include _LIBCPP_MSVC_INCLUDE(eh.h)
-
-#else
-extern "C" {
-typedef void (__cdecl* terminate_handler)();
-_LIBCPP_CRT_FUNC terminate_handler __cdecl set_terminate(
-    terminate_handler _NewTerminateHandler) throw();
-_LIBCPP_CRT_FUNC terminate_handler __cdecl _get_terminate();
-
-typedef void (__cdecl* unexpected_handler)();
-unexpected_handler __cdecl set_unexpected(
-    unexpected_handler _NewUnexpectedHandler) throw();
-unexpected_handler __cdecl _get_unexpected();
-
-int __cdecl __uncaught_exceptions();
-}
-#endif
-
-namespace std {
-
-unexpected_handler
-set_unexpected(unexpected_handler func) noexcept {
-  return ::set_unexpected(func);
-}
-
-unexpected_handler get_unexpected() noexcept {
-  return ::_get_unexpected();
-}
-
-_LIBCPP_NORETURN
-void unexpected() {
-    (*get_unexpected())();
-    // unexpected handler should not return
-    terminate();
-}
-
-terminate_handler set_terminate(terminate_handler func) noexcept {
-  return ::set_terminate(func);
-}
-
-terminate_handler get_terminate() noexcept {
-  return ::_get_terminate();
-}
-
-_LIBCPP_NORETURN
-void terminate() noexcept
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_NO_EXCEPTIONS
-        (*get_terminate())();
-        // handler should not return
-        fprintf(stderr, "terminate_handler unexpectedly returned\n");
-        ::abort();
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
-        ::abort();
-    }
-#endif // _LIBCPP_NO_EXCEPTIONS
-}
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept {
-    return __uncaught_exceptions();
-}
-
-#if !defined(_LIBCPP_ABI_VCRUNTIME)
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_cast::~bad_cast() noexcept
-{
-}
-
-const char *
-bad_cast::what() const noexcept
-{
-  return "std::bad_cast";
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-bad_typeid::~bad_typeid() noexcept
-{
-}
-
-const char *
-bad_typeid::what() const noexcept
-{
-  return "std::bad_typeid";
-}
-
-exception::~exception() noexcept
-{
-}
-
-const char* exception::what() const noexcept
-{
-  return "std::exception";
-}
-
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_alloc::~bad_alloc() noexcept
-{
-}
-
-const char*
-bad_alloc::what() const noexcept
-{
-    return "std::bad_alloc";
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_array_new_length::~bad_array_new_length() noexcept
-{
-}
-
-const char*
-bad_array_new_length::what() const noexcept
-{
-    return "bad_array_new_length";
-}
-#endif // !_LIBCPP_ABI_VCRUNTIME
-
-} // namespace std
+// We don't want to depend on MSVC headers but 
+// we have conflicting definitions otherwise due to 
+// some other dependency on eh.h. 
+#include _LIBCPP_MSVC_INCLUDE(eh.h) 
+ 
+#else 
+extern "C" { 
+typedef void (__cdecl* terminate_handler)(); 
+_LIBCPP_CRT_FUNC terminate_handler __cdecl set_terminate( 
+    terminate_handler _NewTerminateHandler) throw(); 
+_LIBCPP_CRT_FUNC terminate_handler __cdecl _get_terminate(); 
+ 
+typedef void (__cdecl* unexpected_handler)(); 
+unexpected_handler __cdecl set_unexpected( 
+    unexpected_handler _NewUnexpectedHandler) throw(); 
+unexpected_handler __cdecl _get_unexpected(); 
+ 
+int __cdecl __uncaught_exceptions(); 
+} 
+#endif 
+ 
+namespace std { 
+ 
+unexpected_handler 
+set_unexpected(unexpected_handler func) noexcept { 
+  return ::set_unexpected(func); 
+} 
+ 
+unexpected_handler get_unexpected() noexcept { 
+  return ::_get_unexpected(); 
+} 
+ 
+_LIBCPP_NORETURN 
+void unexpected() { 
+    (*get_unexpected())(); 
+    // unexpected handler should not return 
+    terminate(); 
+} 
+ 
+terminate_handler set_terminate(terminate_handler func) noexcept { 
+  return ::set_terminate(func); 
+} 
+ 
+terminate_handler get_terminate() noexcept { 
+  return ::_get_terminate(); 
+} 
+ 
+_LIBCPP_NORETURN 
+void terminate() noexcept 
+{ 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+    try 
+    { 
+#endif // _LIBCPP_NO_EXCEPTIONS 
+        (*get_terminate())(); 
+        // handler should not return 
+        fprintf(stderr, "terminate_handler unexpectedly returned\n"); 
+        ::abort(); 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+    } 
+    catch (...) 
+    { 
+        // handler should not throw exception 
+        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n"); 
+        ::abort(); 
+    } 
+#endif // _LIBCPP_NO_EXCEPTIONS 
+} 
+ 
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; } 
+ 
+int uncaught_exceptions() noexcept { 
+    return __uncaught_exceptions(); 
+} 
+ 
+#if !defined(_LIBCPP_ABI_VCRUNTIME) 
+bad_cast::bad_cast() noexcept 
+{ 
+} 
+ 
+bad_cast::~bad_cast() noexcept 
+{ 
+} 
+ 
+const char * 
+bad_cast::what() const noexcept 
+{ 
+  return "std::bad_cast"; 
+} 
+ 
+bad_typeid::bad_typeid() noexcept 
+{ 
+} 
+ 
+bad_typeid::~bad_typeid() noexcept 
+{ 
+} 
+ 
+const char * 
+bad_typeid::what() const noexcept 
+{ 
+  return "std::bad_typeid"; 
+} 
+ 
+exception::~exception() noexcept 
+{ 
+} 
+ 
+const char* exception::what() const noexcept 
+{ 
+  return "std::exception"; 
+} 
+ 
+ 
+bad_exception::~bad_exception() noexcept 
+{ 
+} 
+ 
+const char* bad_exception::what() const noexcept 
+{ 
+  return "std::bad_exception"; 
+} 
+ 
+ 
+bad_alloc::bad_alloc() noexcept 
+{ 
+} 
+ 
+bad_alloc::~bad_alloc() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_alloc::what() const noexcept 
+{ 
+    return "std::bad_alloc"; 
+} 
+ 
+bad_array_new_length::bad_array_new_length() noexcept 
+{ 
+} 
+ 
+bad_array_new_length::~bad_array_new_length() noexcept 
+{ 
+} 
+ 
+const char* 
+bad_array_new_length::what() const noexcept 
+{ 
+    return "bad_array_new_length"; 
+} 
+#endif // !_LIBCPP_ABI_VCRUNTIME 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp
index 33aa94502b..5ffc0cd127 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp
@@ -1,73 +1,73 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef HAVE_DEPENDENT_EH_ABI
-#error this header may only be used with libc++abi or libcxxrt
-#endif
-
-namespace std {
-
-exception_ptr::~exception_ptr() noexcept {
-  __cxa_decrement_exception_refcount(__ptr_);
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-    __cxa_increment_exception_refcount(__ptr_);
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-    if (__ptr_ != other.__ptr_)
-    {
-        __cxa_increment_exception_refcount(other.__ptr_);
-        __cxa_decrement_exception_refcount(__ptr_);
-        __ptr_ = other.__ptr_;
-    }
-    return *this;
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-nested_exception::~nested_exception() noexcept
-{
-}
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-    if (__ptr_ == nullptr)
-        terminate();
-    rethrow_exception(__ptr_);
-}
-
-exception_ptr current_exception() noexcept
-{
-    // be nicer if there was a constructor that took a ptr, then
-    // this whole function would be just:
-    //    return exception_ptr(__cxa_current_primary_exception());
-    exception_ptr ptr;
-    ptr.__ptr_ = __cxa_current_primary_exception();
-    return ptr;
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-    __cxa_rethrow_primary_exception(p.__ptr_);
-    // if p.__ptr_ is NULL, above returns so we terminate
-    terminate();
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef HAVE_DEPENDENT_EH_ABI 
+#error this header may only be used with libc++abi or libcxxrt 
+#endif 
+ 
+namespace std { 
+ 
+exception_ptr::~exception_ptr() noexcept { 
+  __cxa_decrement_exception_refcount(__ptr_); 
+} 
+ 
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept 
+    : __ptr_(other.__ptr_) 
+{ 
+    __cxa_increment_exception_refcount(__ptr_); 
+} 
+ 
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept 
+{ 
+    if (__ptr_ != other.__ptr_) 
+    { 
+        __cxa_increment_exception_refcount(other.__ptr_); 
+        __cxa_decrement_exception_refcount(__ptr_); 
+        __ptr_ = other.__ptr_; 
+    } 
+    return *this; 
+} 
+ 
+nested_exception::nested_exception() noexcept 
+    : __ptr_(current_exception()) 
+{ 
+} 
+ 
+nested_exception::~nested_exception() noexcept 
+{ 
+} 
+ 
+_LIBCPP_NORETURN 
+void 
+nested_exception::rethrow_nested() const 
+{ 
+    if (__ptr_ == nullptr) 
+        terminate(); 
+    rethrow_exception(__ptr_); 
+} 
+ 
+exception_ptr current_exception() noexcept 
+{ 
+    // be nicer if there was a constructor that took a ptr, then 
+    // this whole function would be just: 
+    //    return exception_ptr(__cxa_current_primary_exception()); 
+    exception_ptr ptr; 
+    ptr.__ptr_ = __cxa_current_primary_exception(); 
+    return ptr; 
+} 
+ 
+_LIBCPP_NORETURN 
+void rethrow_exception(exception_ptr p) 
+{ 
+    __cxa_rethrow_primary_exception(p.__ptr_); 
+    // if p.__ptr_ is NULL, above returns so we terminate 
+    terminate(); 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp
index 983a08808d..bd1d5e4752 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp
@@ -1,77 +1,77 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// libsupc++ does not implement the dependent EH ABI and the functionality
-// it uses to implement std::exception_ptr (which it declares as an alias of
-// std::__exception_ptr::exception_ptr) is not directly exported to clients. So
-// we have little choice but to hijack std::__exception_ptr::exception_ptr's
-// (which fortunately has the same layout as our std::exception_ptr) copy
-// constructor, assignment operator and destructor (which are part of its
-// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
-// function.
-
-namespace std {
-
-namespace __exception_ptr
-{
-
-struct exception_ptr
-{
-    void* __ptr_;
-
-    exception_ptr(const exception_ptr&) noexcept;
-    exception_ptr& operator=(const exception_ptr&) noexcept;
-    ~exception_ptr() noexcept;
-};
-
-}
-
-_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
-
-exception_ptr::~exception_ptr() noexcept
-{
-    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
-    return *this;
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-    if (__ptr_ == nullptr)
-        terminate();
-    rethrow_exception(__ptr_);
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+// libsupc++ does not implement the dependent EH ABI and the functionality 
+// it uses to implement std::exception_ptr (which it declares as an alias of 
+// std::__exception_ptr::exception_ptr) is not directly exported to clients. So 
+// we have little choice but to hijack std::__exception_ptr::exception_ptr's 
+// (which fortunately has the same layout as our std::exception_ptr) copy 
+// constructor, assignment operator and destructor (which are part of its 
+// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr) 
+// function. 
+ 
+namespace std { 
+ 
+namespace __exception_ptr 
+{ 
+ 
+struct exception_ptr 
+{ 
+    void* __ptr_; 
+ 
+    exception_ptr(const exception_ptr&) noexcept; 
+    exception_ptr& operator=(const exception_ptr&) noexcept; 
+    ~exception_ptr() noexcept; 
+}; 
+ 
+} 
+ 
+_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr); 
+ 
+exception_ptr::~exception_ptr() noexcept 
+{ 
+    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr(); 
+} 
+ 
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept 
+    : __ptr_(other.__ptr_) 
+{ 
+    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr( 
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other)); 
+} 
+ 
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept 
+{ 
+    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) = 
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other); 
+    return *this; 
+} 
+ 
+nested_exception::nested_exception() noexcept 
+    : __ptr_(current_exception()) 
+{ 
+} 
+ 
+ 
+_LIBCPP_NORETURN 
+void 
+nested_exception::rethrow_nested() const 
+{ 
+    if (__ptr_ == nullptr) 
+        terminate(); 
+    rethrow_exception(__ptr_); 
+} 
+ 
+_LIBCPP_NORETURN 
+void rethrow_exception(exception_ptr p) 
+{ 
+    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p)); 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_msvc.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_msvc.ipp
index 300acbf759..0810acf1ed 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_msvc.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_msvc.ipp
@@ -1,258 +1,258 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <atomic>
-#include <cstdint>
-#include <cstring>
-#include <malloc.h>
-#include <windows.h> // For RtlPcToFileHeader function
-
-struct EHCatchableType {
-  uint32_t properties;
-  int32_t type_info;
-  uint32_t non_virtual_adjustment;
-  uint32_t offset_to_virtual_base_ptr;
-  uint32_t virtual_base_table_index;
-  uint32_t size;
-  int32_t copy_function;
-};
-
-struct EHCatchableTypeArray {
-  uint32_t catchable_types;
-  // It is variable size but we only need the first element of this array
-  int32_t array_of_catchable_types[1];
-};
-
-struct EHThrowInfo {
-  uint32_t attributes;
-  int32_t unwind;
-  int32_t forward_compat;
-  int32_t catchable_type_array;
-};
-
-struct EHParameters {
-  uint32_t magic_number;
-  void* exception_object;
-  EHThrowInfo* throw_info;
-#ifdef _M_AMD64
-  uintptr_t throw_image_base;
-#endif
-};
-
-struct EHExceptionRecord {
-  uint32_t exception_code;
-  uint32_t exception_flags;
-  void* exception_record;
-  void* exception_address;
-  uint32_t number_of_parameters;
-  EHParameters parameters;
-};
-
-// defined in vcruntime<ver>.dll
-extern "C" EHExceptionRecord** __current_exception();
-
-// This is internal compiler definition for MSVC but not for clang.
-// We use our own EHThrowInfo because _ThrowInfo doesn't match actual
-// compiler-generated structures in 64-bit mode.
-#ifdef __clang__
-struct _ThrowInfo;
-// defined in vcruntime<ver>.dll
-_LIBCPP_NORETURN extern "C" void __stdcall _CxxThrowException(
-    void* __exc, _ThrowInfo* __throw_info);
-#endif
-
-namespace {
-struct ExceptionPtr {
-  void* exception_object;
-  const EHThrowInfo* throw_info;
-  std::atomic<size_t> counter;
-#ifdef _M_AMD64
-  PVOID image_base;
-#endif
-  template <class T>
-  T convert(int32_t offset) {
-#ifdef _M_AMD64
-    uintptr_t value = reinterpret_cast<uintptr_t>(image_base) +
-                      static_cast<uintptr_t>(offset);
-#else
-    uintptr_t value = static_cast<uintptr_t>(offset);
-#endif
-    T res;
-    static_assert(
-        sizeof(value) == sizeof(res),
-        "Can only convert to pointers or pointers to member functions");
-    memcpy(&res, &value, sizeof(value));
-    return res;
-  }
-
-  void copy(void* dst, const void* src, const EHCatchableType* exc_type) {
-    struct Temp {};
-    constexpr uint32_t virtual_base = 4;
-    if (exc_type->copy_function == 0) {
-      memcpy(dst, src, exc_type->size);
-    } else if (exc_type->properties & virtual_base) {
-      auto copy_constructor =
-          convert<void (Temp::*)(const void*, int)>(exc_type->copy_function);
-      ((Temp*)dst->*copy_constructor)(src, 1);
-    } else {
-      auto copy_constructor =
-          convert<void (Temp::*)(const void*)>(exc_type->copy_function);
-      ((Temp*)dst->*copy_constructor)(src);
-    }
-  }
-
-  EHCatchableType* exception_type() {
-    return convert<EHCatchableType*>(
-        convert<EHCatchableTypeArray*>(throw_info->catchable_type_array)
-            ->array_of_catchable_types[0]);
-  }
-
-  ExceptionPtr(const void* exception_object_, const EHThrowInfo* throw_info_)
-      : exception_object(nullptr), throw_info(throw_info_), counter(1) {
-#ifdef _M_AMD64
-    RtlPcToFileHeader(
-        reinterpret_cast<PVOID>(const_cast<EHThrowInfo*>(throw_info)),
-        &image_base);
-#endif
-    EHCatchableType* exc_type = exception_type();
-    this->exception_object = malloc(exc_type->size);
-    if (this->exception_object == nullptr) {
-      throw std::bad_alloc();
-    }
-    copy(exception_object, exception_object_, exc_type);
-  }
-
-  ~ExceptionPtr() {
-    if (throw_info->unwind && exception_object) {
-      struct Temp {};
-      auto destructor = convert<void (Temp::*)()>(throw_info->unwind);
-      ((Temp*)exception_object->*destructor)();
-    }
-    free(exception_object);
-  }
-
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <atomic> 
+#include <cstdint> 
+#include <cstring> 
+#include <malloc.h> 
+#include <windows.h> // For RtlPcToFileHeader function 
+ 
+struct EHCatchableType { 
+  uint32_t properties; 
+  int32_t type_info; 
+  uint32_t non_virtual_adjustment; 
+  uint32_t offset_to_virtual_base_ptr; 
+  uint32_t virtual_base_table_index; 
+  uint32_t size; 
+  int32_t copy_function; 
+}; 
+ 
+struct EHCatchableTypeArray { 
+  uint32_t catchable_types; 
+  // It is variable size but we only need the first element of this array 
+  int32_t array_of_catchable_types[1]; 
+}; 
+ 
+struct EHThrowInfo { 
+  uint32_t attributes; 
+  int32_t unwind; 
+  int32_t forward_compat; 
+  int32_t catchable_type_array; 
+}; 
+ 
+struct EHParameters { 
+  uint32_t magic_number; 
+  void* exception_object; 
+  EHThrowInfo* throw_info; 
+#ifdef _M_AMD64 
+  uintptr_t throw_image_base; 
+#endif 
+}; 
+ 
+struct EHExceptionRecord { 
+  uint32_t exception_code; 
+  uint32_t exception_flags; 
+  void* exception_record; 
+  void* exception_address; 
+  uint32_t number_of_parameters; 
+  EHParameters parameters; 
+}; 
+ 
+// defined in vcruntime<ver>.dll 
+extern "C" EHExceptionRecord** __current_exception(); 
+ 
+// This is internal compiler definition for MSVC but not for clang. 
+// We use our own EHThrowInfo because _ThrowInfo doesn't match actual 
+// compiler-generated structures in 64-bit mode. 
+#ifdef __clang__ 
+struct _ThrowInfo; 
+// defined in vcruntime<ver>.dll 
+_LIBCPP_NORETURN extern "C" void __stdcall _CxxThrowException( 
+    void* __exc, _ThrowInfo* __throw_info); 
+#endif 
+ 
+namespace { 
+struct ExceptionPtr { 
+  void* exception_object; 
+  const EHThrowInfo* throw_info; 
+  std::atomic<size_t> counter; 
+#ifdef _M_AMD64 
+  PVOID image_base; 
+#endif 
+  template <class T> 
+  T convert(int32_t offset) { 
+#ifdef _M_AMD64 
+    uintptr_t value = reinterpret_cast<uintptr_t>(image_base) + 
+                      static_cast<uintptr_t>(offset); 
+#else 
+    uintptr_t value = static_cast<uintptr_t>(offset); 
+#endif 
+    T res; 
+    static_assert( 
+        sizeof(value) == sizeof(res), 
+        "Can only convert to pointers or pointers to member functions"); 
+    memcpy(&res, &value, sizeof(value)); 
+    return res; 
+  } 
+ 
+  void copy(void* dst, const void* src, const EHCatchableType* exc_type) { 
+    struct Temp {}; 
+    constexpr uint32_t virtual_base = 4; 
+    if (exc_type->copy_function == 0) { 
+      memcpy(dst, src, exc_type->size); 
+    } else if (exc_type->properties & virtual_base) { 
+      auto copy_constructor = 
+          convert<void (Temp::*)(const void*, int)>(exc_type->copy_function); 
+      ((Temp*)dst->*copy_constructor)(src, 1); 
+    } else { 
+      auto copy_constructor = 
+          convert<void (Temp::*)(const void*)>(exc_type->copy_function); 
+      ((Temp*)dst->*copy_constructor)(src); 
+    } 
+  } 
+ 
+  EHCatchableType* exception_type() { 
+    return convert<EHCatchableType*>( 
+        convert<EHCatchableTypeArray*>(throw_info->catchable_type_array) 
+            ->array_of_catchable_types[0]); 
+  } 
+ 
+  ExceptionPtr(const void* exception_object_, const EHThrowInfo* throw_info_) 
+      : exception_object(nullptr), throw_info(throw_info_), counter(1) { 
+#ifdef _M_AMD64 
+    RtlPcToFileHeader( 
+        reinterpret_cast<PVOID>(const_cast<EHThrowInfo*>(throw_info)), 
+        &image_base); 
+#endif 
+    EHCatchableType* exc_type = exception_type(); 
+    this->exception_object = malloc(exc_type->size); 
+    if (this->exception_object == nullptr) { 
+      throw std::bad_alloc(); 
+    } 
+    copy(exception_object, exception_object_, exc_type); 
+  } 
+ 
+  ~ExceptionPtr() { 
+    if (throw_info->unwind && exception_object) { 
+      struct Temp {}; 
+      auto destructor = convert<void (Temp::*)()>(throw_info->unwind); 
+      ((Temp*)exception_object->*destructor)(); 
+    } 
+    free(exception_object); 
+  } 
+ 
   // _bad_alloc_storage must be initialized before bad_alloc, so we declare and define it first.
   static std::bad_alloc _bad_alloc_storage;
-  static ExceptionPtr bad_alloc;
-  //static ExceptionPtr bad_exception;
-};
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Waddress-of-temporary"
-#endif
-
+  static ExceptionPtr bad_alloc; 
+  //static ExceptionPtr bad_exception; 
+}; 
+ 
+#ifdef __clang__ 
+#pragma clang diagnostic push 
+#pragma clang diagnostic ignored "-Waddress-of-temporary" 
+#endif 
+ 
 std::bad_alloc ExceptionPtr::_bad_alloc_storage;
 
-ExceptionPtr ExceptionPtr::bad_alloc(
+ExceptionPtr ExceptionPtr::bad_alloc( 
     &ExceptionPtr::_bad_alloc_storage,
     reinterpret_cast<const EHThrowInfo*>(__GetExceptionInfo(ExceptionPtr::_bad_alloc_storage)));
-
-/* ExceptionPtr
-ExceptionPtr::bad_exception(&std::bad_exception(),
-                            reinterpret_cast<const EHThrowInfo*>(
-                                __GetExceptionInfo(std::bad_exception()))); */
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-} // namespace
-
-namespace std {
-
-exception_ptr::exception_ptr(const exception_ptr& __other) noexcept
-    : __ptr_(__other.__ptr_) {
-  if (__ptr_) {
-    reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_add(1);
-  }
-}
-
-exception_ptr& exception_ptr::
-operator=(const exception_ptr& __other) noexcept {
-  auto before = __ptr_;
-  __ptr_ = __other.__ptr_;
-  if (__ptr_) {
-    reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_add(1);
-  }
-  if (before) {
-    if (reinterpret_cast<ExceptionPtr*>(before)->counter.fetch_sub(1) == 1) {
-      delete reinterpret_cast<ExceptionPtr*>(before);
-    }
-  }
-  return *this;
-}
-
-exception_ptr::~exception_ptr() noexcept {
-  if (__ptr_) {
-    if (reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_sub(1) == 1) {
-      delete reinterpret_cast<ExceptionPtr*>(__ptr_);
-    }
-  }
-}
-
-exception_ptr __copy_exception_ptr(void* exception_object,
-                                   const void* throw_info) {
-  ExceptionPtr* ptr;
-  try {
-    ptr = new ExceptionPtr(exception_object,
-                           reinterpret_cast<const EHThrowInfo*>(throw_info));
-  } catch (const std::bad_alloc&) {
-    ptr = &ExceptionPtr::bad_alloc;
-    ptr->counter.fetch_add(1);
-  } catch (...) {
-    //ptr = &ExceptionPtr::bad_exception;
-    //ptr->counter.fetch_add(1);
-    std::terminate();
-  }
-  exception_ptr res;
-  memcpy(&res, &ptr, sizeof(ptr));
-  return res;
-}
-
-exception_ptr current_exception() noexcept {
-  EHExceptionRecord** record = __current_exception();
-  if (*record && !std::uncaught_exception()) {
-    return __copy_exception_ptr((*record)->parameters.exception_object,
-                                (*record)->parameters.throw_info);
-  }
-  return exception_ptr();
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p) {
-  if (!p) {
-    throw std::bad_exception();
-  }
-  ExceptionPtr* exc_ptr = reinterpret_cast<ExceptionPtr*>(p.__ptr_);
-  EHCatchableType* exc_type = exc_ptr->exception_type();
-  // _CxxThrowException doesn't call free on exception object so we must
-  // allocate it on the stack.
-  void* dst = _alloca(exc_type->size);
-  exc_ptr->copy(dst, exc_ptr->exception_object, exc_type);
-  auto throw_info = reinterpret_cast<_ThrowInfo*>(
-      const_cast<EHThrowInfo*>(exc_ptr->throw_info));
-  // For some reason clang doesn't call p destructor during unwinding.
-  // So we must clear it ourselves.
-  p = nullptr;
-  _CxxThrowException(dst, throw_info);
-}
-
-nested_exception::nested_exception() noexcept : __ptr_(current_exception()) {}
-
-nested_exception::~nested_exception() noexcept {}
-
-_LIBCPP_NORETURN
-void nested_exception::rethrow_nested() const {
-  if (__ptr_ == nullptr)
-    terminate();
-  rethrow_exception(__ptr_);
-}
-
-} // namespace std
+ 
+/* ExceptionPtr 
+ExceptionPtr::bad_exception(&std::bad_exception(), 
+                            reinterpret_cast<const EHThrowInfo*>( 
+                                __GetExceptionInfo(std::bad_exception()))); */ 
+ 
+#ifdef __clang__ 
+#pragma clang diagnostic pop 
+#endif 
+ 
+} // namespace 
+ 
+namespace std { 
+ 
+exception_ptr::exception_ptr(const exception_ptr& __other) noexcept 
+    : __ptr_(__other.__ptr_) { 
+  if (__ptr_) { 
+    reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_add(1); 
+  } 
+} 
+ 
+exception_ptr& exception_ptr:: 
+operator=(const exception_ptr& __other) noexcept { 
+  auto before = __ptr_; 
+  __ptr_ = __other.__ptr_; 
+  if (__ptr_) { 
+    reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_add(1); 
+  } 
+  if (before) { 
+    if (reinterpret_cast<ExceptionPtr*>(before)->counter.fetch_sub(1) == 1) { 
+      delete reinterpret_cast<ExceptionPtr*>(before); 
+    } 
+  } 
+  return *this; 
+} 
+ 
+exception_ptr::~exception_ptr() noexcept { 
+  if (__ptr_) { 
+    if (reinterpret_cast<ExceptionPtr*>(__ptr_)->counter.fetch_sub(1) == 1) { 
+      delete reinterpret_cast<ExceptionPtr*>(__ptr_); 
+    } 
+  } 
+} 
+ 
+exception_ptr __copy_exception_ptr(void* exception_object, 
+                                   const void* throw_info) { 
+  ExceptionPtr* ptr; 
+  try { 
+    ptr = new ExceptionPtr(exception_object, 
+                           reinterpret_cast<const EHThrowInfo*>(throw_info)); 
+  } catch (const std::bad_alloc&) { 
+    ptr = &ExceptionPtr::bad_alloc; 
+    ptr->counter.fetch_add(1); 
+  } catch (...) { 
+    //ptr = &ExceptionPtr::bad_exception; 
+    //ptr->counter.fetch_add(1); 
+    std::terminate(); 
+  } 
+  exception_ptr res; 
+  memcpy(&res, &ptr, sizeof(ptr)); 
+  return res; 
+} 
+ 
+exception_ptr current_exception() noexcept { 
+  EHExceptionRecord** record = __current_exception(); 
+  if (*record && !std::uncaught_exception()) { 
+    return __copy_exception_ptr((*record)->parameters.exception_object, 
+                                (*record)->parameters.throw_info); 
+  } 
+  return exception_ptr(); 
+} 
+ 
+_LIBCPP_NORETURN 
+void rethrow_exception(exception_ptr p) { 
+  if (!p) { 
+    throw std::bad_exception(); 
+  } 
+  ExceptionPtr* exc_ptr = reinterpret_cast<ExceptionPtr*>(p.__ptr_); 
+  EHCatchableType* exc_type = exc_ptr->exception_type(); 
+  // _CxxThrowException doesn't call free on exception object so we must 
+  // allocate it on the stack. 
+  void* dst = _alloca(exc_type->size); 
+  exc_ptr->copy(dst, exc_ptr->exception_object, exc_type); 
+  auto throw_info = reinterpret_cast<_ThrowInfo*>( 
+      const_cast<EHThrowInfo*>(exc_ptr->throw_info)); 
+  // For some reason clang doesn't call p destructor during unwinding. 
+  // So we must clear it ourselves. 
+  p = nullptr; 
+  _CxxThrowException(dst, throw_info); 
+} 
+ 
+nested_exception::nested_exception() noexcept : __ptr_(current_exception()) {} 
+ 
+nested_exception::~nested_exception() noexcept {} 
+ 
+_LIBCPP_NORETURN 
+void nested_exception::rethrow_nested() const { 
+  if (__ptr_ == nullptr) 
+    terminate(); 
+  rethrow_exception(__ptr_); 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp
index 9e8ec04e11..191b9d4304 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp
@@ -1,79 +1,79 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-#include <stdlib.h>
-
-namespace std {
-
-exception_ptr::~exception_ptr() noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-#if !defined(__GLIBCXX__)
-
-nested_exception::~nested_exception() noexcept
-{
-}
-
-#endif
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-#if 0
-  if (__ptr_ == nullptr)
-      terminate();
-  rethrow_exception(__ptr_);
-#endif // FIXME
-}
-
-exception_ptr current_exception() noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <stdio.h> 
+#include <stdlib.h> 
+ 
+namespace std { 
+ 
+exception_ptr::~exception_ptr() noexcept 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept 
+    : __ptr_(other.__ptr_) 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+nested_exception::nested_exception() noexcept 
+    : __ptr_(current_exception()) 
+{ 
+} 
+ 
+#if !defined(__GLIBCXX__) 
+ 
+nested_exception::~nested_exception() noexcept 
+{ 
+} 
+ 
+#endif 
+ 
+_LIBCPP_NORETURN 
+void 
+nested_exception::rethrow_nested() const 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+#if 0 
+  if (__ptr_ == nullptr) 
+      terminate(); 
+  rethrow_exception(__ptr_); 
+#endif // FIXME 
+} 
+ 
+exception_ptr current_exception() noexcept 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+_LIBCPP_NORETURN 
+void rethrow_exception(exception_ptr p) 
+{ 
+#  warning exception_ptr not yet implemented 
+  fprintf(stderr, "exception_ptr not yet implemented\n"); 
+  ::abort(); 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/new_handler_fallback.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/new_handler_fallback.ipp
index 3eaeb489a1..838a9a7910 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/new_handler_fallback.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/new_handler_fallback.ipp
@@ -1,28 +1,28 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "../../include/atomic_support.h"
-
-namespace std {
-
-_LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
-
-new_handler
-set_new_handler(new_handler handler) noexcept
-{
-    return __libcpp_atomic_exchange(&__new_handler, handler);
-}
-
-new_handler
-get_new_handler() noexcept
-{
-    return __libcpp_atomic_load(&__new_handler);
-}
-
-} // namespace std
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "../../include/atomic_support.h" 
+ 
+namespace std { 
+ 
+_LIBCPP_SAFE_STATIC static std::new_handler __new_handler; 
+ 
+new_handler 
+set_new_handler(new_handler handler) noexcept 
+{ 
+    return __libcpp_atomic_exchange(&__new_handler, handler); 
+} 
+ 
+new_handler 
+get_new_handler() noexcept 
+{ 
+    return __libcpp_atomic_load(&__new_handler); 
+} 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_default.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_default.ipp
index 5d22b7894c..8f390a737d 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_default.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_default.ipp
@@ -1,64 +1,64 @@
-//===--------------------- stdexcept_default.ipp --------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "../../include/refstring.h"
-
-/* For _LIBCPPABI_VERSION */
-#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) &&                           \
+//===--------------------- stdexcept_default.ipp --------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "../../include/refstring.h" 
+ 
+/* For _LIBCPPABI_VERSION */ 
+#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) &&                           \ 
     (defined(LIBCXX_BUILDING_LIBCXXABI) || defined(LIBCXX_BUILDING_LIBCXXRT))
-#include <cxxabi.h>
-#endif
-
-static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
-
-namespace std // purposefully not using versioning namespace
-{
-
-logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
-
-logic_error::logic_error(const char* msg) : __imp_(msg) {}
-
-logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {}
-
-logic_error& logic_error::operator=(const logic_error& le) noexcept {
-  __imp_ = le.__imp_;
-  return *this;
-}
-
-runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
-
-runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
-
-runtime_error::runtime_error(const runtime_error& re) noexcept
-    : __imp_(re.__imp_) {}
-
-runtime_error& runtime_error::operator=(const runtime_error& re) noexcept {
-  __imp_ = re.__imp_;
-  return *this;
-}
-
-#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
-
-const char* logic_error::what() const noexcept { return __imp_.c_str(); }
-
-const char* runtime_error::what() const noexcept { return __imp_.c_str(); }
-
-logic_error::~logic_error() noexcept {}
-domain_error::~domain_error() noexcept {}
-invalid_argument::~invalid_argument() noexcept {}
-length_error::~length_error() noexcept {}
-out_of_range::~out_of_range() noexcept {}
-
-runtime_error::~runtime_error() noexcept {}
-range_error::~range_error() noexcept {}
-overflow_error::~overflow_error() noexcept {}
-underflow_error::~underflow_error() noexcept {}
-
-#endif
-
-} // namespace std
+#include <cxxabi.h> 
+#endif 
+ 
+static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), ""); 
+ 
+namespace std // purposefully not using versioning namespace 
+{ 
+ 
+logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {} 
+ 
+logic_error::logic_error(const char* msg) : __imp_(msg) {} 
+ 
+logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {} 
+ 
+logic_error& logic_error::operator=(const logic_error& le) noexcept { 
+  __imp_ = le.__imp_; 
+  return *this; 
+} 
+ 
+runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {} 
+ 
+runtime_error::runtime_error(const char* msg) : __imp_(msg) {} 
+ 
+runtime_error::runtime_error(const runtime_error& re) noexcept 
+    : __imp_(re.__imp_) {} 
+ 
+runtime_error& runtime_error::operator=(const runtime_error& re) noexcept { 
+  __imp_ = re.__imp_; 
+  return *this; 
+} 
+ 
+#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX) 
+ 
+const char* logic_error::what() const noexcept { return __imp_.c_str(); } 
+ 
+const char* runtime_error::what() const noexcept { return __imp_.c_str(); } 
+ 
+logic_error::~logic_error() noexcept {} 
+domain_error::~domain_error() noexcept {} 
+invalid_argument::~invalid_argument() noexcept {} 
+length_error::~length_error() noexcept {} 
+out_of_range::~out_of_range() noexcept {} 
+ 
+runtime_error::~runtime_error() noexcept {} 
+range_error::~range_error() noexcept {} 
+overflow_error::~overflow_error() noexcept {} 
+underflow_error::~underflow_error() noexcept {} 
+ 
+#endif 
+ 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_vcruntime.ipp b/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_vcruntime.ipp
index 94eed465ae..c62e702dc5 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_vcruntime.ipp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/runtime/stdexcept_vcruntime.ipp
@@ -1,16 +1,16 @@
-//===------------------- stdexcept_vcruntime.ipp --------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_ABI_VCRUNTIME
-#error This file may only be used when defering to vcruntime
-#endif
-
-namespace std {
-logic_error::logic_error(std::string const& s) : exception(s.c_str()) {}
-runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {}
-} // namespace std
+//===------------------- stdexcept_vcruntime.ipp --------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPP_ABI_VCRUNTIME 
+#error This file may only be used when defering to vcruntime 
+#endif 
+ 
+namespace std { 
+logic_error::logic_error(std::string const& s) : exception(s.c_str()) {} 
+runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {} 
+} // namespace std 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/solaris/README b/contrib/libs/cxxsupp/libcxx/src/support/solaris/README
index 89c887a3b4..3f475a5d9c 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/solaris/README
+++ b/contrib/libs/cxxsupp/libcxx/src/support/solaris/README
@@ -1,4 +1,4 @@
-This directory contains a partial implementation of the xlocale APIs for
-Solaris.  Some portions are lifted from FreeBSD libc, and so are covered by a
-2-clause BSD license instead of the MIT/UUIC license that the rest of libc++ is
-distributed under.
+This directory contains a partial implementation of the xlocale APIs for 
+Solaris.  Some portions are lifted from FreeBSD libc, and so are covered by a 
+2-clause BSD license instead of the MIT/UUIC license that the rest of libc++ is 
+distributed under. 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/solaris/mbsnrtowcs.inc b/contrib/libs/cxxsupp/libcxx/src/support/solaris/mbsnrtowcs.inc
index 074045277c..2aa5fc1737 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/solaris/mbsnrtowcs.inc
+++ b/contrib/libs/cxxsupp/libcxx/src/support/solaris/mbsnrtowcs.inc
@@ -1,76 +1,76 @@
-
-
-/*-
- * As noted in the source, some portions of this implementation are copied from
- * FreeBSD libc.  These are covered by the following copyright:
- *
- * Copyright (c) 2002-2004 Tim J. Robbins.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-size_t
-mbsnrtowcs_l(wchar_t * __restrict dst, const char ** __restrict src,
-    size_t nms, size_t len, mbstate_t * __restrict ps, locale_t loc)
-{
-  const char *s;
-  size_t nchr;
-  wchar_t wc;
-  size_t nb;
-  FIX_LOCALE(loc);
-
-  s = *src;
-  nchr = 0;
-
-  if (dst == NULL) {
-    for (;;) {
-      if ((nb = mbrtowc_l(&wc, s, nms, ps, loc)) == (size_t)-1)
-        /* Invalid sequence - mbrtowc() sets errno. */
-        return ((size_t)-1);
-      else if (nb == 0 || nb == (size_t)-2)
-        return (nchr);
-      s += nb;
-      nms -= nb;
-      nchr++;
-    }
-    /*NOTREACHED*/
-  }
-
-  while (len-- > 0) {
-    if ((nb = mbrtowc_l(dst, s, nms, ps, loc)) == (size_t)-1) {
-      *src = s;
-      return ((size_t)-1);
-    } else if (nb == (size_t)-2) {
-      *src = s + nms;
-      return (nchr);
-    } else if (nb == 0) {
-      *src = NULL;
-      return (nchr);
-    }
-    s += nb;
-    nms -= nb;
-    nchr++;
-    dst++;
-  }
-  *src = s;
-  return (nchr);
-}
+ 
+ 
+/*- 
+ * As noted in the source, some portions of this implementation are copied from 
+ * FreeBSD libc.  These are covered by the following copyright: 
+ * 
+ * Copyright (c) 2002-2004 Tim J. Robbins. 
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
+ */ 
+ 
+size_t 
+mbsnrtowcs_l(wchar_t * __restrict dst, const char ** __restrict src, 
+    size_t nms, size_t len, mbstate_t * __restrict ps, locale_t loc) 
+{ 
+  const char *s; 
+  size_t nchr; 
+  wchar_t wc; 
+  size_t nb; 
+  FIX_LOCALE(loc); 
+ 
+  s = *src; 
+  nchr = 0; 
+ 
+  if (dst == NULL) { 
+    for (;;) { 
+      if ((nb = mbrtowc_l(&wc, s, nms, ps, loc)) == (size_t)-1) 
+        /* Invalid sequence - mbrtowc() sets errno. */ 
+        return ((size_t)-1); 
+      else if (nb == 0 || nb == (size_t)-2) 
+        return (nchr); 
+      s += nb; 
+      nms -= nb; 
+      nchr++; 
+    } 
+    /*NOTREACHED*/ 
+  } 
+ 
+  while (len-- > 0) { 
+    if ((nb = mbrtowc_l(dst, s, nms, ps, loc)) == (size_t)-1) { 
+      *src = s; 
+      return ((size_t)-1); 
+    } else if (nb == (size_t)-2) { 
+      *src = s + nms; 
+      return (nchr); 
+    } else if (nb == 0) { 
+      *src = NULL; 
+      return (nchr); 
+    } 
+    s += nb; 
+    nms -= nb; 
+    nchr++; 
+    dst++; 
+  } 
+  *src = s; 
+  return (nchr); 
+} 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/solaris/wcsnrtombs.inc b/contrib/libs/cxxsupp/libcxx/src/support/solaris/wcsnrtombs.inc
index 239079e471..7c241c310b 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/solaris/wcsnrtombs.inc
+++ b/contrib/libs/cxxsupp/libcxx/src/support/solaris/wcsnrtombs.inc
@@ -1,92 +1,92 @@
-/*-
- * Copyright (c) 2002-2004 Tim J. Robbins.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-
-size_t
-wcsnrtombs_l(char * __restrict dst, const wchar_t ** __restrict src,
-    size_t nwc, size_t len, mbstate_t * __restrict ps, locale_t loc)
-{
-  FIX_LOCALE(loc);
-  mbstate_t mbsbak;
-  char buf[MB_CUR_MAX_L(loc)];
-  const wchar_t *s;
-  size_t nbytes;
-  size_t nb;
-
-  s = *src;
-  nbytes = 0;
-
-  if (dst == NULL) {
-    while (nwc-- > 0) {
-      if ((nb = wcrtomb_l(buf, *s, ps, loc)) == (size_t)-1)
-        /* Invalid character - wcrtomb() sets errno. */
-        return ((size_t)-1);
-      else if (*s == L'\0')
-        return (nbytes + nb - 1);
-      s++;
-      nbytes += nb;
-    }
-    return (nbytes);
-  }
-
-  while (len > 0 && nwc-- > 0) {
-    if (len > (size_t)MB_CUR_MAX_L(loc)) {
-      /* Enough space to translate in-place. */
-      if ((nb = wcrtomb_l(dst, *s, ps, loc)) == (size_t)-1) {
-        *src = s;
-        return ((size_t)-1);
-      }
-    } else {
-      /*
-       * May not be enough space; use temp. buffer.
-       *
-       * We need to save a copy of the conversion state
-       * here so we can restore it if the multibyte
-       * character is too long for the buffer.
-       */
-      mbsbak = *ps;
-      if ((nb = wcrtomb_l(buf, *s, ps, loc)) == (size_t)-1) {
-        *src = s;
-        return ((size_t)-1);
-      }
-      if (nb > (int)len) {
-        /* MB sequence for character won't fit. */
-        *ps = mbsbak;
-        break;
-      }
-      memcpy(dst, buf, nb);
-    }
-    if (*s == L'\0') {
-      *src = NULL;
-      return (nbytes + nb - 1);
-    }
-    s++;
-    dst += nb;
-    len -= nb;
-    nbytes += nb;
-  }
-  *src = s;
-  return (nbytes);
-}
+/*- 
+ * Copyright (c) 2002-2004 Tim J. Robbins. 
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
+ */ 
+ 
+ 
+size_t 
+wcsnrtombs_l(char * __restrict dst, const wchar_t ** __restrict src, 
+    size_t nwc, size_t len, mbstate_t * __restrict ps, locale_t loc) 
+{ 
+  FIX_LOCALE(loc); 
+  mbstate_t mbsbak; 
+  char buf[MB_CUR_MAX_L(loc)]; 
+  const wchar_t *s; 
+  size_t nbytes; 
+  size_t nb; 
+ 
+  s = *src; 
+  nbytes = 0; 
+ 
+  if (dst == NULL) { 
+    while (nwc-- > 0) { 
+      if ((nb = wcrtomb_l(buf, *s, ps, loc)) == (size_t)-1) 
+        /* Invalid character - wcrtomb() sets errno. */ 
+        return ((size_t)-1); 
+      else if (*s == L'\0') 
+        return (nbytes + nb - 1); 
+      s++; 
+      nbytes += nb; 
+    } 
+    return (nbytes); 
+  } 
+ 
+  while (len > 0 && nwc-- > 0) { 
+    if (len > (size_t)MB_CUR_MAX_L(loc)) { 
+      /* Enough space to translate in-place. */ 
+      if ((nb = wcrtomb_l(dst, *s, ps, loc)) == (size_t)-1) { 
+        *src = s; 
+        return ((size_t)-1); 
+      } 
+    } else { 
+      /* 
+       * May not be enough space; use temp. buffer. 
+       * 
+       * We need to save a copy of the conversion state 
+       * here so we can restore it if the multibyte 
+       * character is too long for the buffer. 
+       */ 
+      mbsbak = *ps; 
+      if ((nb = wcrtomb_l(buf, *s, ps, loc)) == (size_t)-1) { 
+        *src = s; 
+        return ((size_t)-1); 
+      } 
+      if (nb > (int)len) { 
+        /* MB sequence for character won't fit. */ 
+        *ps = mbsbak; 
+        break; 
+      } 
+      memcpy(dst, buf, nb); 
+    } 
+    if (*s == L'\0') { 
+      *src = NULL; 
+      return (nbytes + nb - 1); 
+    } 
+    s++; 
+    dst += nb; 
+    len -= nb; 
+    nbytes += nb; 
+  } 
+  *src = s; 
+  return (nbytes); 
+} 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/solaris/xlocale.cpp b/contrib/libs/cxxsupp/libcxx/src/support/solaris/xlocale.cpp
index d25adcd21d..6b6ce2065a 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/solaris/xlocale.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/solaris/xlocale.cpp
@@ -1,68 +1,68 @@
-//===----------------------------------------------------------------------===//
-//
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifdef __sun__
-
-#include "__support/solaris/xlocale.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <sys/localedef.h>
-
-extern "C" {
-
-int isxdigit_l(int __c, locale_t __l) {
-    return isxdigit(__c);
-}
-
-int iswxdigit_l(wint_t __c, locale_t __l) {
-    return isxdigit(__c);
-}
-
-// FIXME: This disregards the locale, which is Very Wrong
-#define vsnprintf_l(__s, __n, __l, __format, __va)  \
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifdef __sun__ 
+ 
+#include "__support/solaris/xlocale.h" 
+#include <stdarg.h> 
+#include <stdio.h> 
+#include <sys/localedef.h> 
+ 
+extern "C" { 
+ 
+int isxdigit_l(int __c, locale_t __l) { 
+    return isxdigit(__c); 
+} 
+ 
+int iswxdigit_l(wint_t __c, locale_t __l) { 
+    return isxdigit(__c); 
+} 
+ 
+// FIXME: This disregards the locale, which is Very Wrong 
+#define vsnprintf_l(__s, __n, __l, __format, __va)  \ 
     vsnprintf(__s, __n, __format, __va)
-
-int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...)
-{
-  va_list __va;
-  va_start(__va, __format);
-  int __res = vsnprintf_l(__s, __n , __l, __format, __va);
-  va_end(__va);
-  return __res;
-}
-
-int asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-  // FIXME:
-  int __res = vasprintf(__s, __format, __va);
-  va_end(__va);
-  return __res;
-}
-
-int sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-  // FIXME:
-  int __res = vsscanf(__s, __format, __va);
-  va_end(__va);
-  return __res;
-}
-
-size_t mbrtowc_l(wchar_t *__pwc, const char *__pmb,
-                 size_t __max, mbstate_t *__ps, locale_t __loc) {
-  return mbrtowc(__pwc, __pmb, __max, __ps);
-}
-
-struct lconv *localeconv_l(locale_t __l) {
-  return localeconv();
-}
-
-};
-
-#endif // __sun__
+ 
+int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) 
+{ 
+  va_list __va; 
+  va_start(__va, __format); 
+  int __res = vsnprintf_l(__s, __n , __l, __format, __va); 
+  va_end(__va); 
+  return __res; 
+} 
+ 
+int asprintf_l(char **__s, locale_t __l, const char *__format, ...) { 
+  va_list __va; 
+  va_start(__va, __format); 
+  // FIXME: 
+  int __res = vasprintf(__s, __format, __va); 
+  va_end(__va); 
+  return __res; 
+} 
+ 
+int sscanf_l(const char *__s, locale_t __l, const char *__format, ...) { 
+  va_list __va; 
+  va_start(__va, __format); 
+  // FIXME: 
+  int __res = vsscanf(__s, __format, __va); 
+  va_end(__va); 
+  return __res; 
+} 
+ 
+size_t mbrtowc_l(wchar_t *__pwc, const char *__pmb, 
+                 size_t __max, mbstate_t *__ps, locale_t __loc) { 
+  return mbrtowc(__pwc, __pmb, __max, __ps); 
+} 
+ 
+struct lconv *localeconv_l(locale_t __l) { 
+  return localeconv(); 
+} 
+ 
+}; 
+ 
+#endif // __sun__ 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/win32/atomic_win32.cpp b/contrib/libs/cxxsupp/libcxx/src/support/win32/atomic_win32.cpp
index 28cb0722ce..04717c8c87 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/win32/atomic_win32.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/win32/atomic_win32.cpp
@@ -1,31 +1,31 @@
-#include <intrin.h>
-#include <cstdint>
-
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace {
-static const int __msvc_locks_size = 1024;
-volatile long __msvc_locks[__msvc_locks_size];
-
-size_t __msvc_lock_hash(void* __p) {
-    uintptr_t __num = reinterpret_cast<uintptr_t>(__p);
-    return (__num ^ (__num >> 10)) & (__msvc_locks_size - 1);
-}
-}
-
-void __msvc_lock(void* __p) {
-    volatile long& __lock = __msvc_locks[__msvc_lock_hash(__p)];
-    while (_InterlockedExchange(&__lock, 1) == 0) {
-#if defined(_M_ARM) || defined(_M_ARM64)
-        __yield();
-#endif
-    }
-}
-
-void __msvc_unlock(void* __p) {
-    volatile long& __lock = __msvc_locks[__msvc_lock_hash(__p)];
-    _InterlockedExchange(&__lock, 0);
-}
-
-_LIBCPP_END_NAMESPACE_STD
\ No newline at end of file
+#include <intrin.h> 
+#include <cstdint> 
+ 
+ 
+_LIBCPP_BEGIN_NAMESPACE_STD 
+ 
+namespace { 
+static const int __msvc_locks_size = 1024; 
+volatile long __msvc_locks[__msvc_locks_size]; 
+ 
+size_t __msvc_lock_hash(void* __p) { 
+    uintptr_t __num = reinterpret_cast<uintptr_t>(__p); 
+    return (__num ^ (__num >> 10)) & (__msvc_locks_size - 1); 
+} 
+} 
+ 
+void __msvc_lock(void* __p) { 
+    volatile long& __lock = __msvc_locks[__msvc_lock_hash(__p)]; 
+    while (_InterlockedExchange(&__lock, 1) == 0) { 
+#if defined(_M_ARM) || defined(_M_ARM64) 
+        __yield(); 
+#endif 
+    } 
+} 
+ 
+void __msvc_unlock(void* __p) { 
+    volatile long& __lock = __msvc_locks[__msvc_lock_hash(__p)]; 
+    _InterlockedExchange(&__lock, 0); 
+} 
+ 
+_LIBCPP_END_NAMESPACE_STD 
\ No newline at end of file
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/win32/locale_win32.cpp b/contrib/libs/cxxsupp/libcxx/src/support/win32/locale_win32.cpp
index f10916875d..67a8391e0f 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/win32/locale_win32.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/win32/locale_win32.cpp
@@ -1,138 +1,138 @@
-//===----------------------------------------------------------------------===//
-//
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <locale>
-#include <cstdarg> // va_start, va_end
-#include <memory>
-#include <type_traits>
-
-int __libcpp_vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
-
-using std::__libcpp_locale_guard;
-
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
-{
-    return {_create_locale( LC_ALL, locale ), locale};
-}
-
-decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
-{
-#if defined(_LIBCPP_MSVCRT)
-  return ___mb_cur_max_l_func(__l);
-#else
-  __libcpp_locale_guard __current(__l);
-  return MB_CUR_MAX;
-#endif
-}
-
-lconv *localeconv_l( locale_t &loc )
-{
-    __libcpp_locale_guard __current(loc);
-    lconv *lc = localeconv();
-    if (!lc)
-        return lc;
-    return loc.__store_lconv(lc);
-}
-size_t mbrlen_l( const char *__restrict s, size_t n,
-                 mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbrlen( s, n, ps );
-}
-size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                    size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbsrtowcs( dst, src, len, ps );
-}
-size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
-                  locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wcrtomb( s, wc, ps );
-}
-size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
-                  size_t n, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbrtowc( pwc, s, n, ps );
-}
-size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbsnrtowcs( dst, src, nms, len, ps );
-}
-size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
-                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wcsnrtombs( dst, src, nwc, len, ps );
-}
-wint_t btowc_l( int c, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return btowc( c );
-}
-int wctob_l( wint_t c, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wctob( c );
-}
-
-int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...)
-{
-    va_list ap;
-    va_start( ap, format );
-#if defined(_LIBCPP_MSVCRT)
-    // FIXME: Remove usage of internal CRT function and globals.
-    int result = __stdio_common_vsprintf(
-        _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
-        ret, n, format, loc, ap);
-#else
-    __libcpp_locale_guard __current(loc);
-    int result = vsnprintf( ret, n, format, ap );
-#endif
-    va_end(ap);
-    return result;
-}
-
-int asprintf_l( char **ret, locale_t loc, const char *format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
-    int result = vasprintf_l( ret, loc, format, ap );
-    va_end(ap);
-    return result;
-}
-int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap )
-{
-    __libcpp_locale_guard __current(loc);
-    return __libcpp_vasprintf( ret, format, ap );
-}
-
-#if !defined(_LIBCPP_MSVCRT)
-float strtof_l(const char* nptr, char** endptr, locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strtof(nptr, endptr);
-}
-
-long double strtold_l(const char* nptr, char** endptr, locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strtold(nptr, endptr);
-}
-#endif
-
-#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
-size_t strftime_l(char *ret, size_t n, const char *format, const struct tm *tm,
-                  locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strftime(ret, n, format, tm);
-}
-#endif
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <locale> 
+#include <cstdarg> // va_start, va_end 
+#include <memory> 
+#include <type_traits> 
+ 
+int __libcpp_vasprintf(char **sptr, const char *__restrict fmt, va_list ap); 
+ 
+using std::__libcpp_locale_guard; 
+ 
+// FIXME: base currently unused. Needs manual work to construct the new locale 
+locale_t newlocale( int mask, const char * locale, locale_t /*base*/ ) 
+{ 
+    return {_create_locale( LC_ALL, locale ), locale}; 
+} 
+ 
+decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l ) 
+{ 
+#if defined(_LIBCPP_MSVCRT) 
+  return ___mb_cur_max_l_func(__l); 
+#else 
+  __libcpp_locale_guard __current(__l); 
+  return MB_CUR_MAX; 
+#endif 
+} 
+ 
+lconv *localeconv_l( locale_t &loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    lconv *lc = localeconv(); 
+    if (!lc) 
+        return lc; 
+    return loc.__store_lconv(lc); 
+} 
+size_t mbrlen_l( const char *__restrict s, size_t n, 
+                 mbstate_t *__restrict ps, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return mbrlen( s, n, ps ); 
+} 
+size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src, 
+                    size_t len, mbstate_t *__restrict ps, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return mbsrtowcs( dst, src, len, ps ); 
+} 
+size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps, 
+                  locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return wcrtomb( s, wc, ps ); 
+} 
+size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s, 
+                  size_t n, mbstate_t *__restrict ps, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return mbrtowc( pwc, s, n, ps ); 
+} 
+size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src, 
+                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return mbsnrtowcs( dst, src, nms, len, ps ); 
+} 
+size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src, 
+                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return wcsnrtombs( dst, src, nwc, len, ps ); 
+} 
+wint_t btowc_l( int c, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return btowc( c ); 
+} 
+int wctob_l( wint_t c, locale_t loc ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return wctob( c ); 
+} 
+ 
+int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...) 
+{ 
+    va_list ap; 
+    va_start( ap, format ); 
+#if defined(_LIBCPP_MSVCRT) 
+    // FIXME: Remove usage of internal CRT function and globals. 
+    int result = __stdio_common_vsprintf( 
+        _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, 
+        ret, n, format, loc, ap); 
+#else 
+    __libcpp_locale_guard __current(loc); 
+    int result = vsnprintf( ret, n, format, ap ); 
+#endif 
+    va_end(ap); 
+    return result; 
+} 
+ 
+int asprintf_l( char **ret, locale_t loc, const char *format, ... ) 
+{ 
+    va_list ap; 
+    va_start( ap, format ); 
+    int result = vasprintf_l( ret, loc, format, ap ); 
+    va_end(ap); 
+    return result; 
+} 
+int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap ) 
+{ 
+    __libcpp_locale_guard __current(loc); 
+    return __libcpp_vasprintf( ret, format, ap ); 
+} 
+ 
+#if !defined(_LIBCPP_MSVCRT) 
+float strtof_l(const char* nptr, char** endptr, locale_t loc) { 
+  __libcpp_locale_guard __current(loc); 
+  return strtof(nptr, endptr); 
+} 
+ 
+long double strtold_l(const char* nptr, char** endptr, locale_t loc) { 
+  __libcpp_locale_guard __current(loc); 
+  return strtold(nptr, endptr); 
+} 
+#endif 
+ 
+#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800 
+size_t strftime_l(char *ret, size_t n, const char *format, const struct tm *tm, 
+                  locale_t loc) { 
+  __libcpp_locale_guard __current(loc); 
+  return strftime(ret, n, format, tm); 
+} 
+#endif 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/win32/new_win32.cpp b/contrib/libs/cxxsupp/libcxx/src/support/win32/new_win32.cpp
index 00eff4abf9..600c802a96 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/win32/new_win32.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/win32/new_win32.cpp
@@ -1,28 +1,28 @@
-#include <atomic>
-#include <new>
-
-namespace std {
-
-void
-__throw_bad_alloc()
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw bad_alloc();
-#endif
-}
-
-static std::atomic<std::new_handler> __new_handler;
-
-new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
-{
-    return __new_handler.exchange(handler);
-}
-
-new_handler
-get_new_handler() _NOEXCEPT
-{
-    return __new_handler.load();
-}
-
-}
\ No newline at end of file
+#include <atomic> 
+#include <new> 
+ 
+namespace std { 
+ 
+void 
+__throw_bad_alloc() 
+{ 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+    throw bad_alloc(); 
+#endif 
+} 
+ 
+static std::atomic<std::new_handler> __new_handler; 
+ 
+new_handler 
+set_new_handler(new_handler handler) _NOEXCEPT 
+{ 
+    return __new_handler.exchange(handler); 
+} 
+ 
+new_handler 
+get_new_handler() _NOEXCEPT 
+{ 
+    return __new_handler.load(); 
+} 
+ 
+} 
\ No newline at end of file
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/win32/support.cpp b/contrib/libs/cxxsupp/libcxx/src/support/win32/support.cpp
index 11702a788b..8532d623ca 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/win32/support.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/win32/support.cpp
@@ -1,166 +1,166 @@
-//===----------------------------------------------------------------------===//
-//
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstdarg> // va_start, va_end
-#include <cstddef> // size_t
-#include <cstdlib> // malloc
-#include <cstdio>  // vsprintf, vsnprintf
-#include <cstring> // strcpy, wcsncpy
-#include <cwchar>  // mbstate_t
-
-
-// Like sprintf, but when return value >= 0 it returns
-// a pointer to a malloc'd string in *sptr.
-// If return >= 0, use free to delete *sptr.
-int __libcpp_vasprintf( char **sptr, const char *__restrict format, va_list ap )
-{
-    *sptr = NULL;
-    // Query the count required.
-    va_list ap_copy;
-    va_copy(ap_copy, ap);
-    int count = _vsnprintf( NULL, 0, format, ap_copy );
-    va_end(ap_copy);
-    if (count < 0)
-        return count;
-    size_t buffer_size = static_cast<size_t>(count) + 1;
-    char* p = static_cast<char*>(malloc(buffer_size));
-    if ( ! p )
-        return -1;
-    // If we haven't used exactly what was required, something is wrong.
-    // Maybe bug in vsnprintf. Report the error and return.
-    if (_vsnprintf(p, buffer_size, format, ap) != count) {
-        free(p);
-        return -1;
-    }
-    // All good. This is returning memory to the caller not freeing it.
-    *sptr = p;
-    return count;
-}
-
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <cstdarg> // va_start, va_end 
+#include <cstddef> // size_t 
+#include <cstdlib> // malloc 
+#include <cstdio>  // vsprintf, vsnprintf 
+#include <cstring> // strcpy, wcsncpy 
+#include <cwchar>  // mbstate_t 
+ 
+ 
+// Like sprintf, but when return value >= 0 it returns 
+// a pointer to a malloc'd string in *sptr. 
+// If return >= 0, use free to delete *sptr. 
+int __libcpp_vasprintf( char **sptr, const char *__restrict format, va_list ap ) 
+{ 
+    *sptr = NULL; 
+    // Query the count required. 
+    va_list ap_copy; 
+    va_copy(ap_copy, ap); 
+    int count = _vsnprintf( NULL, 0, format, ap_copy ); 
+    va_end(ap_copy); 
+    if (count < 0) 
+        return count; 
+    size_t buffer_size = static_cast<size_t>(count) + 1; 
+    char* p = static_cast<char*>(malloc(buffer_size)); 
+    if ( ! p ) 
+        return -1; 
+    // If we haven't used exactly what was required, something is wrong. 
+    // Maybe bug in vsnprintf. Report the error and return. 
+    if (_vsnprintf(p, buffer_size, format, ap) != count) { 
+        free(p); 
+        return -1; 
+    } 
+    // All good. This is returning memory to the caller not freeing it. 
+    *sptr = p; 
+    return count; 
+} 
+ 
 // Returns >= 0: the number of wide characters found in the
 // multi byte sequence src (of src_size_bytes), that fit in the buffer dst
-// (of max_dest_chars elements size). The count returned excludes the
+// (of max_dest_chars elements size). The count returned excludes the 
 // null terminator. When dst is NULL, no characters are copied
-// and no "out" parameters are updated.
-// Returns (size_t) -1: an incomplete sequence encountered.
+// and no "out" parameters are updated. 
+// Returns (size_t) -1: an incomplete sequence encountered. 
 // Leaves *src pointing the next character to convert or NULL
-// if a null character was converted from *src.
-size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
-                   size_t src_size_bytes, size_t max_dest_chars, mbstate_t *__restrict ps )
-{
-    const size_t terminated_sequence = static_cast<size_t>(0);
-    //const size_t invalid_sequence = static_cast<size_t>(-1);
-    const size_t incomplete_sequence = static_cast< size_t>(-2);
-
-    size_t dest_converted = 0;
-    size_t source_converted = 0;
-    size_t source_remaining = src_size_bytes;
-    size_t result = 0;
-    bool have_result = false;
-
+// if a null character was converted from *src. 
+size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src, 
+                   size_t src_size_bytes, size_t max_dest_chars, mbstate_t *__restrict ps ) 
+{ 
+    const size_t terminated_sequence = static_cast<size_t>(0); 
+    //const size_t invalid_sequence = static_cast<size_t>(-1); 
+    const size_t incomplete_sequence = static_cast< size_t>(-2); 
+ 
+    size_t dest_converted = 0; 
+    size_t source_converted = 0; 
+    size_t source_remaining = src_size_bytes; 
+    size_t result = 0; 
+    bool have_result = false; 
+ 
     // If dst is null then max_dest_chars should be ignored according to the
     // standard.  Setting max_dest_chars to a large value has this effect.
     if (!dst)
         max_dest_chars = static_cast<size_t>(-1);
 
-    while ( source_remaining ) {
-        if ( dst && dest_converted >= max_dest_chars )
-            break;
-        // Converts one multi byte character.
-        // if result > 0, it's the size in bytes of that character.
-        // othewise if result is zero it indicates the null character has been found.
-        // otherwise it's an error and errno may be set.
-        size_t char_size = mbrtowc( dst ? dst + dest_converted : NULL, *src + source_converted, source_remaining, ps );
-        // Don't do anything to change errno from here on.
-        if ( char_size > 0 ) {
-            source_remaining -= char_size;
-            source_converted += char_size;
-            ++dest_converted;
-            continue;
-        }
-        result = char_size;
-        have_result = true;
-        break;
-    }
-    if ( dst ) {
-        if ( have_result && result == terminated_sequence )
-            *src = NULL;
-        else
-            *src += source_converted;
-    }
-    if ( have_result && result != terminated_sequence && result != incomplete_sequence )
-        return static_cast<size_t>(-1);
-
-    return dest_converted;
-}
-
-// Converts max_source_chars from the wide character buffer pointer to by *src,
-// into the multi byte character sequence buffer stored at dst which must be
-// dst_size_bytes bytes in size.
-// Returns >= 0: the number of bytes in the sequence
-// converted from *src, excluding the null terminator.
-// Returns size_t(-1) if an error occurs, also sets errno.
+    while ( source_remaining ) { 
+        if ( dst && dest_converted >= max_dest_chars ) 
+            break; 
+        // Converts one multi byte character. 
+        // if result > 0, it's the size in bytes of that character. 
+        // othewise if result is zero it indicates the null character has been found. 
+        // otherwise it's an error and errno may be set. 
+        size_t char_size = mbrtowc( dst ? dst + dest_converted : NULL, *src + source_converted, source_remaining, ps ); 
+        // Don't do anything to change errno from here on. 
+        if ( char_size > 0 ) { 
+            source_remaining -= char_size; 
+            source_converted += char_size; 
+            ++dest_converted; 
+            continue; 
+        } 
+        result = char_size; 
+        have_result = true; 
+        break; 
+    } 
+    if ( dst ) { 
+        if ( have_result && result == terminated_sequence ) 
+            *src = NULL; 
+        else 
+            *src += source_converted; 
+    } 
+    if ( have_result && result != terminated_sequence && result != incomplete_sequence ) 
+        return static_cast<size_t>(-1); 
+ 
+    return dest_converted; 
+} 
+ 
+// Converts max_source_chars from the wide character buffer pointer to by *src, 
+// into the multi byte character sequence buffer stored at dst which must be 
+// dst_size_bytes bytes in size. 
+// Returns >= 0: the number of bytes in the sequence 
+// converted from *src, excluding the null terminator. 
+// Returns size_t(-1) if an error occurs, also sets errno. 
 // If dst is NULL dst_size_bytes is ignored and no bytes are copied to dst
-// and no "out" parameters are updated.
-size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
-                   size_t max_source_chars, size_t dst_size_bytes, mbstate_t *__restrict ps )
-{
-    //const size_t invalid_sequence = static_cast<size_t>(-1);
-
-    size_t source_converted = 0;
-    size_t dest_converted = 0;
-    size_t dest_remaining = dst_size_bytes;
-    size_t char_size = 0;
-    const errno_t no_error = ( errno_t) 0;
-    errno_t result = ( errno_t ) 0;
-    bool have_result = false;
-    bool terminator_found = false;
-
+// and no "out" parameters are updated. 
+size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src, 
+                   size_t max_source_chars, size_t dst_size_bytes, mbstate_t *__restrict ps ) 
+{ 
+    //const size_t invalid_sequence = static_cast<size_t>(-1); 
+ 
+    size_t source_converted = 0; 
+    size_t dest_converted = 0; 
+    size_t dest_remaining = dst_size_bytes; 
+    size_t char_size = 0; 
+    const errno_t no_error = ( errno_t) 0; 
+    errno_t result = ( errno_t ) 0; 
+    bool have_result = false; 
+    bool terminator_found = false; 
+ 
     // If dst is null then dst_size_bytes should be ignored according to the
     // standard.  Setting dest_remaining to a large value has this effect.
     if (!dst)
         dest_remaining = static_cast<size_t>(-1);
 
-    while ( source_converted != max_source_chars ) {
-        if ( ! dest_remaining )
-            break;
-        wchar_t c = (*src)[source_converted];
-        if ( dst )
-            result = wcrtomb_s( &char_size, dst + dest_converted, dest_remaining, c, ps);
-        else
-            result = wcrtomb_s( &char_size, NULL, 0, c, ps);
+    while ( source_converted != max_source_chars ) { 
+        if ( ! dest_remaining ) 
+            break; 
+        wchar_t c = (*src)[source_converted]; 
+        if ( dst ) 
+            result = wcrtomb_s( &char_size, dst + dest_converted, dest_remaining, c, ps); 
+        else 
+            result = wcrtomb_s( &char_size, NULL, 0, c, ps); 
         // If result is zero there is no error and char_size contains the
-        // size of the multi-byte-sequence converted.
-        // Otherwise result indicates an errno type error.
-        if ( result == no_error ) {
-            if ( c == L'\0' ) {
-                terminator_found = true;
-                break;
-            }
-            ++source_converted;
-            if ( dst )
-                dest_remaining -= char_size;
-            dest_converted += char_size;
-            continue;
-        }
-        have_result = true;
-        break;
-    }
-    if ( dst ) {
-        if ( terminator_found )
-            *src = NULL;
-        else
-            *src = *src + source_converted;
-    }
-    if ( have_result && result != no_error ) {
-        errno = result;
-        return static_cast<size_t>(-1);
-    }
-
-    return dest_converted;
-}
+        // size of the multi-byte-sequence converted. 
+        // Otherwise result indicates an errno type error. 
+        if ( result == no_error ) { 
+            if ( c == L'\0' ) { 
+                terminator_found = true; 
+                break; 
+            } 
+            ++source_converted; 
+            if ( dst ) 
+                dest_remaining -= char_size; 
+            dest_converted += char_size; 
+            continue; 
+        } 
+        have_result = true; 
+        break; 
+    } 
+    if ( dst ) { 
+        if ( terminator_found ) 
+            *src = NULL; 
+        else 
+            *src = *src + source_converted; 
+    } 
+    if ( have_result && result != no_error ) { 
+        errno = result; 
+        return static_cast<size_t>(-1); 
+    } 
+ 
+    return dest_converted; 
+} 
diff --git a/contrib/libs/cxxsupp/libcxx/src/support/win32/thread_win32.cpp b/contrib/libs/cxxsupp/libcxx/src/support/win32/thread_win32.cpp
index 9506822da8..7d79153c88 100644
--- a/contrib/libs/cxxsupp/libcxx/src/support/win32/thread_win32.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/support/win32/thread_win32.cpp
@@ -1,310 +1,310 @@
-//===----------------------------------------------------------------------===//
-//
+//===----------------------------------------------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__threading_support>
-#define NOMINMAX
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <process.h>
-#include <fibersapi.h>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-static_assert(sizeof(__libcpp_mutex_t) == sizeof(SRWLOCK), "");
-static_assert(alignof(__libcpp_mutex_t) == alignof(SRWLOCK), "");
-
-static_assert(sizeof(__libcpp_recursive_mutex_t) == sizeof(CRITICAL_SECTION),
-              "");
-static_assert(alignof(__libcpp_recursive_mutex_t) == alignof(CRITICAL_SECTION),
-              "");
-
-static_assert(sizeof(__libcpp_condvar_t) == sizeof(CONDITION_VARIABLE), "");
-static_assert(alignof(__libcpp_condvar_t) == alignof(CONDITION_VARIABLE), "");
-
-static_assert(sizeof(__libcpp_exec_once_flag) == sizeof(INIT_ONCE), "");
-static_assert(alignof(__libcpp_exec_once_flag) == alignof(INIT_ONCE), "");
-
-static_assert(sizeof(__libcpp_thread_id) == sizeof(DWORD), "");
-static_assert(alignof(__libcpp_thread_id) == alignof(DWORD), "");
-
-static_assert(sizeof(__libcpp_thread_t) == sizeof(HANDLE), "");
-static_assert(alignof(__libcpp_thread_t) == alignof(HANDLE), "");
-
-static_assert(sizeof(__libcpp_tls_key) == sizeof(DWORD), "");
-static_assert(alignof(__libcpp_tls_key) == alignof(DWORD), "");
-
-static_assert(sizeof(__libcpp_semaphore_t) == sizeof(HANDLE), "");
-static_assert(alignof(__libcpp_semaphore_t) == alignof(HANDLE), "");
-
-// Mutex
-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
-{
-  InitializeCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
-{
-  EnterCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
-{
-  return TryEnterCriticalSection((LPCRITICAL_SECTION)__m) != 0;
-}
-
-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
-{
-  LeaveCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
-{
-  DeleteCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
-{
-  AcquireSRWLockExclusive((PSRWLOCK)__m);
-  return 0;
-}
-
-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
-{
-  return TryAcquireSRWLockExclusive((PSRWLOCK)__m) != 0;
-}
-
-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
-{
-  ReleaseSRWLockExclusive((PSRWLOCK)__m);
-  return 0;
-}
-
-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
-{
-  static_cast<void>(__m);
-  return 0;
-}
-
-// Condition Variable
-int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
-{
-  WakeConditionVariable((PCONDITION_VARIABLE)__cv);
-  return 0;
-}
-
-int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
-{
-  WakeAllConditionVariable((PCONDITION_VARIABLE)__cv);
-  return 0;
-}
-
-int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
-{
-  SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m, INFINITE, 0);
-  return 0;
-}
-
-int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               __libcpp_timespec_t *__ts)
-{
-  using namespace _VSTD::chrono;
-
-  auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec);
-  auto abstime =
-      system_clock::time_point(duration_cast<system_clock::duration>(duration));
-  auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now());
-
-  if (!SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m,
-                                 timeout_ms.count() > 0 ? timeout_ms.count()
-                                                        : 0,
-                                 0))
-    {
-      auto __ec = GetLastError();
-      return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec;
-    }
-  return 0;
-}
-
-int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
-{
-  static_cast<void>(__cv);
-  return 0;
-}
-
-// Execute Once
-static inline _LIBCPP_INLINE_VISIBILITY BOOL CALLBACK
-__libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter,
-                                      PVOID *__context)
-{
-  static_cast<void>(__init_once);
-  static_cast<void>(__context);
-
-  void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter);
-  init_routine();
-  return TRUE;
-}
-
-int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
-                          void (*__init_routine)(void))
-{
-  if (!InitOnceExecuteOnce((PINIT_ONCE)__flag, __libcpp_init_once_execute_once_thunk,
-                           reinterpret_cast<void *>(__init_routine), NULL))
-    return GetLastError();
-  return 0;
-}
-
-// Thread ID
-bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs,
-                              __libcpp_thread_id __rhs)
-{
-  return __lhs == __rhs;
-}
-
-bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs)
-{
-  return __lhs < __rhs;
-}
-
-// Thread
-struct __libcpp_beginthreadex_thunk_data
-{
-  void *(*__func)(void *);
-  void *__arg;
-};
-
-static inline _LIBCPP_INLINE_VISIBILITY unsigned WINAPI
-__libcpp_beginthreadex_thunk(void *__raw_data)
-{
-  auto *__data =
-      static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data);
-  auto *__func = __data->__func;
-  void *__arg = __data->__arg;
-  delete __data;
-  return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg)));
-}
-
-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
-  return *__t == 0;
-}
-
-int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
-                           void *__arg)
-{
-  auto *__data = new __libcpp_beginthreadex_thunk_data;
-  __data->__func = __func;
-  __data->__arg = __arg;
-
-  *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0,
-                                                 __libcpp_beginthreadex_thunk,
-                                                 __data, 0, nullptr));
-
-  if (*__t)
-    return 0;
-  return GetLastError();
-}
-
-__libcpp_thread_id __libcpp_thread_get_current_id()
-{
-  return GetCurrentThreadId();
-}
-
-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
-{
-  return GetThreadId(*__t);
-}
-
-int __libcpp_thread_join(__libcpp_thread_t *__t)
-{
-  if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED)
-    return GetLastError();
-  if (!CloseHandle(*__t))
-    return GetLastError();
-  return 0;
-}
-
-int __libcpp_thread_detach(__libcpp_thread_t *__t)
-{
-  if (!CloseHandle(*__t))
-    return GetLastError();
-  return 0;
-}
-
-void __libcpp_thread_yield()
-{
-  SwitchToThread();
-}
-
-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
-{
-  // round-up to the nearest millisecond
-  chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns);
-  // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx)
-  Sleep(__ms.count());
-}
-
-// Thread Local Storage
-int __libcpp_tls_create(__libcpp_tls_key* __key,
-                        void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*))
-{
-  DWORD index = FlsAlloc(__at_exit);
-  if (index == FLS_OUT_OF_INDEXES)
-    return GetLastError();
-  *__key = index;
-  return 0;
-}
-
-void *__libcpp_tls_get(__libcpp_tls_key __key)
-{
-  return FlsGetValue(__key);
-}
-
-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
-{
-  if (!FlsSetValue(__key, __p))
-    return GetLastError();
-  return 0;
-}
-
-// Semaphores
-bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)
-{
-  *(PHANDLE)__sem = CreateSemaphoreEx(nullptr, __init, _LIBCPP_SEMAPHORE_MAX,
-                                      nullptr, 0, SEMAPHORE_ALL_ACCESS);
-  return *__sem != nullptr;
-}
-
-bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)
-{
-  CloseHandle(*(PHANDLE)__sem);
-  return true;
-}
-
-bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)
-{
-  return ReleaseSemaphore(*(PHANDLE)__sem, 1, nullptr);
-}
-
-bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)
-{
-  return WaitForSingleObjectEx(*(PHANDLE)__sem, INFINITE, false) ==
-         WAIT_OBJECT_0;
-}
-
-bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem,
-                                   chrono::nanoseconds const& __ns)
-{
-  chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns);
-  return WaitForSingleObjectEx(*(PHANDLE)__sem, __ms.count(), false) ==
-         WAIT_OBJECT_0;
-}
-
-_LIBCPP_END_NAMESPACE_STD
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include <__threading_support> 
+#define NOMINMAX 
+#define WIN32_LEAN_AND_MEAN 
+#include <windows.h> 
+#include <process.h> 
+#include <fibersapi.h> 
+ 
+_LIBCPP_BEGIN_NAMESPACE_STD 
+ 
+static_assert(sizeof(__libcpp_mutex_t) == sizeof(SRWLOCK), ""); 
+static_assert(alignof(__libcpp_mutex_t) == alignof(SRWLOCK), ""); 
+ 
+static_assert(sizeof(__libcpp_recursive_mutex_t) == sizeof(CRITICAL_SECTION), 
+              ""); 
+static_assert(alignof(__libcpp_recursive_mutex_t) == alignof(CRITICAL_SECTION), 
+              ""); 
+ 
+static_assert(sizeof(__libcpp_condvar_t) == sizeof(CONDITION_VARIABLE), ""); 
+static_assert(alignof(__libcpp_condvar_t) == alignof(CONDITION_VARIABLE), ""); 
+ 
+static_assert(sizeof(__libcpp_exec_once_flag) == sizeof(INIT_ONCE), ""); 
+static_assert(alignof(__libcpp_exec_once_flag) == alignof(INIT_ONCE), ""); 
+ 
+static_assert(sizeof(__libcpp_thread_id) == sizeof(DWORD), ""); 
+static_assert(alignof(__libcpp_thread_id) == alignof(DWORD), ""); 
+ 
+static_assert(sizeof(__libcpp_thread_t) == sizeof(HANDLE), ""); 
+static_assert(alignof(__libcpp_thread_t) == alignof(HANDLE), ""); 
+ 
+static_assert(sizeof(__libcpp_tls_key) == sizeof(DWORD), ""); 
+static_assert(alignof(__libcpp_tls_key) == alignof(DWORD), ""); 
+ 
+static_assert(sizeof(__libcpp_semaphore_t) == sizeof(HANDLE), ""); 
+static_assert(alignof(__libcpp_semaphore_t) == alignof(HANDLE), ""); 
+ 
+// Mutex 
+int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) 
+{ 
+  InitializeCriticalSection((LPCRITICAL_SECTION)__m); 
+  return 0; 
+} 
+ 
+int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) 
+{ 
+  EnterCriticalSection((LPCRITICAL_SECTION)__m); 
+  return 0; 
+} 
+ 
+bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) 
+{ 
+  return TryEnterCriticalSection((LPCRITICAL_SECTION)__m) != 0; 
+} 
+ 
+int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m) 
+{ 
+  LeaveCriticalSection((LPCRITICAL_SECTION)__m); 
+  return 0; 
+} 
+ 
+int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) 
+{ 
+  DeleteCriticalSection((LPCRITICAL_SECTION)__m); 
+  return 0; 
+} 
+ 
+int __libcpp_mutex_lock(__libcpp_mutex_t *__m) 
+{ 
+  AcquireSRWLockExclusive((PSRWLOCK)__m); 
+  return 0; 
+} 
+ 
+bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) 
+{ 
+  return TryAcquireSRWLockExclusive((PSRWLOCK)__m) != 0; 
+} 
+ 
+int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) 
+{ 
+  ReleaseSRWLockExclusive((PSRWLOCK)__m); 
+  return 0; 
+} 
+ 
+int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) 
+{ 
+  static_cast<void>(__m); 
+  return 0; 
+} 
+ 
+// Condition Variable 
+int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) 
+{ 
+  WakeConditionVariable((PCONDITION_VARIABLE)__cv); 
+  return 0; 
+} 
+ 
+int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) 
+{ 
+  WakeAllConditionVariable((PCONDITION_VARIABLE)__cv); 
+  return 0; 
+} 
+ 
+int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) 
+{ 
+  SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m, INFINITE, 0); 
+  return 0; 
+} 
+ 
+int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, 
+                               __libcpp_timespec_t *__ts) 
+{ 
+  using namespace _VSTD::chrono; 
+ 
+  auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec); 
+  auto abstime = 
+      system_clock::time_point(duration_cast<system_clock::duration>(duration)); 
+  auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now()); 
+ 
+  if (!SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m, 
+                                 timeout_ms.count() > 0 ? timeout_ms.count() 
+                                                        : 0, 
+                                 0)) 
+    { 
+      auto __ec = GetLastError(); 
+      return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec; 
+    } 
+  return 0; 
+} 
+ 
+int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) 
+{ 
+  static_cast<void>(__cv); 
+  return 0; 
+} 
+ 
+// Execute Once 
+static inline _LIBCPP_INLINE_VISIBILITY BOOL CALLBACK 
+__libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter, 
+                                      PVOID *__context) 
+{ 
+  static_cast<void>(__init_once); 
+  static_cast<void>(__context); 
+ 
+  void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter); 
+  init_routine(); 
+  return TRUE; 
+} 
+ 
+int __libcpp_execute_once(__libcpp_exec_once_flag *__flag, 
+                          void (*__init_routine)(void)) 
+{ 
+  if (!InitOnceExecuteOnce((PINIT_ONCE)__flag, __libcpp_init_once_execute_once_thunk, 
+                           reinterpret_cast<void *>(__init_routine), NULL)) 
+    return GetLastError(); 
+  return 0; 
+} 
+ 
+// Thread ID 
+bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs, 
+                              __libcpp_thread_id __rhs) 
+{ 
+  return __lhs == __rhs; 
+} 
+ 
+bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs) 
+{ 
+  return __lhs < __rhs; 
+} 
+ 
+// Thread 
+struct __libcpp_beginthreadex_thunk_data 
+{ 
+  void *(*__func)(void *); 
+  void *__arg; 
+}; 
+ 
+static inline _LIBCPP_INLINE_VISIBILITY unsigned WINAPI 
+__libcpp_beginthreadex_thunk(void *__raw_data) 
+{ 
+  auto *__data = 
+      static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data); 
+  auto *__func = __data->__func; 
+  void *__arg = __data->__arg; 
+  delete __data; 
+  return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg))); 
+} 
+ 
+bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { 
+  return *__t == 0; 
+} 
+ 
+int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), 
+                           void *__arg) 
+{ 
+  auto *__data = new __libcpp_beginthreadex_thunk_data; 
+  __data->__func = __func; 
+  __data->__arg = __arg; 
+ 
+  *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, 
+                                                 __libcpp_beginthreadex_thunk, 
+                                                 __data, 0, nullptr)); 
+ 
+  if (*__t) 
+    return 0; 
+  return GetLastError(); 
+} 
+ 
+__libcpp_thread_id __libcpp_thread_get_current_id() 
+{ 
+  return GetCurrentThreadId(); 
+} 
+ 
+__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) 
+{ 
+  return GetThreadId(*__t); 
+} 
+ 
+int __libcpp_thread_join(__libcpp_thread_t *__t) 
+{ 
+  if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED) 
+    return GetLastError(); 
+  if (!CloseHandle(*__t)) 
+    return GetLastError(); 
+  return 0; 
+} 
+ 
+int __libcpp_thread_detach(__libcpp_thread_t *__t) 
+{ 
+  if (!CloseHandle(*__t)) 
+    return GetLastError(); 
+  return 0; 
+} 
+ 
+void __libcpp_thread_yield() 
+{ 
+  SwitchToThread(); 
+} 
+ 
+void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) 
+{ 
+  // round-up to the nearest millisecond 
+  chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns); 
+  // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx) 
+  Sleep(__ms.count()); 
+} 
+ 
+// Thread Local Storage 
+int __libcpp_tls_create(__libcpp_tls_key* __key, 
+                        void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)) 
+{ 
+  DWORD index = FlsAlloc(__at_exit); 
+  if (index == FLS_OUT_OF_INDEXES) 
+    return GetLastError(); 
+  *__key = index; 
+  return 0; 
+} 
+ 
+void *__libcpp_tls_get(__libcpp_tls_key __key) 
+{ 
+  return FlsGetValue(__key); 
+} 
+ 
+int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) 
+{ 
+  if (!FlsSetValue(__key, __p)) 
+    return GetLastError(); 
+  return 0; 
+} 
+ 
+// Semaphores 
+bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init) 
+{ 
+  *(PHANDLE)__sem = CreateSemaphoreEx(nullptr, __init, _LIBCPP_SEMAPHORE_MAX, 
+                                      nullptr, 0, SEMAPHORE_ALL_ACCESS); 
+  return *__sem != nullptr; 
+} 
+ 
+bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem) 
+{ 
+  CloseHandle(*(PHANDLE)__sem); 
+  return true; 
+} 
+ 
+bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem) 
+{ 
+  return ReleaseSemaphore(*(PHANDLE)__sem, 1, nullptr); 
+} 
+ 
+bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem) 
+{ 
+  return WaitForSingleObjectEx(*(PHANDLE)__sem, INFINITE, false) == 
+         WAIT_OBJECT_0; 
+} 
+ 
+bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, 
+                                   chrono::nanoseconds const& __ns) 
+{ 
+  chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns); 
+  return WaitForSingleObjectEx(*(PHANDLE)__sem, __ms.count(), false) == 
+         WAIT_OBJECT_0; 
+} 
+ 
+_LIBCPP_END_NAMESPACE_STD