libc++: Run clang-format from upstream and update to 9783f28cbb155e4a8d49c12e1c60ce14dcfaf0c7

commit_hash:ca4954fe054e5a7190ad11ab71bfc7ca0965bca2

30 files changed, 2344 insertions, 2633 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/access.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/access.h
index 502bd5e951c..263fdd637fd 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/access.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/access.h
@@ -32,138 +32,121 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template <class _Tp>
-  concept __can_borrow =
-    is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
+template <class _Tp>
+concept __can_borrow = is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
 } // namespace ranges
 
 // [range.access.begin]
 
 namespace ranges {
 namespace __begin {
-  template <class _Tp>
-  concept __member_begin =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
-    };
+template <class _Tp>
+concept __member_begin = __can_borrow<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
+};
 
-  void begin(auto&) = delete;
-  void begin(const auto&) = delete;
+void begin(auto&)       = delete;
+void begin(const auto&) = delete;
 
-  template <class _Tp>
-  concept __unqualified_begin =
-    !__member_begin<_Tp> &&
-    __can_borrow<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp && __t) {
+template <class _Tp>
+concept __unqualified_begin =
+    !__member_begin<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
       { _LIBCPP_AUTO_CAST(begin(__t)) } -> input_or_output_iterator;
     };
 
-  struct __fn {
-    template <class _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + 0;
-    }
-
-    template <class _Tp, size_t _Np>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + 0;
-    }
-
-    template <class _Tp>
-      requires __member_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.begin());
-    }
-
-    template <class _Tp>
-      requires __unqualified_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(begin(__t));
-    }
-
-    void operator()(auto&&) const = delete;
-  };
+struct __fn {
+  template <class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + 0;
+  }
+
+  template <class _Tp, size_t _Np>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + 0;
+  }
+
+  template <class _Tp>
+    requires __member_begin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin()))) {
+    return _LIBCPP_AUTO_CAST(__t.begin());
+  }
+
+  template <class _Tp>
+    requires __unqualified_begin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t)))) {
+    return _LIBCPP_AUTO_CAST(begin(__t));
+  }
+
+  void operator()(auto&&) const = delete;
+};
 } // namespace __begin
 
 inline namespace __cpo {
-  inline constexpr auto begin = __begin::__fn{};
+inline constexpr auto begin = __begin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.range]
 
 namespace ranges {
-  template <class _Tp>
-  using iterator_t = decltype(ranges::begin(std::declval<_Tp&>()));
+template <class _Tp>
+using iterator_t = decltype(ranges::begin(std::declval<_Tp&>()));
 } // namespace ranges
 
 // [range.access.end]
 
 namespace ranges {
 namespace __end {
-  template <class _Tp>
-  concept __member_end =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
+template <class _Tp>
+concept __member_end = __can_borrow<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  typename iterator_t<_Tp>;
+  { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp>>;
+};
+
+void end(auto&)       = delete;
+void end(const auto&) = delete;
+
+template <class _Tp>
+concept __unqualified_end =
+    !__member_end<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
       typename iterator_t<_Tp>;
-      { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp>>;
+      { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp>>;
     };
 
-  void end(auto&) = delete;
-  void end(const auto&) = delete;
+struct __fn {
+  template <class _Tp, size_t _Np>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + _Np;
+  }
 
   template <class _Tp>
-  concept __unqualified_end =
-    !__member_end<_Tp> &&
-    __can_borrow<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp && __t) {
-      typename iterator_t<_Tp>;
-      { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp>>;
-    };
+    requires __member_end<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end()))) {
+    return _LIBCPP_AUTO_CAST(__t.end());
+  }
 
-  struct __fn {
-    template <class _Tp, size_t _Np>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + _Np;
-    }
-
-    template <class _Tp>
-      requires __member_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.end());
-    }
-
-    template <class _Tp>
-      requires __unqualified_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(end(__t));
-    }
-
-    void operator()(auto&&) const = delete;
-  };
+  template <class _Tp>
+    requires __unqualified_end<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t)))) {
+    return _LIBCPP_AUTO_CAST(end(__t));
+  }
+
+  void operator()(auto&&) const = delete;
+};
 } // namespace __end
 
 inline namespace __cpo {
-  inline constexpr auto end = __end::__fn{};
+inline constexpr auto end = __end::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -171,27 +154,27 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cbegin {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::begin(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::begin(static_cast<const _Tp&&>(__t)))
-      { return          ranges::begin(static_cast<const _Tp&&>(__t)); }
-  };
+          -> decltype(ranges::begin(static_cast<const _Tp&&>(__t))) {
+    return ranges::begin(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cbegin
 
 inline namespace __cpo {
-  inline constexpr auto cbegin = __cbegin::__fn{};
+inline constexpr auto cbegin = __cbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -199,27 +182,27 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cend {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::end(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::end(static_cast<const _Tp&&>(__t)))
-      { return          ranges::end(static_cast<const _Tp&&>(__t)); }
-  };
+          -> decltype(ranges::end(static_cast<const _Tp&&>(__t))) {
+    return ranges::end(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cend
 
 inline namespace __cpo {
-  inline constexpr auto cend = __cend::__fn{};
+inline constexpr auto cend = __cend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/all.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/all.h
index 2c88f51b664..b735bdc7166 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/all.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/all.h
@@ -36,45 +36,38 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges::views {
 
 namespace __all {
-  struct __fn : __range_adaptor_closure<__fn> {
-    template<class _Tp>
-      requires ranges::view<decay_t<_Tp>>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Tp>
+    requires ranges::view<decay_t<_Tp>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t))))
-      -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t)))
-    {
-      return _LIBCPP_AUTO_CAST(std::forward<_Tp>(__t));
-    }
+          -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Tp>(__t));
+  }
 
-    template<class _Tp>
-      requires (!ranges::view<decay_t<_Tp>>) &&
-               requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; }
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::ref_view{std::forward<_Tp>(__t)}))
-    {
-      return ranges::ref_view{std::forward<_Tp>(__t)};
-    }
+  template <class _Tp>
+    requires(!ranges::view<decay_t<_Tp>>) && requires(_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::ref_view{std::forward<_Tp>(__t)})) {
+    return ranges::ref_view{std::forward<_Tp>(__t)};
+  }
 
-    template<class _Tp>
-      requires (!ranges::view<decay_t<_Tp>> &&
-                !requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; } &&
-                 requires (_Tp&& __t) { ranges::owning_view{std::forward<_Tp>(__t)}; })
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)}))
-    {
-      return ranges::owning_view{std::forward<_Tp>(__t)};
-    }
-  };
+  template <class _Tp>
+    requires(
+        !ranges::view<decay_t<_Tp>> && !requires(_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; } &&
+        requires(_Tp&& __t) { ranges::owning_view{std::forward<_Tp>(__t)}; })
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)})) {
+    return ranges::owning_view{std::forward<_Tp>(__t)};
+  }
+};
 } // namespace __all
 
 inline namespace __cpo {
-  inline constexpr auto all = __all::__fn{};
+inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
-template<ranges::viewable_range _Range>
+template <ranges::viewable_range _Range>
 using all_t = decltype(views::all(std::declval<_Range>()));
 
 } // namespace ranges::views
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/common_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/common_view.h
index f4cd1807490..4b5b04c9894 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/common_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/common_view.h
@@ -38,96 +38,99 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<view _View>
-  requires (!common_range<_View> && copyable<iterator_t<_View>>)
+template <view _View>
+  requires(!common_range<_View> && copyable<iterator_t<_View>>)
 class common_view : public view_interface<common_view<_View>> {
   _View __base_ = _View();
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  common_view() requires default_initializable<_View> = default;
+  _LIBCPP_HIDE_FROM_ABI common_view()
+    requires default_initializable<_View>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit common_view(_View __v) : __base_(std::move(__v)) { }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit common_view(_View __v) : __base_(std::move(__v)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
     if constexpr (random_access_range<_View> && sized_range<_View>)
       return ranges::begin(__base_);
     else
       return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
     if constexpr (random_access_range<const _View> && sized_range<const _View>)
       return ranges::begin(__base_);
     else
       return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
     if constexpr (random_access_range<_View> && sized_range<_View>)
       return ranges::begin(__base_) + ranges::size(__base_);
     else
       return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
     if constexpr (random_access_range<const _View> && sized_range<const _View>)
       return ranges::begin(__base_) + ranges::size(__base_);
     else
       return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
     return ranges::size(__base_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
     return ranges::size(__base_);
   }
 };
 
-template<class _Range>
-common_view(_Range&&)
-  -> common_view<views::all_t<_Range>>;
+template <class _Range>
+common_view(_Range&&) -> common_view<views::all_t<_Range>>;
 
-template<class _View>
+template <class _View>
 inline constexpr bool enable_borrowed_range<common_view<_View>> = enable_borrowed_range<_View>;
 
 namespace views {
 namespace __common {
-  struct __fn : __range_adaptor_closure<__fn> {
-    template<class _Range>
-      requires common_range<_Range>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range) const
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+    requires common_range<_Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
       noexcept(noexcept(views::all(std::forward<_Range>(__range))))
-      -> decltype(      views::all(std::forward<_Range>(__range)))
-      { return          views::all(std::forward<_Range>(__range)); }
+          -> decltype(views::all(std::forward<_Range>(__range))) {
+    return views::all(std::forward<_Range>(__range));
+  }
 
-    template<class _Range>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range) const
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
       noexcept(noexcept(common_view{std::forward<_Range>(__range)}))
-      -> decltype(      common_view{std::forward<_Range>(__range)})
-      { return          common_view{std::forward<_Range>(__range)}; }
-  };
+          -> decltype(common_view{std::forward<_Range>(__range)}) {
+    return common_view{std::forward<_Range>(__range)};
+  }
+};
 } // namespace __common
 
 inline namespace __cpo {
-  inline constexpr auto common = __common::__fn{};
+inline constexpr auto common = __common::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/concepts.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/concepts.h
index b87a7146061..674a3f359ff 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/concepts.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/concepts.h
@@ -41,100 +41,92 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-  // [range.range]
+// [range.range]
 
-  template <class _Tp>
-  concept range = requires(_Tp& __t) {
-    ranges::begin(__t); // sometimes equality-preserving
-    ranges::end(__t);
-  };
+template <class _Tp>
+concept range = requires(_Tp& __t) {
+  ranges::begin(__t); // sometimes equality-preserving
+  ranges::end(__t);
+};
 
-  template <class _Tp>
-  concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
 
-  template<class _Range>
-  concept borrowed_range = range<_Range> &&
-    (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
+template <class _Range>
+concept borrowed_range =
+    range<_Range> && (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
 
-  // `iterator_t` defined in <__ranges/access.h>
+// `iterator_t` defined in <__ranges/access.h>
 
-  template <range _Rp>
-  using sentinel_t = decltype(ranges::end(std::declval<_Rp&>()));
+template <range _Rp>
+using sentinel_t = decltype(ranges::end(std::declval<_Rp&>()));
 
-  template <range _Rp>
-  using range_difference_t = iter_difference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_difference_t = iter_difference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_value_t = iter_value_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_value_t = iter_value_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_reference_t = iter_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_reference_t = iter_reference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_common_reference_t = iter_common_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_common_reference_t = iter_common_reference_t<iterator_t<_Rp>>;
 
-  // [range.sized]
-  template <class _Tp>
-  concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); };
+// [range.sized]
+template <class _Tp>
+concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); };
 
-  template<sized_range _Rp>
-  using range_size_t = decltype(ranges::size(std::declval<_Rp&>()));
+template <sized_range _Rp>
+using range_size_t = decltype(ranges::size(std::declval<_Rp&>()));
 
-  // `disable_sized_range` defined in `<__ranges/size.h>`
+// `disable_sized_range` defined in `<__ranges/size.h>`
 
-  // [range.view], views
+// [range.view], views
 
-  // `enable_view` defined in <__ranges/enable_view.h>
-  // `view_base` defined in <__ranges/enable_view.h>
+// `enable_view` defined in <__ranges/enable_view.h>
+// `view_base` defined in <__ranges/enable_view.h>
 
-  template <class _Tp>
-  concept view =
-    range<_Tp> &&
-    movable<_Tp> &&
-    enable_view<_Tp>;
+template <class _Tp>
+concept view = range<_Tp> && movable<_Tp> && enable_view<_Tp>;
 
-  template <class _Range>
-  concept __simple_view =
-    view<_Range> && range<const _Range> &&
-    same_as<iterator_t<_Range>, iterator_t<const _Range>> &&
+template <class _Range>
+concept __simple_view =
+    view<_Range> && range<const _Range> && same_as<iterator_t<_Range>, iterator_t<const _Range>> &&
     same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;
 
-  // [range.refinements], other range refinements
-  template <class _Rp, class _Tp>
-  concept output_range = range<_Rp> && output_iterator<iterator_t<_Rp>, _Tp>;
+// [range.refinements], other range refinements
+template <class _Rp, class _Tp>
+concept output_range = range<_Rp> && output_iterator<iterator_t<_Rp>, _Tp>;
 
-  template <class _Tp>
-  concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
 
-  template <class _Tp>
-  concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
 
-  template <class _Tp>
-  concept random_access_range =
-      bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept random_access_range = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
 
-  template<class _Tp>
-  concept contiguous_range =
-    random_access_range<_Tp> &&
-    contiguous_iterator<iterator_t<_Tp>> &&
-    requires(_Tp& __t) {
-      { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
-    };
+template <class _Tp>
+concept contiguous_range = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>> && requires(_Tp& __t) {
+  { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
+};
 
-  template <class _Tp>
-  concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
+template <class _Tp>
+concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
 
-  template <class _Tp>
-  inline constexpr bool __is_std_initializer_list = false;
+template <class _Tp>
+inline constexpr bool __is_std_initializer_list = false;
 
-  template <class _Ep>
-  inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
+template <class _Ep>
+inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
 
-  template <class _Tp>
-  concept viewable_range =
+template <class _Tp>
+concept viewable_range =
     range<_Tp> &&
     ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>) ||
      (!view<remove_cvref_t<_Tp>> &&
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/counted.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/counted.h
index 882f90b1ed8..33763489576 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/counted.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/counted.h
@@ -37,41 +37,43 @@ namespace ranges::views {
 
 namespace __counted {
 
-  struct __fn {
-    template<contiguous_iterator _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(span(std::to_address(__it), static_cast<size_t>(__count))))
-      // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
-      { return          span(std::to_address(__it), static_cast<size_t>(__count)); }
-
-    template<random_access_iterator _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(subrange(__it, __it + __count)))
-      -> decltype(      subrange(__it, __it + __count))
-      { return          subrange(__it, __it + __count); }
-
-    template<class _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(subrange(counted_iterator(std::move(__it), __count), default_sentinel)))
-      -> decltype(      subrange(counted_iterator(std::move(__it), __count), default_sentinel))
-      { return          subrange(counted_iterator(std::move(__it), __count), default_sentinel); }
-
-    template<class _It, convertible_to<iter_difference_t<_It>> _Diff>
-      requires input_or_output_iterator<decay_t<_It>>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_It&& __it, _Diff&& __count) const
+struct __fn {
+  template <contiguous_iterator _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  __go(_It __it,
+       iter_difference_t<_It> __count) noexcept(noexcept(span(std::to_address(__it), static_cast<size_t>(__count))))
+  // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
+  {
+    return span(std::to_address(__it), static_cast<size_t>(__count));
+  }
+
+  template <random_access_iterator _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  __go(_It __it, iter_difference_t<_It> __count) noexcept(noexcept(subrange(__it, __it + __count)))
+      -> decltype(subrange(__it, __it + __count)) {
+    return subrange(__it, __it + __count);
+  }
+
+  template <class _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_It __it, iter_difference_t<_It> __count) noexcept(
+      noexcept(subrange(counted_iterator(std::move(__it), __count), default_sentinel)))
+      -> decltype(subrange(counted_iterator(std::move(__it), __count), default_sentinel)) {
+    return subrange(counted_iterator(std::move(__it), __count), default_sentinel);
+  }
+
+  template <class _It, convertible_to<iter_difference_t<_It>> _Diff>
+    requires input_or_output_iterator<decay_t<_It>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_It&& __it, _Diff&& __count) const
       noexcept(noexcept(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))))
-      -> decltype(      __go(std::forward<_It>(__it), std::forward<_Diff>(__count)))
-      { return          __go(std::forward<_It>(__it), std::forward<_Diff>(__count)); }
-  };
+          -> decltype(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))) {
+    return __go(std::forward<_It>(__it), std::forward<_Diff>(__count));
+  }
+};
 
 } // namespace __counted
 
 inline namespace __cpo {
-  inline constexpr auto counted = __counted::__fn{};
+inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace ranges::views
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/data.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/data.h
index 6c099085af3..18002bb52cc 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/data.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/data.h
@@ -36,44 +36,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __data {
-  template <class _Tp>
-  concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
-
-  template <class _Tp>
-  concept __member_data =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.data()) } -> __ptr_to_object;
-    };
-
-  template <class _Tp>
-  concept __ranges_begin_invocable =
-    !__member_data<_Tp> &&
-    __can_borrow<_Tp> &&
-    requires(_Tp&& __t) {
-      { ranges::begin(__t) } -> contiguous_iterator;
-    };
-
-  struct __fn {
-    template <__member_data _Tp>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-        noexcept(noexcept(__t.data())) {
-      return __t.data();
-    }
-
-    template<__ranges_begin_invocable _Tp>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-        noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
-      return std::to_address(ranges::begin(__t));
-    }
-  };
+template <class _Tp>
+concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
+
+template <class _Tp>
+concept __member_data = __can_borrow<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.data()) } -> __ptr_to_object;
+};
+
+template <class _Tp>
+concept __ranges_begin_invocable = !__member_data<_Tp> && __can_borrow<_Tp> && requires(_Tp&& __t) {
+  { ranges::begin(__t) } -> contiguous_iterator;
+};
+
+struct __fn {
+  template <__member_data _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(__t.data())) {
+    return __t.data();
+  }
+
+  template <__ranges_begin_invocable _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
+    return std::to_address(ranges::begin(__t));
+  }
+};
 } // namespace __data
 
 inline namespace __cpo {
-  inline constexpr auto data = __data::__fn{};
+inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -81,27 +72,27 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cdata {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::data(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::data(static_cast<const _Tp&&>(__t)))
-      { return          ranges::data(static_cast<const _Tp&&>(__t)); }
-  };
+          -> decltype(ranges::data(static_cast<const _Tp&&>(__t))) {
+    return ranges::data(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cdata
 
 inline namespace __cpo {
-  inline constexpr auto cdata = __cdata::__fn{};
+inline constexpr auto cdata = __cdata::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/drop_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/drop_view.h
index f10476f0011..2b89c6877a7 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/drop_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/drop_view.h
@@ -56,89 +56,91 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<view _View>
-  class drop_view
-    : public view_interface<drop_view<_View>>
-  {
-    // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
-    // amortized O(1) begin() method. If this is an input_range, then we cannot cache
-    // begin because begin is not equality preserving.
-    // Note: drop_view<input-range>::begin() is still trivially amortized O(1) because
-    // one can't call begin() on it more than once.
-    static constexpr bool _UseCache = forward_range<_View> && !(random_access_range<_View> && sized_range<_View>);
-    using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
-    range_difference_t<_View> __count_ = 0;
-    _View __base_ = _View();
+template <view _View>
+class drop_view : public view_interface<drop_view<_View>> {
+  // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
+  // amortized O(1) begin() method. If this is an input_range, then we cannot cache
+  // begin because begin is not equality preserving.
+  // Note: drop_view<input-range>::begin() is still trivially amortized O(1) because
+  // one can't call begin() on it more than once.
+  static constexpr bool _UseCache = forward_range<_View> && !(random_access_range<_View> && sized_range<_View>);
+  using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+  range_difference_t<_View> __count_               = 0;
+  _View __base_                                    = _View();
 
 public:
-    _LIBCPP_HIDE_FROM_ABI drop_view() requires default_initializable<_View> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_view(_View __base, range_difference_t<_View> __count)
-      : __count_(__count)
-      , __base_(std::move(__base))
-    {
-      _LIBCPP_ASSERT_UNCATEGORIZED(__count_ >= 0, "count must be greater than or equal to zero.");
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin()
-      requires (!(__simple_view<_View> &&
-                  random_access_range<const _View> && sized_range<const _View>))
-    {
-      if constexpr (_UseCache)
-        if (__cached_begin_.__has_value())
-          return *__cached_begin_;
-
-      auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
-      if constexpr (_UseCache)
-        __cached_begin_.__emplace(__tmp);
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const
-      requires random_access_range<const _View> && sized_range<const _View>
-    {
-      return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end()
-      requires (!__simple_view<_View>)
-    { return ranges::end(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const
-      requires range<const _View>
-    { return ranges::end(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __size(auto& __self) {
-      const auto __s = ranges::size(__self.__base_);
-      const auto __c = static_cast<decltype(__s)>(__self.__count_);
-      return __s < __c ? 0 : __s - __c;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size()
-      requires sized_range<_View>
-    { return __size(*this); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires sized_range<const _View>
-    { return __size(*this); }
-  };
-
-template<class _Range>
+  _LIBCPP_HIDE_FROM_ABI drop_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  drop_view(_View __base, range_difference_t<_View> __count)
+      : __count_(__count), __base_(std::move(__base)) {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count_ >= 0, "count must be greater than or equal to zero.");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!(__simple_view<_View> && random_access_range<const _View> && sized_range<const _View>))
+  {
+    if constexpr (_UseCache)
+      if (__cached_begin_.__has_value())
+        return *__cached_begin_;
+
+    auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
+    if constexpr (_UseCache)
+      __cached_begin_.__emplace(__tmp);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires random_access_range<const _View> && sized_range<const _View>
+  {
+    return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    return ranges::end(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    return ranges::end(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __size(auto& __self) {
+    const auto __s = ranges::size(__self.__base_);
+    const auto __c = static_cast<decltype(__s)>(__self.__count_);
+    return __s < __c ? 0 : __s - __c;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return __size(*this);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return __size(*this);
+  }
+};
+
+template <class _Range>
 drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
 
-template<class _Tp>
+template <class _Tp>
 inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 namespace views {
@@ -203,72 +205,55 @@ struct __fn {
   // [range.drop.overview]: the `empty_view` case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
     requires __is_empty_view<remove_cvref_t<_Range>>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&&) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
-    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
-    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&&) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+          -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range));
+  }
 
   // [range.drop.overview]: the `span | basic_string_view | iota_view | subrange (StoreSize == false)` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_passthrough_specialization<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(__passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              )))
-    -> decltype(      __passthrough_type_t<_RawRange>(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              ))
-    { return          __passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              ); }
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_passthrough_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __rng, _Np&& __n) const
+      noexcept(noexcept(__passthrough_type_t<_RawRange>(
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)), ranges::end(__rng))))
+          -> decltype(__passthrough_type_t<_RawRange>(
+              // Note: deliberately not forwarding `__rng` to guard against double moves.
+              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+              ranges::end(__rng))) {
+    return __passthrough_type_t<_RawRange>(
+        ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)), ranges::end(__rng));
+  }
 
   // [range.drop.overview]: the `subrange (StoreSize == true)` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_subrange_specialization_with_store_size<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(_RawRange(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(ranges::distance(__rng) -
-                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
-                              )))
-    -> decltype(      _RawRange(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(ranges::distance(__rng) -
-                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
-                              ))
-    {
-      // Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
-      // expression used in the `noexcept` clause and the return statement).
-      auto __dist = ranges::distance(__rng);
-      auto __clamped = std::min<_Dist>(__dist, std::forward<_Np>(__n));
-      return          _RawRange(
-                              ranges::begin(__rng) + __clamped,
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(__dist - __clamped)
-                              );}
-// clang-format off
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_subrange_specialization_with_store_size<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(
+      _RawRange(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+                ranges::end(__rng),
+                std::__to_unsigned_like(ranges::distance(__rng) -
+                                        std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))))))
+      -> decltype(_RawRange(
+          // Note: deliberately not forwarding `__rng` to guard against double moves.
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+          ranges::end(__rng),
+          std::__to_unsigned_like(ranges::distance(__rng) -
+                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))))) {
+    // Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
+    // expression used in the `noexcept` clause and the return statement).
+    auto __dist    = ranges::distance(__rng);
+    auto __clamped = std::min<_Dist>(__dist, std::forward<_Np>(__n));
+    return _RawRange(ranges::begin(__rng) + __clamped, ranges::end(__rng), std::__to_unsigned_like(__dist - __clamped));
+  }
+  // clang-format off
 #if _LIBCPP_STD_VER >= 23
   // [range.drop.overview]: the `repeat_view` "_RawRange models sized_range" case.
   template <class _Range,
@@ -293,42 +278,38 @@ struct __fn {
     -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
     { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
 #endif
-// clang-format on
+  // clang-format on
 
   // [range.drop.overview]: the "otherwise" case.
-  template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
-            class _RawRange = remove_cvref_t<_Range>>
-    // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
-    // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
-#if _LIBCPP_STD_VER >= 23
-                __is_repeat_specialization<_RawRange> ||
-#endif
-               (__is_subrange_specialization_with_store_size<_RawRange> &&
-               sized_range<_RawRange> &&
-                random_access_range<_RawRange>) ||
-               (__is_passthrough_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>)
-             ))
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&& __n) const
-    noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
-    -> decltype(      drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
-    { return          drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np, class _RawRange = remove_cvref_t<_Range>>
+  // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
+  // overloads.
+    requires(
+        !(__is_empty_view<_RawRange> ||
+#  if _LIBCPP_STD_VER >= 23
+          __is_repeat_specialization<_RawRange> ||
+#  endif
+          (__is_subrange_specialization_with_store_size<_RawRange> && sized_range<_RawRange> &&
+           random_access_range<_RawRange>) ||
+          (__is_passthrough_specialization<_RawRange> && sized_range<_RawRange> && random_access_range<_RawRange>)))
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+          -> decltype(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
+    return drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
+  }
 
   template <class _Np>
     requires constructible_from<decay_t<_Np>, _Np>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Np&& __n) const
-    noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
-  { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Np&& __n) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n)));
+  }
 };
 
 } // namespace __drop
 
 inline namespace __cpo {
-  inline constexpr auto drop = __drop::__fn{};
+inline constexpr auto drop = __drop::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/empty.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/empty.h
index 64996f4a6f7..acd55dae224 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/empty.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/empty.h
@@ -28,50 +28,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __empty {
-  template <class _Tp>
-  concept __member_empty =
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      bool(__t.empty());
-    };
-
-  template<class _Tp>
-  concept __can_invoke_size =
-    !__member_empty<_Tp> &&
-    requires(_Tp&& __t) { ranges::size(__t); };
-
-  template <class _Tp>
-  concept __can_compare_begin_end =
-    !__member_empty<_Tp> &&
-    !__can_invoke_size<_Tp> &&
-    requires(_Tp&& __t) {
-      bool(ranges::begin(__t) == ranges::end(__t));
-      { ranges::begin(__t) } -> forward_iterator;
-    };
-
-  struct __fn {
-    template <__member_empty _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(__t.empty()))) {
-      return bool(__t.empty());
-    }
-
-    template <__can_invoke_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::size(__t))) {
-      return ranges::size(__t) == 0;
-    }
-
-    template<__can_compare_begin_end _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
-      return ranges::begin(__t) == ranges::end(__t);
-    }
-  };
+template <class _Tp>
+concept __member_empty = __workaround_52970<_Tp> && requires(_Tp&& __t) { bool(__t.empty()); };
+
+template <class _Tp>
+concept __can_invoke_size = !__member_empty<_Tp> && requires(_Tp&& __t) { ranges::size(__t); };
+
+template <class _Tp>
+concept __can_compare_begin_end = !__member_empty<_Tp> && !__can_invoke_size<_Tp> && requires(_Tp&& __t) {
+  bool(ranges::begin(__t) == ranges::end(__t));
+  { ranges::begin(__t) } -> forward_iterator;
+};
+
+struct __fn {
+  template <__member_empty _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const noexcept(noexcept(bool(__t.empty()))) {
+    return bool(__t.empty());
+  }
+
+  template <__can_invoke_size _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const noexcept(noexcept(ranges::size(__t))) {
+    return ranges::size(__t) == 0;
+  }
+
+  template <__can_compare_begin_end _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
+      noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
+    return ranges::begin(__t) == ranges::end(__t);
+  }
+};
 } // namespace __empty
 
 inline namespace __cpo {
-  inline constexpr auto empty = __empty::__fn{};
+inline constexpr auto empty = __empty::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/empty_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/empty_view.h
index bb445b4e6f9..6c04b0200c3 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/empty_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/empty_view.h
@@ -25,26 +25,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _Tp>
-    requires is_object_v<_Tp>
-  class empty_view : public view_interface<empty_view<_Tp>> {
-  public:
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
-  };
-
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
-
-  namespace views {
-
-  template <class _Tp>
-  inline constexpr empty_view<_Tp> empty{};
-
-  } // namespace views
+template <class _Tp>
+  requires is_object_v<_Tp>
+class empty_view : public view_interface<empty_view<_Tp>> {
+public:
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
+};
+
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
+
+namespace views {
+
+template <class _Tp>
+inline constexpr empty_view<_Tp> empty{};
+
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/enable_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/enable_view.h
index 0c1dff3821e..f570926eb67 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/enable_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/enable_view.h
@@ -27,19 +27,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-struct view_base { };
+struct view_base {};
 
-template<class _Derived>
+template <class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface;
 
-template<class _Op, class _Yp>
+template <class _Op, class _Yp>
   requires is_convertible_v<_Op*, view_interface<_Yp>*>
 void __is_derived_from_view_interface(const _Op*, const view_interface<_Yp>*);
 
 template <class _Tp>
-inline constexpr bool enable_view = derived_from<_Tp, view_base> ||
-  requires { ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr); };
+inline constexpr bool enable_view = derived_from<_Tp, view_base> || requires {
+  ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr);
+};
 
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/filter_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/filter_view.h
index 1cef94ca674..08d50ab0110 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/filter_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/filter_view.h
@@ -49,212 +49,199 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view : public view_interface<filter_view<_View, _Pred>> {
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-    _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
-
-    // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
-    // the underlying range is at least a forward_range.
-    static constexpr bool _UseCache = forward_range<_View>;
-    using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
-
-    class __iterator;
-    class __sentinel;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    filter_view() requires default_initializable<_View> && default_initializable<_Pred> = default;
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 filter_view(_View __base, _Pred __pred)
-        : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
-
-    template<class _Vp = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_Vp> { return __base_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Pred const& pred() const { return *__pred_; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator begin() {
-      _LIBCPP_ASSERT_UNCATEGORIZED(
-          __pred_.__has_value(),
-          "Trying to call begin() on a filter_view that does not have a valid predicate.");
-      if constexpr (_UseCache) {
-        if (!__cached_begin_.__has_value()) {
-          __cached_begin_.__emplace(ranges::find_if(__base_, std::ref(*__pred_)));
-        }
-        return {*this, *__cached_begin_};
-      } else {
-        return {*this, ranges::find_if(__base_, std::ref(*__pred_))};
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class filter_view : public view_interface<filter_view<_View, _Pred>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
+
+  // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
+  // the underlying range is at least a forward_range.
+  static constexpr bool _UseCache = forward_range<_View>;
+  using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+
+  class __iterator;
+  class __sentinel;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI filter_view()
+    requires default_initializable<_View> && default_initializable<_Pred>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 filter_view(_View __base, _Pred __pred)
+      : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
+
+  template <class _Vp = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_Vp>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Pred const& pred() const { return *__pred_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        __pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");
+    if constexpr (_UseCache) {
+      if (!__cached_begin_.__has_value()) {
+        __cached_begin_.__emplace(ranges::find_if(__base_, std::ref(*__pred_)));
       }
+      return {*this, *__cached_begin_};
+    } else {
+      return {*this, ranges::find_if(__base_, std::ref(*__pred_))};
     }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() {
-      if constexpr (common_range<_View>)
-        return __iterator{*this, ranges::end(__base_)};
-      else
-        return __sentinel{*this};
-    }
-  };
-
-  template<class _Range, class _Pred>
-  filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
-
-  template<class _View>
-  struct __filter_iterator_category { };
-
-  template<forward_range _View>
-  struct __filter_iterator_category<_View> {
-    using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
-    using iterator_category =
-      _If<derived_from<_Cat, bidirectional_iterator_tag>, bidirectional_iterator_tag,
-      _If<derived_from<_Cat, forward_iterator_tag>,       forward_iterator_tag,
-      /* else */                                          _Cat
-    >>;
-  };
-
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
-
-  public:
-    _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
-    _LIBCPP_NO_UNIQUE_ADDRESS filter_view* __parent_ = nullptr;
-
-    using iterator_concept =
-      _If<bidirectional_range<_View>, bidirectional_iterator_tag,
-      _If<forward_range<_View>,       forward_iterator_tag,
-      /* else */                      input_iterator_tag
-    >>;
-    // using iterator_category = inherited;
-    using value_type = range_value_t<_View>;
-    using difference_type = range_difference_t<_View>;
-
-    _LIBCPP_HIDE_FROM_ABI
-    __iterator() requires default_initializable<iterator_t<_View>> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
-      : __current_(std::move(__current)), __parent_(std::addressof(__parent))
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> base() && { return std::move(__current_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr range_reference_t<_View> operator*() const { return *__current_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> operator->() const
-      requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
-    {
-      return __current_;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator++() {
-      __current_ = ranges::find_if(std::move(++__current_), ranges::end(__parent_->__base_),
-                                   std::ref(*__parent_->__pred_));
-      return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator++(int) { ++*this; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator++(int) requires forward_range<_View> {
-      auto __tmp = *this;
-      ++*this;
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator--() requires bidirectional_range<_View> {
-      do {
-        --__current_;
-      } while (!std::invoke(*__parent_->__pred_, *__current_));
-      return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator--(int) requires bidirectional_range<_View> {
-      auto __tmp = *this;
-      --*this;
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
-      requires equality_comparable<iterator_t<_View>>
-    {
-      return __x.__current_ == __y.__current_;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr range_rvalue_reference_t<_View> iter_move(__iterator const& __it)
-      noexcept(noexcept(ranges::iter_move(__it.__current_)))
-    {
-      return ranges::iter_move(__it.__current_);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(__iterator const& __x, __iterator const& __y)
-      noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
-      requires indirectly_swappable<iterator_t<_View>>
-    {
-      return ranges::iter_swap(__x.__current_, __y.__current_);
-    }
-  };
-
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__sentinel {
-  public:
-    sentinel_t<_View> __end_ = sentinel_t<_View>();
-
-    _LIBCPP_HIDE_FROM_ABI
-    __sentinel() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(filter_view& __parent)
-      : __end_(ranges::end(__parent.__base_))
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr sentinel_t<_View> base() const { return __end_; }
-
-    _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-    operator==(__iterator const& __x, __sentinel const& __y) {
-      return __x.__current_ == __y.__end_;
-    }
-  };
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>)
+      return __iterator{*this, ranges::end(__base_)};
+    else
+      return __sentinel{*this};
+  }
+};
+
+template <class _Range, class _Pred>
+filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
+
+template <class _View>
+struct __filter_iterator_category {};
+
+template <forward_range _View>
+struct __filter_iterator_category<_View> {
+  using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+  using iterator_category =
+      _If<derived_from<_Cat, bidirectional_iterator_tag>,
+          bidirectional_iterator_tag,
+          _If<derived_from<_Cat, forward_iterator_tag>,
+              forward_iterator_tag,
+              /* else */ _Cat >>;
+};
+
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
+public:
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS filter_view* __parent_       = nullptr;
+
+  using iterator_concept =
+      _If<bidirectional_range<_View>,
+          bidirectional_iterator_tag,
+          _If<forward_range<_View>,
+              forward_iterator_tag,
+              /* else */ input_iterator_tag >>;
+  // using iterator_category = inherited;
+  using value_type      = range_value_t<_View>;
+  using difference_type = range_difference_t<_View>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires default_initializable<iterator_t<_View>>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
+      : __current_(std::move(__current)), __parent_(std::addressof(__parent)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() && { return std::move(__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr range_reference_t<_View> operator*() const { return *__current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> operator->() const
+    requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
+  {
+    return __current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    __current_ =
+        ranges::find_if(std::move(++__current_), ranges::end(__parent_->__base_), std::ref(*__parent_->__pred_));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires forward_range<_View>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_View>
+  {
+    do {
+      --__current_;
+    } while (!std::invoke(*__parent_->__pred_, *__current_));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_View>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
+    requires equality_comparable<iterator_t<_View>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_rvalue_reference_t<_View>
+  iter_move(__iterator const& __it) noexcept(noexcept(ranges::iter_move(__it.__current_))) {
+    return ranges::iter_move(__it.__current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(__iterator const& __x,
+            __iterator const& __y) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+    requires indirectly_swappable<iterator_t<_View>>
+  {
+    return ranges::iter_swap(__x.__current_, __y.__current_);
+  }
+};
+
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class filter_view<_View, _Pred>::__sentinel {
+public:
+  sentinel_t<_View> __end_ = sentinel_t<_View>();
+
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(filter_view& __parent) : __end_(ranges::end(__parent.__base_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_View> base() const { return __end_; }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {
+    return __x.__current_ == __y.__end_;
+  }
+};
 
 namespace views {
 namespace __filter {
-  struct __fn {
-    template<class _Range, class _Pred>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
+struct __fn {
+  template <class _Range, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
       noexcept(noexcept(filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))))
-      -> decltype(      filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred)))
-      { return          filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred)); }
-
-    template<class _Pred>
-      requires constructible_from<decay_t<_Pred>, _Pred>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Pred&& __pred) const
-      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>)
-    { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred))); }
-  };
+          -> decltype(filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))) {
+    return filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred));
+  }
+
+  template <class _Pred>
+    requires constructible_from<decay_t<_Pred>, _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
+  }
+};
 } // namespace __filter
 
 inline namespace __cpo {
-  inline constexpr auto filter = __filter::__fn{};
+inline constexpr auto filter = __filter::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/iota_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/iota_view.h
index ccf0c7a8e8d..c6c9618cfe6 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/iota_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/iota_view.h
@@ -46,36 +46,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _Int>
-  struct __get_wider_signed {
-    consteval static auto __call() {
-           if constexpr (sizeof(_Int) < sizeof(short)) return type_identity<short>{};
-      else if constexpr (sizeof(_Int) < sizeof(int))   return type_identity<int>{};
-      else if constexpr (sizeof(_Int) < sizeof(long))  return type_identity<long>{};
-      else                                             return type_identity<long long>{};
-
-      static_assert(sizeof(_Int) <= sizeof(long long),
-        "Found integer-like type that is bigger than largest integer like type.");
-    }
-
-    using type = typename decltype(__call())::type;
-  };
-
-  template<class _Start>
-  using _IotaDiffT = typename _If<
-      (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
-      type_identity<iter_difference_t<_Start>>,
-      __get_wider_signed<_Start>
-    >::type;
-
-  template<class _Iter>
-  concept __decrementable = incrementable<_Iter> && requires(_Iter __i) {
-    { --__i } -> same_as<_Iter&>;
-    { __i-- } -> same_as<_Iter>;
-  };
-
-  template<class _Iter>
-  concept __advanceable =
+template <class _Int>
+struct __get_wider_signed {
+  consteval static auto __call() {
+    if constexpr (sizeof(_Int) < sizeof(short))
+      return type_identity<short>{};
+    else if constexpr (sizeof(_Int) < sizeof(int))
+      return type_identity<int>{};
+    else if constexpr (sizeof(_Int) < sizeof(long))
+      return type_identity<long>{};
+    else
+      return type_identity<long long>{};
+
+    static_assert(
+        sizeof(_Int) <= sizeof(long long), "Found integer-like type that is bigger than largest integer like type.");
+  }
+
+  using type = typename decltype(__call())::type;
+};
+
+template <class _Start>
+using _IotaDiffT =
+    typename _If< (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
+                  type_identity<iter_difference_t<_Start>>,
+                  __get_wider_signed<_Start> >::type;
+
+template <class _Iter>
+concept __decrementable = incrementable<_Iter> && requires(_Iter __i) {
+  { --__i } -> same_as<_Iter&>;
+  { __i-- } -> same_as<_Iter>;
+};
+
+template <class _Iter>
+concept __advanceable =
     __decrementable<_Iter> && totally_ordered<_Iter> &&
     requires(_Iter __i, const _Iter __j, const _IotaDiffT<_Iter> __n) {
       { __i += __n } -> same_as<_Iter&>;
@@ -86,322 +89,304 @@ namespace ranges {
       { __j - __j } -> convertible_to<_IotaDiffT<_Iter>>;
     };
 
-  template<class>
-  struct __iota_iterator_category {};
+template <class>
+struct __iota_iterator_category {};
 
-  template<incrementable _Tp>
-  struct __iota_iterator_category<_Tp> {
-    using iterator_category = input_iterator_tag;
-  };
+template <incrementable _Tp>
+struct __iota_iterator_category<_Tp> {
+  using iterator_category = input_iterator_tag;
+};
 
-  template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
-    requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
-  class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
-    struct __iterator : public __iota_iterator_category<_Start> {
-      friend class iota_view;
+template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
+  requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
+class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
+  struct __iterator : public __iota_iterator_category<_Start> {
+    friend class iota_view;
 
-      using iterator_concept =
-        _If<__advanceable<_Start>,   random_access_iterator_tag,
-        _If<__decrementable<_Start>, bidirectional_iterator_tag,
-        _If<incrementable<_Start>,   forward_iterator_tag,
-        /*Else*/                     input_iterator_tag>>>;
+    using iterator_concept =
+        _If<__advanceable<_Start>,
+            random_access_iterator_tag,
+            _If<__decrementable<_Start>,
+                bidirectional_iterator_tag,
+                _If<incrementable<_Start>,
+                    forward_iterator_tag,
+                    /*Else*/ input_iterator_tag>>>;
 
-      using value_type = _Start;
-      using difference_type = _IotaDiffT<_Start>;
+    using value_type      = _Start;
+    using difference_type = _IotaDiffT<_Start>;
 
-      _Start __value_ = _Start();
+    _Start __value_ = _Start();
 
-      _LIBCPP_HIDE_FROM_ABI
-      __iterator() requires default_initializable<_Start> = default;
+    _LIBCPP_HIDE_FROM_ABI __iterator()
+      requires default_initializable<_Start>
+    = default;
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
-        return __value_;
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
+      return __value_;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator++() {
-        ++__value_;
-        return *this;
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+      ++__value_;
+      return *this;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr void operator++(int) { ++*this; }
+    _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator operator++(int) requires incrementable<_Start> {
-        auto __tmp = *this;
-        ++*this;
-        return __tmp;
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+      requires incrementable<_Start>
+    {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator--() requires __decrementable<_Start> {
-        --__value_;
-        return *this;
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+      requires __decrementable<_Start>
+    {
+      --__value_;
+      return *this;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator  operator--(int) requires __decrementable<_Start> {
-        auto __tmp = *this;
-        --*this;
-        return __tmp;
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+      requires __decrementable<_Start>
+    {
+      auto __tmp = *this;
+      --*this;
+      return __tmp;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator+=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ += static_cast<_Start>(__n);
-          } else {
-            __value_ -= static_cast<_Start>(-__n);
-          }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+        if (__n >= difference_type(0)) {
+          __value_ += static_cast<_Start>(__n);
         } else {
-          __value_ += __n;
+          __value_ -= static_cast<_Start>(-__n);
         }
-        return *this;
+      } else {
+        __value_ += __n;
       }
+      return *this;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator-=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ -= static_cast<_Start>(__n);
-          } else {
-            __value_ += static_cast<_Start>(-__n);
-          }
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+        if (__n >= difference_type(0)) {
+          __value_ -= static_cast<_Start>(__n);
         } else {
-          __value_ -= __n;
+          __value_ += static_cast<_Start>(-__n);
         }
-        return *this;
+      } else {
+        __value_ -= __n;
       }
+      return *this;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator[](difference_type __n) const
-        requires __advanceable<_Start>
-      {
-        return _Start(__value_ + __n);
-      }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Start operator[](difference_type __n) const
+      requires __advanceable<_Start>
+    {
+      return _Start(__value_ + __n);
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-        requires equality_comparable<_Start>
-      {
-        return __x.__value_ == __y.__value_;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+      requires equality_comparable<_Start>
+    {
+      return __x.__value_ == __y.__value_;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __x.__value_ < __y.__value_;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return __x.__value_ < __y.__value_;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __y < __x;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return __y < __x;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__y < __x);
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return !(__y < __x);
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__x < __y);
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return !(__x < __y);
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start> && three_way_comparable<_Start>
-      {
-        return __x.__value_ <=> __y.__value_;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start> && three_way_comparable<_Start>
+    {
+      return __x.__value_ <=> __y.__value_;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i += __n;
-        return __i;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+      requires __advanceable<_Start>
+    {
+      __i += __n;
+      return __i;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(difference_type __n, __iterator __i)
-        requires __advanceable<_Start>
-      {
-        return __i + __n;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+      requires __advanceable<_Start>
+    {
+      return __i + __n;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator-(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i -= __n;
-        return __i;
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+      requires __advanceable<_Start>
+    {
+      __i -= __n;
+      return __i;
+    }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start>) {
-          if constexpr (__signed_integer_like<_Start>) {
-            return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
-          }
-          if (__y.__value_ > __x.__value_) {
-            return difference_type(-difference_type(__y.__value_ - __x.__value_));
-          }
-          return difference_type(__x.__value_ - __y.__value_);
+    _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start>) {
+        if constexpr (__signed_integer_like<_Start>) {
+          return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
         }
-        return __x.__value_ - __y.__value_;
-      }
-    };
-
-    struct __sentinel {
-      friend class iota_view;
-
-    private:
-      _BoundSentinel __bound_sentinel_ = _BoundSentinel();
-
-    public:
-      _LIBCPP_HIDE_FROM_ABI
-      __sentinel() = default;
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_BoundSentinel __bound_sentinel)
-          : __bound_sentinel_(std::move(__bound_sentinel)) {}
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
-        return __x.__value_ == __y.__bound_sentinel_;
+        if (__y.__value_ > __x.__value_) {
+          return difference_type(-difference_type(__y.__value_ - __x.__value_));
+        }
+        return difference_type(__x.__value_ - __y.__value_);
       }
+      return __x.__value_ - __y.__value_;
+    }
+  };
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return __x.__value_ - __y.__bound_sentinel_;
-      }
+  struct __sentinel {
+    friend class iota_view;
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __sentinel& __x, const __iterator& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return -(__y - __x);
-      }
-    };
-
-    _Start __value_ = _Start();
+  private:
     _BoundSentinel __bound_sentinel_ = _BoundSentinel();
 
   public:
-    _LIBCPP_HIDE_FROM_ABI
-    iota_view() requires default_initializable<_Start> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
-        : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
-      // Validate the precondition if possible.
-      if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
-        _LIBCPP_ASSERT_UNCATEGORIZED(ranges::less_equal()(__value_, __bound_sentinel_),
-                                     "Precondition violated: value is greater than bound.");
-      }
-    }
+    _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_BoundSentinel __bound_sentinel)
+        : __bound_sentinel_(std::move(__bound_sentinel)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __iterator __last)
-      requires same_as<_Start, _BoundSentinel>
-    : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, _BoundSentinel __last)
-      requires same_as<_BoundSentinel, unreachable_sentinel_t>
-    : iota_view(std::move(__first.__value_), std::move(__last)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __sentinel __last)
-      requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)
-    : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator begin() const { return __iterator{__value_}; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const {
-      if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
-        return unreachable_sentinel;
-      else
-        return __sentinel{__bound_sentinel_};
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
+      return __x.__value_ == __y.__bound_sentinel_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator end() const
-      requires same_as<_Start, _BoundSentinel>
+    _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
+    operator-(const __iterator& __x, const __sentinel& __y)
+      requires sized_sentinel_for<_BoundSentinel, _Start>
     {
-      return __iterator{__bound_sentinel_};
+      return __x.__value_ - __y.__bound_sentinel_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
-              (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
+    _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
+    operator-(const __sentinel& __x, const __iterator& __y)
+      requires sized_sentinel_for<_BoundSentinel, _Start>
     {
-      if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
-        return (__value_ < 0)
-                 ? ((__bound_sentinel_ < 0)
-                        ? std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_)
-                        : std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_))
-                 : std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
-      } else {
-        return std::__to_unsigned_like(__bound_sentinel_ - __value_);
-      }
+      return -(__y - __x);
     }
   };
 
-  template <class _Start, class _BoundSentinel>
-    requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
-             (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
-  iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
+  _Start __value_                  = _Start();
+  _BoundSentinel __bound_sentinel_ = _BoundSentinel();
 
-  template <class _Start, class _BoundSentinel>
-  inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
-
- namespace views {
- namespace __iota {
-  struct __fn {
-    template<class _Start>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Start&& __start) const
+public:
+  _LIBCPP_HIDE_FROM_ABI iota_view()
+    requires default_initializable<_Start>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
+      : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
+    // Validate the precondition if possible.
+    if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
+      _LIBCPP_ASSERT_UNCATEGORIZED(
+          ranges::less_equal()(__value_, __bound_sentinel_), "Precondition violated: value is greater than bound.");
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __iterator __last)
+    requires same_as<_Start, _BoundSentinel>
+      : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, _BoundSentinel __last)
+    requires same_as<_BoundSentinel, unreachable_sentinel_t>
+      : iota_view(std::move(__first.__value_), std::move(__last)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __sentinel __last)
+    requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)
+      : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator{__value_}; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const {
+    if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
+      return unreachable_sentinel;
+    else
+      return __sentinel{__bound_sentinel_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
+    requires same_as<_Start, _BoundSentinel>
+  {
+    return __iterator{__bound_sentinel_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
+            (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
+  {
+    if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
+      return (__value_ < 0)
+               ? ((__bound_sentinel_ < 0)
+                      ? std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_)
+                      : std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_))
+               : std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
+    } else {
+      return std::__to_unsigned_like(__bound_sentinel_ - __value_);
+    }
+  }
+};
+
+template <class _Start, class _BoundSentinel>
+  requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
+           (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
+iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
+
+template <class _Start, class _BoundSentinel>
+inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
+
+namespace views {
+namespace __iota {
+struct __fn {
+  template <class _Start>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start) const
       noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))
-      -> decltype(      ranges::iota_view(std::forward<_Start>(__start)))
-      { return          ranges::iota_view(std::forward<_Start>(__start)); }
-
-    template <class _Start, class _BoundSentinel>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const
-      noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
-      -> decltype(      ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)))
-      { return          ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)); }
-  };
+          -> decltype(ranges::iota_view(std::forward<_Start>(__start))) {
+    return ranges::iota_view(std::forward<_Start>(__start));
+  }
+
+  template <class _Start, class _BoundSentinel>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const noexcept(
+      noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
+      -> decltype(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))) {
+    return ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel));
+  }
+};
 } // namespace __iota
 
 inline namespace __cpo {
-  inline constexpr auto iota = __iota::__fn{};
+inline constexpr auto iota = __iota::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/istream_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/istream_view.h
index 71af102c332..cd7096d35c2 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/istream_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/istream_view.h
@@ -66,8 +66,7 @@ public:
   using difference_type  = ptrdiff_t;
   using value_type       = _Val;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(
-      basic_istream_view<_Val, _CharT, _Traits>& __parent) noexcept
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(basic_istream_view<_Val, _CharT, _Traits>& __parent) noexcept
       : __parent_(std::addressof(__parent)) {}
 
   __iterator(const __iterator&)                  = delete;
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/join_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/join_view.h
index f80beda33b1..22473059133 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/join_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/join_view.h
@@ -46,389 +46,334 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class>
-  struct __join_view_iterator_category {};
-
-  template<class _View>
-    requires is_reference_v<range_reference_t<_View>> &&
-             forward_range<_View> &&
-             forward_range<range_reference_t<_View>>
-  struct __join_view_iterator_category<_View> {
-    using _OuterC = typename iterator_traits<iterator_t<_View>>::iterator_category;
-    using _InnerC = typename iterator_traits<iterator_t<range_reference_t<_View>>>::iterator_category;
-
-    using iterator_category = _If<
-      derived_from<_OuterC, bidirectional_iterator_tag> && derived_from<_InnerC, bidirectional_iterator_tag> &&
-        common_range<range_reference_t<_View>>,
-      bidirectional_iterator_tag,
-      _If<
-        derived_from<_OuterC, forward_iterator_tag> && derived_from<_InnerC, forward_iterator_tag>,
-        forward_iterator_tag,
-        input_iterator_tag
-      >
-    >;
-  };
-
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  class join_view
-    : public view_interface<join_view<_View>> {
-  private:
-    using _InnerRange = range_reference_t<_View>;
-
-    template<bool> struct __iterator;
-
-    template<bool> struct __sentinel;
-
-    template <class>
-    friend struct std::__segmented_iterator_traits;
-
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-
-    static constexpr bool _UseOuterCache = !forward_range<_View>;
-    using _OuterCache = _If<_UseOuterCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _OuterCache __outer_;
-
-    static constexpr bool _UseInnerCache = !is_reference_v<_InnerRange>;
-    using _InnerCache = _If<_UseInnerCache, __non_propagating_cache<remove_cvref_t<_InnerRange>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _InnerCache __inner_;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    join_view() requires default_initializable<_View> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit join_view(_View __base)
-      : __base_(std::move(__base)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() {
-      if constexpr (forward_range<_View>) {
-        constexpr bool __use_const = __simple_view<_View> &&
-                                     is_reference_v<range_reference_t<_View>>;
-        return __iterator<__use_const>{*this, ranges::begin(__base_)};
-      } else {
-        __outer_.__emplace(ranges::begin(__base_));
-        return __iterator<false>{*this};
-      }
-    }
+template <class>
+struct __join_view_iterator_category {};
+
+template <class _View>
+  requires is_reference_v<range_reference_t<_View>> && forward_range<_View> && forward_range<range_reference_t<_View>>
+struct __join_view_iterator_category<_View> {
+  using _OuterC = typename iterator_traits<iterator_t<_View>>::iterator_category;
+  using _InnerC = typename iterator_traits<iterator_t<range_reference_t<_View>>>::iterator_category;
+
+  using iterator_category =
+      _If< derived_from<_OuterC, bidirectional_iterator_tag> && derived_from<_InnerC, bidirectional_iterator_tag> &&
+               common_range<range_reference_t<_View>>,
+           bidirectional_iterator_tag,
+           _If< derived_from<_OuterC, forward_iterator_tag> && derived_from<_InnerC, forward_iterator_tag>,
+                forward_iterator_tag,
+                input_iterator_tag > >;
+};
 
-    template<class _V2 = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const
-      requires forward_range<const _V2> &&
-               is_reference_v<range_reference_t<const _V2>> &&
-               input_range<range_reference_t<const _V2>>
-    {
-      return __iterator<true>{*this, ranges::begin(__base_)};
-    }
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+class join_view : public view_interface<join_view<_View>> {
+private:
+  using _InnerRange = range_reference_t<_View>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() {
-      if constexpr (forward_range<_View> &&
-                    is_reference_v<_InnerRange> &&
-                    forward_range<_InnerRange> &&
-                    common_range<_View> &&
-                    common_range<_InnerRange>)
-        return __iterator<__simple_view<_View>>{*this, ranges::end(__base_)};
-      else
-        return __sentinel<__simple_view<_View>>{*this};
+  template <bool>
+  struct __iterator;
+
+  template <bool>
+  struct __sentinel;
+
+  template <class>
+  friend struct std::__segmented_iterator_traits;
+
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+
+  static constexpr bool _UseOuterCache = !forward_range<_View>;
+  using _OuterCache                    = _If<_UseOuterCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _OuterCache __outer_;
+
+  static constexpr bool _UseInnerCache = !is_reference_v<_InnerRange>;
+  using _InnerCache = _If<_UseInnerCache, __non_propagating_cache<remove_cvref_t<_InnerRange>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _InnerCache __inner_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI join_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit join_view(_View __base) : __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
+    if constexpr (forward_range<_View>) {
+      constexpr bool __use_const = __simple_view<_View> && is_reference_v<range_reference_t<_View>>;
+      return __iterator<__use_const>{*this, ranges::begin(__base_)};
+    } else {
+      __outer_.__emplace(ranges::begin(__base_));
+      return __iterator<false>{*this};
     }
+  }
+
+  template <class _V2 = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires forward_range<const _V2> && is_reference_v<range_reference_t<const _V2>> &&
+             input_range<range_reference_t<const _V2>>
+  {
+    return __iterator<true>{*this, ranges::begin(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (forward_range<_View> && is_reference_v<_InnerRange> && forward_range<_InnerRange> &&
+                  common_range<_View> && common_range<_InnerRange>)
+      return __iterator<__simple_view<_View>>{*this, ranges::end(__base_)};
+    else
+      return __sentinel<__simple_view<_View>>{*this};
+  }
 
-    template<class _V2 = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const
-      requires forward_range<const _V2> &&
-               is_reference_v<range_reference_t<const _V2>> &&
-               input_range<range_reference_t<const _V2>>
-    {
-      using _ConstInnerRange = range_reference_t<const _View>;
-      if constexpr (forward_range<_ConstInnerRange> &&
-                    common_range<const _View> &&
-                    common_range<_ConstInnerRange>) {
-        return __iterator<true>{*this, ranges::end(__base_)};
-      } else {
-        return __sentinel<true>{*this};
-      }
+  template <class _V2 = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires forward_range<const _V2> && is_reference_v<range_reference_t<const _V2>> &&
+             input_range<range_reference_t<const _V2>>
+  {
+    using _ConstInnerRange = range_reference_t<const _View>;
+    if constexpr (forward_range<_ConstInnerRange> && common_range<const _View> && common_range<_ConstInnerRange>) {
+      return __iterator<true>{*this, ranges::end(__base_)};
+    } else {
+      return __sentinel<true>{*this};
     }
-  };
-
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  template<bool _Const>
-  struct join_view<_View>::__sentinel {
-  private:
-    template <bool>
-    friend struct __sentinel;
-
-    using _Parent            = __maybe_const<_Const, join_view>;
-    using _Base              = __maybe_const<_Const, _View>;
-    sentinel_t<_Base> __end_ = sentinel_t<_Base>();
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    __sentinel() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(_Parent& __parent)
-      : __end_(ranges::end(__parent.__base_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __sentinel(__sentinel<!_Const> __s)
-      requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+  }
+};
+
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+template <bool _Const>
+struct join_view<_View>::__sentinel {
+private:
+  template <bool>
+  friend struct __sentinel;
+
+  using _Parent            = __maybe_const<_Const, join_view>;
+  using _Base              = __maybe_const<_Const, _View>;
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_Parent& __parent) : __end_(ranges::end(__parent.__base_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __s)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
       : __end_(std::move(__s.__end_)) {}
 
-    template<bool _OtherConst>
-      requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
-      return __x.__get_outer() == __y.__end_;
-    }
-  };
-
-  // https://reviews.llvm.org/D142811#inline-1383022
-  // To simplify the segmented iterator traits specialization,
-  // make the iterator `final`
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  template<bool _Const>
-  struct join_view<_View>::__iterator final
-    : public __join_view_iterator_category<__maybe_const<_Const, _View>> {
-    friend join_view;
-
-    template <class>
-    friend struct std::__segmented_iterator_traits;
-
-    static constexpr bool __is_join_view_iterator = true;
-
-  private:
-    using _Parent = __maybe_const<_Const, join_view<_View>>;
-    using _Base = __maybe_const<_Const, _View>;
-    using _Outer = iterator_t<_Base>;
-    using _Inner = iterator_t<range_reference_t<_Base>>;
-    using _InnerRange = range_reference_t<_View>;
-
-    static_assert(!_Const || forward_range<_Base>, "Const can only be true when Base models forward_range.");
-
-    static constexpr bool __ref_is_glvalue = is_reference_v<range_reference_t<_Base>>;
-
-    static constexpr bool _OuterPresent = forward_range<_Base>;
-    using _OuterType                    = _If<_OuterPresent, _Outer, std::__empty>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _OuterType __outer_ = _OuterType();
-
-    optional<_Inner> __inner_;
-    _Parent* __parent_ = nullptr;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void __satisfy() {
-      for (; __get_outer() != ranges::end(__parent_->__base_); ++__get_outer()) {
-        auto&& __inner = [this]() -> auto&& {
-          if constexpr (__ref_is_glvalue)
-            return *__get_outer();
-          else
-            return __parent_->__inner_.__emplace_from([&]() -> decltype(auto) { return *__get_outer(); });
-        }();
-        __inner_ = ranges::begin(__inner);
-        if (*__inner_ != ranges::end(__inner))
-          return;
-      }
+  template <bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__get_outer() == __y.__end_;
+  }
+};
 
-      if constexpr (__ref_is_glvalue)
-        __inner_.reset();
-    }
+// https://reviews.llvm.org/D142811#inline-1383022
+// To simplify the segmented iterator traits specialization,
+// make the iterator `final`
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+template <bool _Const>
+struct join_view<_View>::__iterator final : public __join_view_iterator_category<__maybe_const<_Const, _View>> {
+  friend join_view;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr _Outer& __get_outer() {
-      if constexpr (forward_range<_Base>) {
-        return __outer_;
-      } else {
-        return *__parent_->__outer_;
-      }
-    }
+  template <class>
+  friend struct std::__segmented_iterator_traits;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Outer& __get_outer() const {
-      if constexpr (forward_range<_Base>) {
-        return __outer_;
-      } else {
-        return *__parent_->__outer_;
-      }
-    }
+  static constexpr bool __is_join_view_iterator = true;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, _Outer __outer)
-      requires forward_range<_Base>
-        : __outer_(std::move(__outer)), __parent_(std::addressof(__parent)) {
-      __satisfy();
-    }
+private:
+  using _Parent     = __maybe_const<_Const, join_view<_View>>;
+  using _Base       = __maybe_const<_Const, _View>;
+  using _Outer      = iterator_t<_Base>;
+  using _Inner      = iterator_t<range_reference_t<_Base>>;
+  using _InnerRange = range_reference_t<_View>;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Parent& __parent)
-      requires(!forward_range<_Base>)
-        : __parent_(std::addressof(__parent)) {
-      __satisfy();
-    }
+  static_assert(!_Const || forward_range<_Base>, "Const can only be true when Base models forward_range.");
 
-    _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent* __parent, _Outer __outer, _Inner __inner)
-      requires forward_range<_Base>
-        : __outer_(std::move(__outer)), __inner_(std::move(__inner)), __parent_(__parent) {}
-
-  public:
-    using iterator_concept = _If<
-      __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
-          common_range<range_reference_t<_Base>>,
-      bidirectional_iterator_tag,
-      _If<
-        __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>,
-        forward_iterator_tag,
-        input_iterator_tag
-      >
-    >;
-
-    using value_type = range_value_t<range_reference_t<_Base>>;
-
-    using difference_type = common_type_t<
-      range_difference_t<_Base>, range_difference_t<range_reference_t<_Base>>>;
-
-    _LIBCPP_HIDE_FROM_ABI __iterator() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(__iterator<!_Const> __i)
-      requires _Const &&
-               convertible_to<iterator_t<_View>, _Outer> &&
-               convertible_to<iterator_t<_InnerRange>, _Inner>
-      : __outer_(std::move(__i.__outer_))
-      , __inner_(std::move(__i.__inner_))
-      , __parent_(__i.__parent_) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator*() const {
-      return **__inner_;
-    }
+  static constexpr bool __ref_is_glvalue = is_reference_v<range_reference_t<_Base>>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Inner operator->() const
-      requires __has_arrow<_Inner> && copyable<_Inner>
-    {
-      return *__inner_;
-    }
+  static constexpr bool _OuterPresent           = forward_range<_Base>;
+  using _OuterType                              = _If<_OuterPresent, _Outer, std::__empty>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _OuterType __outer_ = _OuterType();
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator++() {
-      auto __get_inner_range = [&]() -> decltype(auto) {
+  optional<_Inner> __inner_;
+  _Parent* __parent_ = nullptr;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __satisfy() {
+    for (; __get_outer() != ranges::end(__parent_->__base_); ++__get_outer()) {
+      auto&& __inner = [this]() -> auto&& {
         if constexpr (__ref_is_glvalue)
           return *__get_outer();
         else
-          return *__parent_->__inner_;
-      };
-      if (++*__inner_ == ranges::end(std::__as_lvalue(__get_inner_range()))) {
-        ++__get_outer();
-        __satisfy();
-      }
-      return *this;
+          return __parent_->__inner_.__emplace_from([&]() -> decltype(auto) { return *__get_outer(); });
+      }();
+      __inner_ = ranges::begin(__inner);
+      if (*__inner_ != ranges::end(__inner))
+        return;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator++(int) {
-      ++*this;
-    }
+    if constexpr (__ref_is_glvalue)
+      __inner_.reset();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator++(int)
-      requires __ref_is_glvalue &&
-               forward_range<_Base> &&
-               forward_range<range_reference_t<_Base>>
-    {
-      auto __tmp = *this;
-      ++*this;
-      return __tmp;
+  _LIBCPP_HIDE_FROM_ABI constexpr _Outer& __get_outer() {
+    if constexpr (forward_range<_Base>) {
+      return __outer_;
+    } else {
+      return *__parent_->__outer_;
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator--()
-      requires __ref_is_glvalue &&
-               bidirectional_range<_Base> &&
-               bidirectional_range<range_reference_t<_Base>> &&
-               common_range<range_reference_t<_Base>>
-    {
-      if (__outer_ == ranges::end(__parent_->__base_))
-        __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
-
-      // Skip empty inner ranges when going backwards.
-      while (*__inner_ == ranges::begin(std::__as_lvalue(*__outer_))) {
-        __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
-      }
-
-      --*__inner_;
-      return *this;
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Outer& __get_outer() const {
+    if constexpr (forward_range<_Base>) {
+      return __outer_;
+    } else {
+      return *__parent_->__outer_;
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator--(int)
-      requires __ref_is_glvalue &&
-               bidirectional_range<_Base> &&
-               bidirectional_range<range_reference_t<_Base>> &&
-               common_range<range_reference_t<_Base>>
-    {
-      auto __tmp = *this;
-      --*this;
-      return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, _Outer __outer)
+    requires forward_range<_Base>
+      : __outer_(std::move(__outer)), __parent_(std::addressof(__parent)) {
+    __satisfy();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-      requires __ref_is_glvalue &&
-               forward_range<_Base> &&
-               equality_comparable<iterator_t<range_reference_t<_Base>>>
-    {
-      return __x.__outer_ == __y.__outer_ && __x.__inner_ == __y.__inner_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Parent& __parent)
+    requires(!forward_range<_Base>)
+      : __parent_(std::addressof(__parent)) {
+    __satisfy();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent* __parent, _Outer __outer, _Inner __inner)
+    requires forward_range<_Base>
+      : __outer_(std::move(__outer)), __inner_(std::move(__inner)), __parent_(__parent) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) iter_move(const __iterator& __i)
-      noexcept(noexcept(ranges::iter_move(*__i.__inner_)))
-    {
-      return ranges::iter_move(*__i.__inner_);
+public:
+  using iterator_concept =
+      _If< __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+               common_range<range_reference_t<_Base>>,
+           bidirectional_iterator_tag,
+           _If< __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>,
+                forward_iterator_tag,
+                input_iterator_tag > >;
+
+  using value_type = range_value_t<range_reference_t<_Base>>;
+
+  using difference_type = common_type_t< range_difference_t<_Base>, range_difference_t<range_reference_t<_Base>>>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, _Outer> && convertible_to<iterator_t<_InnerRange>, _Inner>
+      : __outer_(std::move(__i.__outer_)), __inner_(std::move(__i.__inner_)), __parent_(__i.__parent_) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return **__inner_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Inner operator->() const
+    requires __has_arrow<_Inner> && copyable<_Inner>
+  {
+    return *__inner_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    auto __get_inner_range = [&]() -> decltype(auto) {
+      if constexpr (__ref_is_glvalue)
+        return *__get_outer();
+      else
+        return *__parent_->__inner_;
+    };
+    if (++*__inner_ == ranges::end(std::__as_lvalue(__get_inner_range()))) {
+      ++__get_outer();
+      __satisfy();
     }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
-      noexcept(noexcept(ranges::iter_swap(*__x.__inner_, *__y.__inner_)))
-      requires indirectly_swappable<_Inner>
-    {
-      return ranges::iter_swap(*__x.__inner_, *__y.__inner_);
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+             common_range<range_reference_t<_Base>>
+  {
+    if (__outer_ == ranges::end(__parent_->__base_))
+      __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
+
+    // Skip empty inner ranges when going backwards.
+    while (*__inner_ == ranges::begin(std::__as_lvalue(*__outer_))) {
+      __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
     }
-  };
 
-  template<class _Range>
-  explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
+    --*__inner_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+             common_range<range_reference_t<_Base>>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires __ref_is_glvalue && forward_range<_Base> && equality_comparable<iterator_t<range_reference_t<_Base>>>
+  {
+    return __x.__outer_ == __y.__outer_ && __x.__inner_ == __y.__inner_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto)
+  iter_move(const __iterator& __i) noexcept(noexcept(ranges::iter_move(*__i.__inner_))) {
+    return ranges::iter_move(*__i.__inner_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const __iterator& __x,
+            const __iterator& __y) noexcept(noexcept(ranges::iter_swap(*__x.__inner_, *__y.__inner_)))
+    requires indirectly_swappable<_Inner>
+  {
+    return ranges::iter_swap(*__x.__inner_, *__y.__inner_);
+  }
+};
+
+template <class _Range>
+explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
 
 namespace views {
 namespace __join_view {
 struct __fn : __range_adaptor_closure<__fn> {
-  template<class _Range>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range) const
-    noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
-    -> decltype(      join_view<all_t<_Range&&>>(std::forward<_Range>(__range)))
-    { return          join_view<all_t<_Range&&>>(std::forward<_Range>(__range)); }
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
+          -> decltype(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))) {
+    return join_view<all_t<_Range&&>>(std::forward<_Range>(__range));
+  }
 };
 } // namespace __join_view
 inline namespace __cpo {
-  inline constexpr auto join = __join_view::__fn{};
+inline constexpr auto join = __join_view::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 template <class _JoinViewIterator>
-  requires(_JoinViewIterator::__is_join_view_iterator &&
-           ranges::common_range<typename _JoinViewIterator::_Parent> &&
+  requires(_JoinViewIterator::__is_join_view_iterator && ranges::common_range<typename _JoinViewIterator::_Parent> &&
            __has_random_access_iterator_category<typename _JoinViewIterator::_Outer>::value &&
            __has_random_access_iterator_category<typename _JoinViewIterator::_Inner>::value)
 struct __segmented_iterator_traits<_JoinViewIterator> {
-
   using __segment_iterator =
       _LIBCPP_NODEBUG __iterator_with_data<typename _JoinViewIterator::_Outer, typename _JoinViewIterator::_Parent*>;
   using __local_iterator = typename _JoinViewIterator::_Inner;
@@ -436,33 +381,33 @@ struct __segmented_iterator_traits<_JoinViewIterator> {
   // TODO: Would it make sense to enable the optimization for other iterator types?
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __segment_iterator __segment(_JoinViewIterator __iter) {
-      if (ranges::empty(__iter.__parent_->__base_))
-        return {};
-      if (!__iter.__inner_.has_value())
-        return __segment_iterator(--__iter.__outer_, __iter.__parent_);
-      return __segment_iterator(__iter.__outer_, __iter.__parent_);
+    if (ranges::empty(__iter.__parent_->__base_))
+      return {};
+    if (!__iter.__inner_.has_value())
+      return __segment_iterator(--__iter.__outer_, __iter.__parent_);
+    return __segment_iterator(__iter.__outer_, __iter.__parent_);
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __local(_JoinViewIterator __iter) {
-      if (ranges::empty(__iter.__parent_->__base_))
-        return {};
-      if (!__iter.__inner_.has_value())
-        return ranges::end(*--__iter.__outer_);
-      return *__iter.__inner_;
+    if (ranges::empty(__iter.__parent_->__base_))
+      return {};
+    if (!__iter.__inner_.has_value())
+      return ranges::end(*--__iter.__outer_);
+    return *__iter.__inner_;
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __begin(__segment_iterator __iter) {
-      return ranges::begin(*__iter.__get_iter());
+    return ranges::begin(*__iter.__get_iter());
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __end(__segment_iterator __iter) {
-      return ranges::end(*__iter.__get_iter());
+    return ranges::end(*__iter.__get_iter());
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI _JoinViewIterator
   __compose(__segment_iterator __seg_iter, __local_iterator __local_iter) {
-      return _JoinViewIterator(
-          std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter));
+    return _JoinViewIterator(
+        std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter));
   }
 };
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/lazy_split_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/lazy_split_view.h
index 8ed4bcfdeb5..e96398b14b5 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/lazy_split_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/lazy_split_view.h
@@ -53,73 +53,73 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template <auto> struct __require_constant;
+template <auto>
+struct __require_constant;
 
 template <class _Range>
-concept __tiny_range =
-  sized_range<_Range> &&
-  requires { typename __require_constant<remove_reference_t<_Range>::size()>; } &&
-  (remove_reference_t<_Range>::size() <= 1);
+concept __tiny_range = sized_range<_Range> && requires {
+  typename __require_constant<remove_reference_t<_Range>::size()>;
+} && (remove_reference_t<_Range>::size() <= 1);
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && view<_Pattern> &&
            indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to> &&
            (forward_range<_View> || __tiny_range<_Pattern>)
 class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
-
-  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_       = _View();
   _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
 
   using _MaybeCurrent = _If<!forward_range<_View>, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
   _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
 
-  template <bool> struct __outer_iterator;
-  template <bool> struct __inner_iterator;
+  template <bool>
+  struct __outer_iterator;
+  template <bool>
+  struct __inner_iterator;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  lazy_split_view()
-    requires default_initializable<_View> && default_initializable<_Pattern> = default;
+  _LIBCPP_HIDE_FROM_ABI lazy_split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_View __base, _Pattern __pattern)
-    : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_View __base, _Pattern __pattern)
+      : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
 
   template <input_range _Range>
     requires constructible_from<_View, views::all_t<_Range>> &&
-             constructible_from<_Pattern, single_view<range_value_t<_Range>>>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
-    : __base_(views::all(std::forward<_Range>(__r)))
-    , __pattern_(views::single(std::move(__e))) {}
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() {
+                 constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+      : __base_(views::all(std::forward<_Range>(__r))), __pattern_(views::single(std::move(__e))) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
     if constexpr (forward_range<_View>) {
-      return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::begin(__base_)};
+      return __outer_iterator < __simple_view<_View> && __simple_view < _Pattern >> {*this, ranges::begin(__base_)};
     } else {
       __current_.__emplace(ranges::begin(__base_));
       return __outer_iterator<false>{*this};
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires forward_range<_View> && forward_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires forward_range<_View> && forward_range<const _View>
+  {
     return __outer_iterator<true>{*this, ranges::begin(__base_)};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() requires forward_range<_View> && common_range<_View> {
-    return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::end(__base_)};
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires forward_range<_View> && common_range<_View>
+  {
+    return __outer_iterator < __simple_view<_View> && __simple_view < _Pattern >> {*this, ranges::end(__base_)};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const {
     if constexpr (forward_range<_View> && forward_range<const _View> && common_range<const _View>) {
       return __outer_iterator<true>{*this, ranges::end(__base_)};
     } else {
@@ -128,7 +128,6 @@ public:
   }
 
 private:
-
   template <class>
   struct __outer_iterator_category {};
 
@@ -145,15 +144,14 @@ private:
     friend __outer_iterator<true>;
 
     using _Parent = __maybe_const<_Const, lazy_split_view>;
-    using _Base = __maybe_const<_Const, _View>;
+    using _Base   = __maybe_const<_Const, _View>;
 
-    _Parent* __parent_ = nullptr;
-    using _MaybeCurrent = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
+    _Parent* __parent_                                 = nullptr;
+    using _MaybeCurrent                                = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
     _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
-    bool __trailing_empty_ = false;
+    bool __trailing_empty_                             = false;
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __current() noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __current() noexcept {
       if constexpr (forward_range<_View>) {
         return __current_;
       } else {
@@ -161,8 +159,7 @@ private:
       }
     }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __current() const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const auto& __current() const noexcept {
       if constexpr (forward_range<_View>) {
         return __current_;
       } else {
@@ -172,56 +169,42 @@ private:
 
     // Workaround for the GCC issue that doesn't allow calling `__parent_->__base_` from friend functions (because
     // `__base_` is private).
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __parent_base() const noexcept {
-      return __parent_->__base_;
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __parent_base() const noexcept { return __parent_->__base_; }
 
   public:
     // using iterator_category = inherited;
     using iterator_concept = conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>;
-    using difference_type = range_difference_t<_Base>;
+    using difference_type  = range_difference_t<_Base>;
 
     struct value_type : view_interface<value_type> {
     private:
       __outer_iterator __i_ = __outer_iterator();
 
     public:
-      _LIBCPP_HIDE_FROM_ABI
-      value_type() = default;
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit value_type(__outer_iterator __i)
-        : __i_(std::move(__i)) {}
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
+      _LIBCPP_HIDE_FROM_ABI value_type() = default;
+      _LIBCPP_HIDE_FROM_ABI constexpr explicit value_type(__outer_iterator __i) : __i_(std::move(__i)) {}
+
+      _LIBCPP_HIDE_FROM_ABI constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
+      _LIBCPP_HIDE_FROM_ABI constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
     };
 
-    _LIBCPP_HIDE_FROM_ABI
-    __outer_iterator() = default;
+    _LIBCPP_HIDE_FROM_ABI __outer_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __outer_iterator(_Parent& __parent)
-      requires (!forward_range<_Base>)
-      : __parent_(std::addressof(__parent)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __outer_iterator(_Parent& __parent)
+      requires(!forward_range<_Base>)
+        : __parent_(std::addressof(__parent)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
       requires forward_range<_Base>
-      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+        : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(__outer_iterator<!_Const> __i)
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator(__outer_iterator<!_Const> __i)
       requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+        : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr value_type operator*() const { return value_type{*this}; }
+    _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const { return value_type{*this}; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator& operator++() {
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator& operator++() {
       const auto __end = ranges::end(__parent_->__base_);
       if (__current() == __end) {
         __trailing_empty_ = false;
@@ -260,8 +243,7 @@ private:
       return *this;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator++(int) {
       if constexpr (forward_range<_Base>) {
         auto __tmp = *this;
         ++*this;
@@ -272,14 +254,13 @@ private:
       }
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
-      requires forward_range<_Base> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
+      requires forward_range<_Base>
+    {
       return __x.__current_ == __y.__current_ && __x.__trailing_empty_ == __y.__trailing_empty_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
       _LIBCPP_ASSERT_NON_NULL(__x.__parent_ != nullptr, "Cannot call comparison on a default-constructed iterator.");
       return __x.__current() == ranges::end(__x.__parent_base()) && !__x.__trailing_empty_;
     }
@@ -290,11 +271,10 @@ private:
 
   template <forward_range _Tp>
   struct __inner_iterator_category<_Tp> {
-    using iterator_category = _If<
-      derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
-      forward_iterator_tag,
-      typename iterator_traits<iterator_t<_Tp>>::iterator_category
-    >;
+    using iterator_category =
+        _If< derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
+             forward_iterator_tag,
+             typename iterator_traits<iterator_t<_Tp>>::iterator_category >;
   };
 
   template <bool _Const>
@@ -303,18 +283,17 @@ private:
     using _Base = __maybe_const<_Const, _View>;
     // Workaround for a GCC issue.
     static constexpr bool _OuterConst = _Const;
-    __outer_iterator<_Const> __i_ = __outer_iterator<_OuterConst>();
-    bool __incremented_ = false;
+    __outer_iterator<_Const> __i_     = __outer_iterator<_OuterConst>();
+    bool __incremented_               = false;
 
     // Note: these private functions are necessary because GCC doesn't allow calls to private members of `__i_` from
     // free functions that are friends of `inner-iterator`.
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool __is_done() const {
+    _LIBCPP_HIDE_FROM_ABI constexpr bool __is_done() const {
       _LIBCPP_ASSERT_NON_NULL(__i_.__parent_ != nullptr, "Cannot call comparison on a default-constructed iterator.");
 
       auto [__pcur, __pend] = ranges::subrange{__i_.__parent_->__pattern_};
-      auto __end = ranges::end(__i_.__parent_->__base_);
+      auto __end            = ranges::end(__i_.__parent_->__base_);
 
       if constexpr (__tiny_range<_Pattern>) {
         const auto& __cur = __i_.__current();
@@ -343,40 +322,32 @@ private:
       }
     }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __outer_current() noexcept {
-      return __i_.__current();
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __outer_current() noexcept { return __i_.__current(); }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __outer_current() const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const auto& __outer_current() const noexcept {
       return __i_.__current();
     }
 
   public:
     // using iterator_category = inherited;
     using iterator_concept = typename __outer_iterator<_Const>::iterator_concept;
-    using value_type = range_value_t<_Base>;
-    using difference_type = range_difference_t<_Base>;
+    using value_type       = range_value_t<_Base>;
+    using difference_type  = range_difference_t<_Base>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __inner_iterator() = default;
+    _LIBCPP_HIDE_FROM_ABI __inner_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __inner_iterator(__outer_iterator<_Const> __i)
-      : __i_(std::move(__i)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __inner_iterator(__outer_iterator<_Const> __i) : __i_(std::move(__i)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_Base> base() &&
-      requires forward_range<_View> { return std::move(__i_.__current()); }
+    _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
+    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() &&
+      requires forward_range<_View>
+    {
+      return std::move(__i_.__current());
+    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator*() const { return *__i_.__current(); }
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return *__i_.__current(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __inner_iterator& operator++() {
+    _LIBCPP_HIDE_FROM_ABI constexpr __inner_iterator& operator++() {
       __incremented_ = true;
 
       if constexpr (!forward_range<_Base>) {
@@ -389,8 +360,7 @@ private:
       return *this;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator++(int) {
       if constexpr (forward_range<_Base>) {
         auto __tmp = *this;
         ++*this;
@@ -401,31 +371,29 @@ private:
       }
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
-      requires forward_range<_Base> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
+      requires forward_range<_Base>
+    {
       return __x.__outer_current() == __y.__outer_current();
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
       return __x.__is_done();
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) iter_move(const __inner_iterator& __i)
-        noexcept(noexcept(ranges::iter_move(__i.__outer_current()))) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto)
+    iter_move(const __inner_iterator& __i) noexcept(noexcept(ranges::iter_move(__i.__outer_current()))) {
       return ranges::iter_move(__i.__outer_current());
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(const __inner_iterator& __x, const __inner_iterator& __y)
-        noexcept(noexcept(ranges::iter_swap(__x.__outer_current(), __y.__outer_current())))
-        requires indirectly_swappable<iterator_t<_Base>> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(
+        const __inner_iterator& __x,
+        const __inner_iterator& __y) noexcept(noexcept(ranges::iter_swap(__x.__outer_current(), __y.__outer_current())))
+      requires indirectly_swappable<iterator_t<_Base>>
+    {
       ranges::iter_swap(__x.__outer_current(), __y.__outer_current());
     }
   };
-
 };
 
 template <class _Range, class _Pattern>
@@ -433,22 +401,21 @@ lazy_split_view(_Range&&, _Pattern&&) -> lazy_split_view<views::all_t<_Range>, v
 
 template <input_range _Range>
 lazy_split_view(_Range&&, range_value_t<_Range>)
-  -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+    -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
 
 namespace views {
 namespace __lazy_split_view {
 struct __fn {
   template <class _Range, class _Pattern>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
-    noexcept(noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
-    -> decltype(      lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
-    { return          lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+      noexcept(noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+          -> decltype(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))) {
+    return lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern));
+  }
 
   template <class _Pattern>
     requires constructible_from<decay_t<_Pattern>, _Pattern>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Pattern&& __pattern) const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
   }
@@ -456,7 +423,7 @@ struct __fn {
 } // namespace __lazy_split_view
 
 inline namespace __cpo {
-  inline constexpr auto lazy_split = __lazy_split_view::__fn{};
+inline constexpr auto lazy_split = __lazy_split_view::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/non_propagating_cache.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/non_propagating_cache.h
index f5223962049..b2de2d2ae1c 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/non_propagating_cache.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/non_propagating_cache.h
@@ -26,85 +26,74 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  // __non_propagating_cache is a helper type that allows storing an optional value in it,
-  // but which does not copy the source's value when it is copy constructed/assigned to,
-  // and which resets the source's value when it is moved-from.
-  //
-  // This type is used as an implementation detail of some views that need to cache the
-  // result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
-  // we don't want to propagate the value of the cache upon copy because the cached iterator
-  // may refer to internal details of the source view.
-  template<class _Tp>
-    requires is_object_v<_Tp>
-  class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
-    struct __from_tag { };
-    struct __forward_tag { };
-
-    // This helper class is needed to perform copy and move elision when
-    // constructing the contained type from an iterator.
-    struct __wrapper {
-      template <class... _Args>
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args)
-          : __t_(std::forward<_Args>(__args)...) {}
-      template <class _Fn>
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) {}
-      _Tp __t_;
-    };
-
-    optional<__wrapper> __value_ = nullopt;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
-      : __value_(nullopt)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
-      : __value_(nullopt)
-    {
-      __other.__value_.reset();
-    }
+// __non_propagating_cache is a helper type that allows storing an optional value in it,
+// but which does not copy the source's value when it is copy constructed/assigned to,
+// and which resets the source's value when it is moved-from.
+//
+// This type is used as an implementation detail of some views that need to cache the
+// result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
+// we don't want to propagate the value of the cache upon copy because the cached iterator
+// may refer to internal details of the source view.
+template <class _Tp>
+  requires is_object_v<_Tp>
+class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
+  struct __from_tag {};
+  struct __forward_tag {};
+
+  // This helper class is needed to perform copy and move elision when
+  // constructing the contained type from an iterator.
+  struct __wrapper {
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args)
+        : __t_(std::forward<_Args>(__args)...) {}
+    template <class _Fn>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) {}
+    _Tp __t_;
+  };
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
-      if (this != std::addressof(__other)) {
-        __value_.reset();
-      }
-      return *this;
-    }
+  optional<__wrapper> __value_ = nullopt;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
+      : __value_(nullopt) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
+      : __value_(nullopt) {
+    __other.__value_.reset();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
+    if (this != std::addressof(__other)) {
       __value_.reset();
-      __other.__value_.reset();
-      return *this;
     }
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& operator*() { return __value_->__t_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp const& operator*() const { return __value_->__t_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
+    __value_.reset();
+    __other.__value_.reset();
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool __has_value() const { return __value_.has_value(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() { return __value_->__t_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const { return __value_->__t_; }
 
-    template<class _Fn>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& __emplace_from(_Fn const& __f) {
-      return __value_.emplace(__from_tag{}, __f).__t_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const { return __value_.has_value(); }
 
-    template<class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& __emplace(_Args&& ...__args) {
-      return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
-    }
-  };
+  template <class _Fn>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __emplace_from(_Fn const& __f) {
+    return __value_.emplace(__from_tag{}, __f).__t_;
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __emplace(_Args&&... __args) {
+    return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
+  }
+};
 
-  struct __empty_cache { };
+struct __empty_cache {};
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/owning_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/owning_view.h
index c846de899b3..254bdb43291 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/owning_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/owning_view.h
@@ -35,47 +35,75 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<range _Rp>
-    requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
-  class owning_view : public view_interface<owning_view<_Rp>> {
-    _Rp __r_ = _Rp();
+template <range _Rp>
+  requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
+class owning_view : public view_interface<owning_view<_Rp>> {
+  _Rp __r_ = _Rp();
 
 public:
-    _LIBCPP_HIDE_FROM_ABI owning_view() requires default_initializable<_Rp> = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(std::move(__r)) {}
-
-    _LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&) = default;
-    _LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const requires range<const _Rp> { return ranges::begin(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto end() const requires range<const _Rp> { return ranges::end(__r_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr bool empty() requires requires { ranges::empty(__r_); }
-      { return ranges::empty(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const requires requires { ranges::empty(__r_); }
-      { return ranges::empty(__r_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr auto size() requires sized_range<_Rp>
-      { return ranges::size(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto size() const requires sized_range<const _Rp>
-      { return ranges::size(__r_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr auto data() requires contiguous_range<_Rp>
-      { return ranges::data(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto data() const requires contiguous_range<const _Rp>
-      { return ranges::data(__r_); }
-  };
-  _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
-
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
+  _LIBCPP_HIDE_FROM_ABI owning_view()
+    requires default_initializable<_Rp>
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(std::move(__r)) {}
+
+  _LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&)            = default;
+  _LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _Rp>
+  {
+    return ranges::begin(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _Rp>
+  {
+    return ranges::end(__r_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
+    requires requires { ranges::empty(__r_); }
+  {
+    return ranges::empty(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
+    requires requires { ranges::empty(__r_); }
+  {
+    return ranges::empty(__r_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_Rp>
+  {
+    return ranges::size(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _Rp>
+  {
+    return ranges::size(__r_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data()
+    requires contiguous_range<_Rp>
+  {
+    return ranges::data(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
+    requires contiguous_range<const _Rp>
+  {
+    return ranges::data(__r_);
+  }
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
+
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/range_adaptor.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/range_adaptor.h
index 2688e4cd043..726b7eda019 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/range_adaptor.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/range_adaptor.h
@@ -47,7 +47,7 @@ struct __range_adaptor_closure;
 // i.e. something that can be called via the `x | f` notation.
 template <class _Fn>
 struct __range_adaptor_closure_t : _Fn, __range_adaptor_closure<__range_adaptor_closure_t<_Fn>> {
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) { }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) {}
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__range_adaptor_closure_t);
 
@@ -56,23 +56,21 @@ concept _RangeAdaptorClosure = derived_from<remove_cvref_t<_Tp>, __range_adaptor
 
 template <class _Tp>
 struct __range_adaptor_closure {
-    template <ranges::viewable_range _View, _RangeAdaptorClosure _Closure>
-        requires same_as<_Tp, remove_cvref_t<_Closure>> &&
-                 invocable<_Closure, _View>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) operator|(_View&& __view, _Closure&& __closure)
-        noexcept(is_nothrow_invocable_v<_Closure, _View>)
-    { return std::invoke(std::forward<_Closure>(__closure), std::forward<_View>(__view)); }
+  template <ranges::viewable_range _View, _RangeAdaptorClosure _Closure>
+    requires same_as<_Tp, remove_cvref_t<_Closure>> && invocable<_Closure, _View>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto)
+  operator|(_View&& __view, _Closure&& __closure) noexcept(is_nothrow_invocable_v<_Closure, _View>) {
+    return std::invoke(std::forward<_Closure>(__closure), std::forward<_View>(__view));
+  }
 
-    template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
-        requires same_as<_Tp, remove_cvref_t<_Closure>> &&
-                 constructible_from<decay_t<_Closure>, _Closure> &&
-                 constructible_from<decay_t<_OtherClosure>, _OtherClosure>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2)
-        noexcept(is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
-                 is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>)
-    { return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1))); }
+  template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
+    requires same_as<_Tp, remove_cvref_t<_Closure>> && constructible_from<decay_t<_Closure>, _Closure> &&
+             constructible_from<decay_t<_OtherClosure>, _OtherClosure>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2) noexcept(
+      is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
+      is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>) {
+    return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1)));
+  }
 };
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/rbegin.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/rbegin.h
index 1ceb1116d69..7111201ae7d 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/rbegin.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/rbegin.h
@@ -36,57 +36,44 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __rbegin {
 template <class _Tp>
-concept __member_rbegin =
-  __can_borrow<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(__t.rbegin()) } -> input_or_output_iterator;
-  };
-
-void rbegin(auto&) = delete;
+concept __member_rbegin = __can_borrow<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.rbegin()) } -> input_or_output_iterator;
+};
+
+void rbegin(auto&)       = delete;
 void rbegin(const auto&) = delete;
 
 template <class _Tp>
 concept __unqualified_rbegin =
-  !__member_rbegin<_Tp> &&
-  __can_borrow<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(rbegin(__t)) } -> input_or_output_iterator;
-  };
+    !__member_rbegin<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { _LIBCPP_AUTO_CAST(rbegin(__t)) } -> input_or_output_iterator;
+    };
 
 template <class _Tp>
 concept __can_reverse =
-  __can_borrow<_Tp> &&
-  !__member_rbegin<_Tp> &&
-  !__unqualified_rbegin<_Tp> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
-    { ranges::begin(__t) } -> bidirectional_iterator;
-  };
+    __can_borrow<_Tp> && !__member_rbegin<_Tp> && !__unqualified_rbegin<_Tp> && requires(_Tp&& __t) {
+      { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+      { ranges::begin(__t) } -> bidirectional_iterator;
+    };
 
 struct __fn {
   template <class _Tp>
     requires __member_rbegin<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rbegin())))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rbegin()))) {
     return _LIBCPP_AUTO_CAST(__t.rbegin());
   }
 
   template <class _Tp>
     requires __unqualified_rbegin<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(rbegin(__t))))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(rbegin(__t)))) {
     return _LIBCPP_AUTO_CAST(rbegin(__t));
   }
 
   template <class _Tp>
     requires __can_reverse<_Tp>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::end(__t)))
-  {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(ranges::end(__t))) {
     return std::make_reverse_iterator(ranges::end(__t));
   }
 
@@ -95,7 +82,7 @@ struct __fn {
 } // namespace __rbegin
 
 inline namespace __cpo {
-  inline constexpr auto rbegin = __rbegin::__fn{};
+inline constexpr auto rbegin = __rbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -106,24 +93,24 @@ namespace __crbegin {
 struct __fn {
   template <class _Tp>
     requires is_lvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))))
-    -> decltype(      ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)))
-    { return          ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))))
+          -> decltype(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
   template <class _Tp>
     requires is_rvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
-    -> decltype(      ranges::rbegin(static_cast<const _Tp&&>(__t)))
-    { return          ranges::rbegin(static_cast<const _Tp&&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
+          -> decltype(ranges::rbegin(static_cast<const _Tp&&>(__t))) {
+    return ranges::rbegin(static_cast<const _Tp&&>(__t));
+  }
 };
 } // namespace __crbegin
 
 inline namespace __cpo {
-  inline constexpr auto crbegin = __crbegin::__fn{};
+inline constexpr auto crbegin = __crbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/ref_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/ref_view.h
index be32b812420..6213332a542 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/ref_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/ref_view.h
@@ -37,49 +37,49 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<range _Range>
-    requires is_object_v<_Range>
-  class ref_view : public view_interface<ref_view<_Range>> {
-    _Range *__range_;
+template <range _Range>
+  requires is_object_v<_Range>
+class ref_view : public view_interface<ref_view<_Range>> {
+  _Range* __range_;
 
-    static void __fun(_Range&);
-    static void __fun(_Range&&) = delete;
+  static void __fun(_Range&);
+  static void __fun(_Range&&) = delete;
 
 public:
-    template<class _Tp>
-      requires __different_from<_Tp, ref_view> &&
-        convertible_to<_Tp, _Range&> && requires { __fun(std::declval<_Tp>()); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr ref_view(_Tp&& __t)
-      : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
-    {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool empty() const
-      requires requires { ranges::empty(*__range_); }
-    { return ranges::empty(*__range_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires sized_range<_Range>
-    { return ranges::size(*__range_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto data() const
-      requires contiguous_range<_Range>
-    { return ranges::data(*__range_); }
-  };
-
-  template<class _Range>
-  ref_view(_Range&) -> ref_view<_Range>;
-
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
+  template <class _Tp>
+    requires __different_from<_Tp, ref_view> && convertible_to<_Tp, _Range&> && requires { __fun(std::declval<_Tp>()); }
+  _LIBCPP_HIDE_FROM_ABI constexpr ref_view(_Tp&& __t)
+      : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t)))) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
+    requires requires { ranges::empty(*__range_); }
+  {
+    return ranges::empty(*__range_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<_Range>
+  {
+    return ranges::size(*__range_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
+    requires contiguous_range<_Range>
+  {
+    return ranges::data(*__range_);
+  }
+};
+
+template <class _Range>
+ref_view(_Range&) -> ref_view<_Range>;
+
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/rend.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/rend.h
index 7ee574ccfa6..58d98aafd26 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/rend.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/rend.h
@@ -37,60 +37,47 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __rend {
 template <class _Tp>
-concept __member_rend =
-  __can_borrow<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    ranges::rbegin(__t);
-    { _LIBCPP_AUTO_CAST(__t.rend()) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
-  };
-
-void rend(auto&) = delete;
+concept __member_rend = __can_borrow<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  ranges::rbegin(__t);
+  { _LIBCPP_AUTO_CAST(__t.rend()) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+};
+
+void rend(auto&)       = delete;
 void rend(const auto&) = delete;
 
 template <class _Tp>
 concept __unqualified_rend =
-  !__member_rend<_Tp> &&
-  __can_borrow<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    ranges::rbegin(__t);
-    { _LIBCPP_AUTO_CAST(rend(__t)) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
-  };
+    !__member_rend<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      ranges::rbegin(__t);
+      { _LIBCPP_AUTO_CAST(rend(__t)) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+    };
 
 template <class _Tp>
-concept __can_reverse =
-  __can_borrow<_Tp> &&
-  !__member_rend<_Tp> &&
-  !__unqualified_rend<_Tp> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
-    { ranges::begin(__t) } -> bidirectional_iterator;
-  };
+concept __can_reverse = __can_borrow<_Tp> && !__member_rend<_Tp> && !__unqualified_rend<_Tp> && requires(_Tp&& __t) {
+  { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+  { ranges::begin(__t) } -> bidirectional_iterator;
+};
 
 class __fn {
 public:
   template <class _Tp>
     requires __member_rend<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rend())))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rend()))) {
     return _LIBCPP_AUTO_CAST(__t.rend());
   }
 
   template <class _Tp>
     requires __unqualified_rend<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(rend(__t))))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(rend(__t)))) {
     return _LIBCPP_AUTO_CAST(rend(__t));
   }
 
   template <class _Tp>
     requires __can_reverse<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::begin(__t)))
-  {
+      noexcept(noexcept(ranges::begin(__t))) {
     return std::make_reverse_iterator(ranges::begin(__t));
   }
 
@@ -99,7 +86,7 @@ public:
 } // namespace __rend
 
 inline namespace __cpo {
-  inline constexpr auto rend = __rend::__fn{};
+inline constexpr auto rend = __rend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -110,24 +97,24 @@ namespace __crend {
 struct __fn {
   template <class _Tp>
     requires is_lvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))))
-    -> decltype(      ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)))
-    { return          ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))))
+          -> decltype(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
   template <class _Tp>
     requires is_rvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rend(static_cast<const _Tp&&>(__t))))
-    -> decltype(      ranges::rend(static_cast<const _Tp&&>(__t)))
-    { return          ranges::rend(static_cast<const _Tp&&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rend(static_cast<const _Tp&&>(__t))))
+          -> decltype(ranges::rend(static_cast<const _Tp&&>(__t))) {
+    return ranges::rend(static_cast<const _Tp&&>(__t));
+  }
 };
 } // namespace __crend
 
 inline namespace __cpo {
-  inline constexpr auto crend = __crend::__fn{};
+inline constexpr auto crend = __crend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/reverse_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/reverse_view.h
index 01d1b97b3ce..f7846259810 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/reverse_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/reverse_view.h
@@ -38,151 +38,158 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<view _View>
-    requires bidirectional_range<_View>
-  class reverse_view : public view_interface<reverse_view<_View>> {
-    // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
-    // amortized O(1) begin() method.
-    static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
-    using _Cache = _If<_UseCache, __non_propagating_cache<reverse_iterator<iterator_t<_View>>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    reverse_view() requires default_initializable<_View> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit reverse_view(_View __view) : __base_(std::move(__view)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> begin() {
-      if constexpr (_UseCache)
-        if (__cached_begin_.__has_value())
-          return *__cached_begin_;
-
-      auto __tmp = std::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
-      if constexpr (_UseCache)
-        __cached_begin_.__emplace(__tmp);
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> begin() requires common_range<_View> {
-      return std::make_reverse_iterator(ranges::end(__base_));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const requires common_range<const _View> {
-      return std::make_reverse_iterator(ranges::end(__base_));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> end() {
-      return std::make_reverse_iterator(ranges::begin(__base_));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const requires common_range<const _View> {
-      return std::make_reverse_iterator(ranges::begin(__base_));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() requires sized_range<_View> {
-      return ranges::size(__base_);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const requires sized_range<const _View> {
-      return ranges::size(__base_);
-    }
-  };
-
-  template<class _Range>
-  reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
-
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<reverse_view<_Tp>> = enable_borrowed_range<_Tp>;
-
-  namespace views {
-  namespace __reverse {
-    template<class _Tp>
-    inline constexpr bool __is_reverse_view = false;
-
-    template<class _Tp>
-    inline constexpr bool __is_reverse_view<reverse_view<_Tp>> = true;
-
-    template<class _Tp>
-    inline constexpr bool __is_sized_reverse_subrange = false;
-
-    template<class _Iter>
-    inline constexpr bool __is_sized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, subrange_kind::sized>> = true;
-
-    template<class _Tp>
-    inline constexpr bool __is_unsized_reverse_subrange = false;
-
-    template<class _Iter, subrange_kind _Kind>
-    inline constexpr bool __is_unsized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> = _Kind == subrange_kind::unsized;
-
-    template<class _Tp>
-    struct __unwrapped_reverse_subrange {
-      using type = void; // avoid SFINAE-ing out the overload below -- let the concept requirements do it for better diagnostics
-    };
-
-    template<class _Iter, subrange_kind _Kind>
-    struct __unwrapped_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> {
-      using type = subrange<_Iter, _Iter, _Kind>;
-    };
-
-    struct __fn : __range_adaptor_closure<__fn> {
-      template<class _Range>
-        requires __is_reverse_view<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(std::forward<_Range>(__range).base()))
-        -> decltype(      std::forward<_Range>(__range).base())
-        { return          std::forward<_Range>(__range).base(); }
-
-      template<class _Range,
-               class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
-        requires __is_sized_reverse_subrange<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())))
-        -> decltype(      _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size()))
-        { return          _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size()); }
-
-      template<class _Range,
-               class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
-        requires __is_unsized_reverse_subrange<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base())))
-        -> decltype(      _UnwrappedSubrange(__range.end().base(), __range.begin().base()))
-        { return          _UnwrappedSubrange(__range.end().base(), __range.begin().base()); }
-
-      template<class _Range>
-        requires (!__is_reverse_view<remove_cvref_t<_Range>> &&
-                  !__is_sized_reverse_subrange<remove_cvref_t<_Range>> &&
-                  !__is_unsized_reverse_subrange<remove_cvref_t<_Range>>)
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(reverse_view{std::forward<_Range>(__range)}))
-        -> decltype(      reverse_view{std::forward<_Range>(__range)})
-        { return          reverse_view{std::forward<_Range>(__range)}; }
-    };
-  } // namespace __reverse
-
-  inline namespace __cpo {
-    inline constexpr auto reverse = __reverse::__fn{};
-  } // namespace __cpo
-  } // namespace views
+template <view _View>
+  requires bidirectional_range<_View>
+class reverse_view : public view_interface<reverse_view<_View>> {
+  // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
+  // amortized O(1) begin() method.
+  static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
+  using _Cache = _If<_UseCache, __non_propagating_cache<reverse_iterator<iterator_t<_View>>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_          = _View();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI reverse_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit reverse_view(_View __view) : __base_(std::move(__view)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> begin() {
+    if constexpr (_UseCache)
+      if (__cached_begin_.__has_value())
+        return *__cached_begin_;
+
+    auto __tmp = std::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
+    if constexpr (_UseCache)
+      __cached_begin_.__emplace(__tmp);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> begin()
+    requires common_range<_View>
+  {
+    return std::make_reverse_iterator(ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires common_range<const _View>
+  {
+    return std::make_reverse_iterator(ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> end() {
+    return std::make_reverse_iterator(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires common_range<const _View>
+  {
+    return std::make_reverse_iterator(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+};
+
+template <class _Range>
+reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
+
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<reverse_view<_Tp>> = enable_borrowed_range<_Tp>;
+
+namespace views {
+namespace __reverse {
+template <class _Tp>
+inline constexpr bool __is_reverse_view = false;
+
+template <class _Tp>
+inline constexpr bool __is_reverse_view<reverse_view<_Tp>> = true;
+
+template <class _Tp>
+inline constexpr bool __is_sized_reverse_subrange = false;
+
+template <class _Iter>
+inline constexpr bool
+    __is_sized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, subrange_kind::sized>> =
+        true;
+
+template <class _Tp>
+inline constexpr bool __is_unsized_reverse_subrange = false;
+
+template <class _Iter, subrange_kind _Kind>
+inline constexpr bool __is_unsized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> =
+    _Kind == subrange_kind::unsized;
+
+template <class _Tp>
+struct __unwrapped_reverse_subrange {
+  using type =
+      void; // avoid SFINAE-ing out the overload below -- let the concept requirements do it for better diagnostics
+};
+
+template <class _Iter, subrange_kind _Kind>
+struct __unwrapped_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> {
+  using type = subrange<_Iter, _Iter, _Kind>;
+};
+
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+    requires __is_reverse_view<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(std::forward<_Range>(__range).base())) -> decltype(std::forward<_Range>(__range).base()) {
+    return std::forward<_Range>(__range).base();
+  }
+
+  template <class _Range,
+            class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
+    requires __is_sized_reverse_subrange<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())))
+          -> decltype(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())) {
+    return _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size());
+  }
+
+  template <class _Range,
+            class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
+    requires __is_unsized_reverse_subrange<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base())))
+          -> decltype(_UnwrappedSubrange(__range.end().base(), __range.begin().base())) {
+    return _UnwrappedSubrange(__range.end().base(), __range.begin().base());
+  }
+
+  template <class _Range>
+    requires(!__is_reverse_view<remove_cvref_t<_Range>> && !__is_sized_reverse_subrange<remove_cvref_t<_Range>> &&
+             !__is_unsized_reverse_subrange<remove_cvref_t<_Range>>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(reverse_view{std::forward<_Range>(__range)}))
+          -> decltype(reverse_view{std::forward<_Range>(__range)}) {
+    return reverse_view{std::forward<_Range>(__range)};
+  }
+};
+} // namespace __reverse
+
+inline namespace __cpo {
+inline constexpr auto reverse = __reverse::__fn{};
+} // namespace __cpo
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/single_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/single_view.h
index 5724e2d1b6d..b0b2c1d9f3c 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/single_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/single_view.h
@@ -74,24 +74,24 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
 };
 
-template<class _Tp>
+template <class _Tp>
 single_view(_Tp) -> single_view<_Tp>;
 
 namespace views {
 namespace __single_view {
 
 struct __fn : __range_adaptor_closure<__fn> {
-  template<class _Range>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range) const
-    noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
-    -> decltype(      single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)))
-    { return          single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)); }
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
+          -> decltype(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))) {
+    return single_view<decay_t<_Range&&>>(std::forward<_Range>(__range));
+  }
 };
 } // namespace __single_view
 
 inline namespace __cpo {
-  inline constexpr auto single = __single_view::__fn{};
+inline constexpr auto single = __single_view::__fn{};
 } // namespace __cpo
 
 } // namespace views
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/size.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/size.h
index f22dd1ff7b7..14e21aae6bf 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/size.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/size.h
@@ -33,49 +33,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class>
-  inline constexpr bool disable_sized_range = false;
+template <class>
+inline constexpr bool disable_sized_range = false;
 } // namespace ranges
 
 // [range.prim.size]
 
 namespace ranges {
 namespace __size {
-void size(auto&) = delete;
+void size(auto&)       = delete;
 void size(const auto&) = delete;
 
 template <class _Tp>
 concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
 
 template <class _Tp>
-concept __member_size =
-  __size_enabled<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
-  };
+concept __member_size = __size_enabled<_Tp> && __workaround_52970<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
+};
 
 template <class _Tp>
 concept __unqualified_size =
-  __size_enabled<_Tp> &&
-  !__member_size<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
-  };
+    __size_enabled<_Tp> && !__member_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
+    };
 
 template <class _Tp>
 concept __difference =
-  !__member_size<_Tp> &&
-  !__unqualified_size<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> forward_iterator;
-    { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
-  };
+    !__member_size<_Tp> && !__unqualified_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { ranges::begin(__t) } -> forward_iterator;
+      { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
+    };
 
 struct __fn {
-
   // `[range.prim.size]`: the array case (for rvalues).
   template <class _Tp, size_t _Sz>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
@@ -105,16 +95,16 @@ struct __fn {
   // [range.prim.size]: the `to-unsigned-like` case.
   template <__difference _Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
-    -> decltype(      std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)))
-    { return          std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
+      noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
+          -> decltype(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))) {
+    return std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
   }
 };
 
 } // namespace __size
 
 inline namespace __cpo {
-  inline constexpr auto size = __size::__fn{};
+inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -123,10 +113,10 @@ inline namespace __cpo {
 namespace ranges {
 namespace __ssize {
 struct __fn {
-  template<class _Tp>
-    requires requires (_Tp&& __t) { ranges::size(__t); }
+  template <class _Tp>
+    requires requires(_Tp&& __t) { ranges::size(__t); }
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::size(__t))) {
+      noexcept(noexcept(ranges::size(__t))) {
     using _Signed = make_signed_t<decltype(ranges::size(__t))>;
     if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
       return static_cast<ptrdiff_t>(ranges::size(__t));
@@ -137,7 +127,7 @@ struct __fn {
 } // namespace __ssize
 
 inline namespace __cpo {
-  inline constexpr auto ssize = __ssize::__fn{};
+inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/subrange.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/subrange.h
index 75f9284a582..a7a3c1efa70 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/subrange.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/subrange.h
@@ -54,208 +54,188 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _From, class _To>
-  concept __uses_nonqualification_pointer_conversion =
+template <class _From, class _To>
+concept __uses_nonqualification_pointer_conversion =
     is_pointer_v<_From> && is_pointer_v<_To> &&
-    !convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>;
-
-  template<class _From, class _To>
-  concept __convertible_to_non_slicing =
-    convertible_to<_From, _To> &&
-    !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
-
-  template<class _Pair, class _Iter, class _Sent>
-  concept __pair_like_convertible_from =
-    !range<_Pair> && __pair_like<_Pair> &&
-    constructible_from<_Pair, _Iter, _Sent> &&
-    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
-    convertible_to<_Sent, tuple_element_t<1, _Pair>>;
-
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
-           subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
-             ? subrange_kind::sized
-             : subrange_kind::unsized>
-    requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
-  class _LIBCPP_TEMPLATE_VIS subrange
-    : public view_interface<subrange<_Iter, _Sent, _Kind>>
-  {
-  public:
-    // Note: this is an internal implementation detail that is public only for internal usage.
-    static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
-
-  private:
-    static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
-    struct _Empty { _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept { } };
-    using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
-    _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_ = _Sent();
-    _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_ = 0;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    subrange() requires default_initializable<_Iter> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
-      requires _MustProvideSizeAtConstruction
-      : __begin_(std::move(__iter)), __end_(std::move(__sent))
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
-                       make_unsigned_t<iter_difference_t<_Iter>> __n)
-      requires (_Kind == subrange_kind::sized)
-      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n)
-    {
-      if constexpr (sized_sentinel_for<_Sent, _Iter>)
-        _LIBCPP_ASSERT_UNCATEGORIZED((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
-          "std::ranges::subrange was passed an invalid size hint");
-    }
+    !convertible_to<remove_pointer_t<_From> (*)[], remove_pointer_t<_To> (*)[]>;
+
+template <class _From, class _To>
+concept __convertible_to_non_slicing =
+    convertible_to<_From, _To> && !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
+
+template <class _Pair, class _Iter, class _Sent>
+concept __pair_like_convertible_from =
+    !range<_Pair> && __pair_like<_Pair> && constructible_from<_Pair, _Iter, _Sent> &&
+    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> && convertible_to<_Sent, tuple_element_t<1, _Pair>>;
+
+template <input_or_output_iterator _Iter,
+          sentinel_for<_Iter> _Sent = _Iter,
+          subrange_kind _Kind       = sized_sentinel_for<_Sent, _Iter> ? subrange_kind::sized : subrange_kind::unsized>
+  requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+class _LIBCPP_TEMPLATE_VIS subrange : public view_interface<subrange<_Iter, _Sent, _Kind>> {
+public:
+  // Note: this is an internal implementation detail that is public only for internal usage.
+  static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
+
+private:
+  static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
+  struct _Empty {
+    _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept {}
+  };
+  using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_   = _Sent();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_  = 0;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI subrange()
+    requires default_initializable<_Iter>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
+    requires _MustProvideSizeAtConstruction
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(
+      __convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent, make_unsigned_t<iter_difference_t<_Iter>> __n)
+    requires(_Kind == subrange_kind::sized)
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n) {
+    if constexpr (sized_sentinel_for<_Sent, _Iter>)
+      _LIBCPP_ASSERT_UNCATEGORIZED((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
+                                   "std::ranges::subrange was passed an invalid size hint");
+  }
 
-    template<__different_from<subrange> _Range>
-      requires borrowed_range<_Range> &&
-               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range)
-      requires (!_StoreSize)
-      : subrange(ranges::begin(__range), ranges::end(__range))
-    { }
-
-    template<__different_from<subrange> _Range>
-      requires borrowed_range<_Range> &&
-               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range)
-      requires _StoreSize && sized_range<_Range>
-      : subrange(__range, ranges::size(__range))
-    { }
-
-    template<borrowed_range _Range>
-      requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
-      requires (_Kind == subrange_kind::sized)
-      : subrange(ranges::begin(__range), ranges::end(__range), __n)
-    { }
-
-    template<__different_from<subrange> _Pair>
-      requires __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr operator _Pair() const {
-      return _Pair(__begin_, __end_);
-    }
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires(!_StoreSize)
+      : subrange(ranges::begin(__range), ranges::end(__range)) {}
+
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires _StoreSize && sized_range<_Range>
+      : subrange(__range, ranges::size(__range)) {}
+
+  template <borrowed_range _Range>
+    requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
+               requires(_Kind == subrange_kind::sized)
+      : subrange(ranges::begin(__range), ranges::end(__range), __n) {}
+
+  template <__different_from<subrange> _Pair>
+    requires __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator _Pair() const {
+    return _Pair(__begin_, __end_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Iter begin() const requires copyable<_Iter> {
-      return __begin_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() const
+    requires copyable<_Iter>
+  {
+    return __begin_;
+  }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() requires (!copyable<_Iter>) {
-      return std::move(__begin_);
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin()
+    requires(!copyable<_Iter>)
+  {
+    return std::move(__begin_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Sent end() const {
-      return __end_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Sent end() const { return __end_; }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const {
-      return __begin_ == __end_;
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __begin_ == __end_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
-      requires (_Kind == subrange_kind::sized)
-    {
-      if constexpr (_StoreSize)
-        return __size_;
-      else
-        return std::__to_unsigned_like(__end_ - __begin_);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
+    requires(_Kind == subrange_kind::sized)
+  {
+    if constexpr (_StoreSize)
+      return __size_;
+    else
+      return std::__to_unsigned_like(__end_ - __begin_);
+  }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
-      requires forward_iterator<_Iter>
-    {
-      auto __tmp = *this;
-      __tmp.advance(__n);
-      return __tmp;
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+    requires forward_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(__n);
+    return __tmp;
+  }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
-      advance(__n);
-      return std::move(*this);
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+    advance(__n);
+    return std::move(*this);
+  }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
-      requires bidirectional_iterator<_Iter>
-    {
-      auto __tmp = *this;
-      __tmp.advance(-__n);
-      return __tmp;
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+    requires bidirectional_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(-__n);
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange& advance(iter_difference_t<_Iter> __n) {
-      if constexpr (bidirectional_iterator<_Iter>) {
-        if (__n < 0) {
-          ranges::advance(__begin_, __n);
-          if constexpr (_StoreSize)
-            __size_ += std::__to_unsigned_like(-__n);
-          return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange& advance(iter_difference_t<_Iter> __n) {
+    if constexpr (bidirectional_iterator<_Iter>) {
+      if (__n < 0) {
+        ranges::advance(__begin_, __n);
+        if constexpr (_StoreSize)
+          __size_ += std::__to_unsigned_like(-__n);
+        return *this;
       }
-
-      auto __d = __n - ranges::advance(__begin_, __n, __end_);
-      if constexpr (_StoreSize)
-        __size_ -= std::__to_unsigned_like(__d);
-      return *this;
     }
-  };
-
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
-  subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
 
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
-  subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>)
-    -> subrange<_Iter, _Sent, subrange_kind::sized>;
+    auto __d = __n - ranges::advance(__begin_, __n, __end_);
+    if constexpr (_StoreSize)
+      __size_ -= std::__to_unsigned_like(__d);
+    return *this;
+  }
+};
 
-  template<borrowed_range _Range>
-  subrange(_Range&&) -> subrange<iterator_t<_Range>, sentinel_t<_Range>,
-                                 (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
-                                   ? subrange_kind::sized : subrange_kind::unsized>;
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
 
-  template<borrowed_range _Range>
-  subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
-    -> subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>) -> subrange<_Iter, _Sent, subrange_kind::sized>;
 
-  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-    requires ((_Index == 0 && copyable<_Iter>) || _Index == 1)
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
-    if constexpr (_Index == 0)
-      return __subrange.begin();
-    else
-      return __subrange.end();
-  }
+template <borrowed_range _Range>
+subrange(_Range&&)
+    -> subrange<iterator_t<_Range>,
+                sentinel_t<_Range>,
+                (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
+                    ? subrange_kind::sized
+                    : subrange_kind::unsized>;
 
-  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-    requires (_Index < 2)
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
-    if constexpr (_Index == 0)
-      return __subrange.begin();
-    else
-      return __subrange.end();
-  }
-
-  template<class _Ip, class _Sp, subrange_kind _Kp>
-  inline constexpr bool enable_borrowed_range<subrange<_Ip, _Sp, _Kp>> = true;
+template <borrowed_range _Range>
+subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
+    -> subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
 
-  template<range _Rp>
-  using borrowed_subrange_t = _If<borrowed_range<_Rp>, subrange<iterator_t<_Rp>>, dangling>;
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
+
+template <class _Ip, class _Sp, subrange_kind _Kp>
+inline constexpr bool enable_borrowed_range<subrange<_Ip, _Sp, _Kp>> = true;
+
+template <range _Rp>
+using borrowed_subrange_t = _If<borrowed_range<_Rp>, subrange<iterator_t<_Rp>>, dangling>;
 } // namespace ranges
 
 // [range.subrange.general]
@@ -264,25 +244,25 @@ using ranges::get;
 
 // [ranges.syn]
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_size<ranges::subrange<_Ip, _Sp, _Kp>> : integral_constant<size_t, 2> {};
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<0, ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Ip;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<1, ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Sp;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<0, const ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Ip;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Sp;
 };
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/take_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/take_view.h
index 518375d684a..4fd1d8b9ab8 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/take_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/take_view.h
@@ -57,37 +57,42 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<view _View>
+template <view _View>
 class take_view : public view_interface<take_view<_View>> {
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  range_difference_t<_View> __count_ = 0;
+  range_difference_t<_View> __count_      = 0;
 
-  template<bool> class __sentinel;
+  template <bool>
+  class __sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  take_view() requires default_initializable<_View> = default;
+  _LIBCPP_HIDE_FROM_ABI take_view()
+    requires default_initializable<_View>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_view(_View __base, range_difference_t<_View> __count)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  take_view(_View __base, range_difference_t<_View> __count)
       : __base_(std::move(__base)), __count_(__count) {
     _LIBCPP_ASSERT_UNCATEGORIZED(__count >= 0, "count has to be greater than or equal to zero");
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() requires (!__simple_view<_View>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
     if constexpr (sized_range<_View>) {
       if constexpr (random_access_range<_View>) {
         return ranges::begin(__base_);
       } else {
         using _DifferenceT = range_difference_t<_View>;
-        auto __size = size();
+        auto __size        = size();
         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
       }
     } else {
@@ -95,14 +100,15 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
     if constexpr (sized_range<const _View>) {
       if constexpr (random_access_range<const _View>) {
         return ranges::begin(__base_);
       } else {
         using _DifferenceT = range_difference_t<const _View>;
-        auto __size = size();
+        auto __size        = size();
         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
       }
     } else {
@@ -110,8 +116,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() requires (!__simple_view<_View>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
     if constexpr (sized_range<_View>) {
       if constexpr (random_access_range<_View>) {
         return ranges::begin(__base_) + size();
@@ -123,8 +130,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
     if constexpr (sized_range<const _View>) {
       if constexpr (random_access_range<const _View>) {
         return ranges::begin(__base_) + size();
@@ -136,47 +144,44 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
     auto __n = ranges::size(__base_);
     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
     auto __n = ranges::size(__base_);
     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
   }
 };
 
-template<view _View>
-template<bool _Const>
+template <view _View>
+template <bool _Const>
 class take_view<_View>::__sentinel {
   using _Base = __maybe_const<_Const, _View>;
-  template<bool _OtherConst>
-  using _Iter = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
+  template <bool _OtherConst>
+  using _Iter                                        = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
   _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
-  template<bool>
+  template <bool>
   friend class take_view<_View>::__sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __s)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __s)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-    : __end_(std::move(__s.__end_)) {}
+      : __end_(std::move(__s.__end_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr sentinel_t<_Base> base() const { return __end_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
     return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
   }
 
@@ -187,10 +192,10 @@ public:
   }
 };
 
-template<class _Range>
+template <class _Range>
 take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
 
-template<class _Tp>
+template <class _Tp>
 inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 namespace views {
@@ -234,7 +239,7 @@ struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
 };
 
 template <class _Iter, class _Sent, subrange_kind _Kind>
-  requires requires{typename subrange<_Iter>;}
+  requires requires { typename subrange<_Iter>; }
 struct __passthrough_type<subrange<_Iter, _Sent, _Kind>> {
   using type = subrange<_Iter>;
 };
@@ -246,62 +251,48 @@ struct __fn {
   // [range.take.overview]: the `empty_view` case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
     requires __is_empty_view<remove_cvref_t<_Range>>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&&) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
-    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
-    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&&) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+          -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range));
+  }
 
   // [range.take.overview]: the `span | basic_string_view | subrange` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_passthrough_specialization<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(__passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              )))
-    -> decltype(      __passthrough_type_t<_RawRange>(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ))
-    { return          __passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ); }
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_passthrough_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
+  operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(__passthrough_type_t<_RawRange>(
+      ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))))
+      -> decltype(__passthrough_type_t<_RawRange>(
+          // Note: deliberately not forwarding `__rng` to guard against double moves.
+          ranges::begin(__rng),
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))) {
+    return __passthrough_type_t<_RawRange>(
+        ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)));
+  }
 
   // [range.take.overview]: the `iota_view` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_iota_specialization<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(ranges::iota_view(
-                              *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              )))
-    -> decltype(      ranges::iota_view(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ))
-    { return          ranges::iota_view(
-                              *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ); }
-// clang-format off
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_iota_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
+  operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(ranges::iota_view(
+      *ranges::begin(__rng), *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))))
+      -> decltype(ranges::iota_view(
+          // Note: deliberately not forwarding `__rng` to guard against double moves.
+          *ranges::begin(__rng),
+          *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))) {
+    return ranges::iota_view(*ranges::begin(__rng),
+                             *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)));
+  }
+  // clang-format off
 #if _LIBCPP_STD_VER >= 23
   // [range.take.overview]: the `repeat_view` "_RawRange models sized_range" case.
   template <class _Range,
@@ -325,42 +316,37 @@ struct __fn {
     -> decltype(      views::repeat(*__range.__value_, static_cast<_Dist>(__n)))
     { return          views::repeat(*__range.__value_, static_cast<_Dist>(__n)); }
 #endif
-// clang-format on
+  // clang-format on
 
   // [range.take.overview]: the "otherwise" case.
-  template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
-            class _RawRange = remove_cvref_t<_Range>>
-    // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
-    // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
-#if _LIBCPP_STD_VER >= 23
-                __is_repeat_specialization<_RawRange> ||
-#endif
-               (__is_iota_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>) ||
-               (__is_passthrough_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>)
-             ))
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&& __n) const
-    noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
-    -> decltype(      take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
-    { return          take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np, class _RawRange = remove_cvref_t<_Range>>
+  // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
+  // overloads.
+    requires(!(__is_empty_view<_RawRange> ||
+#  if _LIBCPP_STD_VER >= 23
+               __is_repeat_specialization<_RawRange> ||
+#  endif
+               (__is_iota_specialization<_RawRange> && sized_range<_RawRange> && random_access_range<_RawRange>) ||
+               (__is_passthrough_specialization<_RawRange> && sized_range<_RawRange> &&
+                random_access_range<_RawRange>)))
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+          -> decltype(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
+    return take_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
+  }
 
   template <class _Np>
     requires constructible_from<decay_t<_Np>, _Np>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Np&& __n) const
-    noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
-  { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Np&& __n) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n)));
+  }
 };
 
 } // namespace __take
 
 inline namespace __cpo {
-  inline constexpr auto take = __take::__fn{};
+inline constexpr auto take = __take::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/transform_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/transform_view.h
index 3678f9d64f7..55c6ce587bd 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/transform_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/transform_view.h
@@ -53,15 +53,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<class _Fn, class _View>
-concept __regular_invocable_with_range_ref =
-  regular_invocable<_Fn, range_reference_t<_View>>;
+template <class _Fn, class _View>
+concept __regular_invocable_with_range_ref = regular_invocable<_Fn, range_reference_t<_View>>;
 
-template<class _View, class _Fn>
+template <class _View, class _Fn>
 concept __transform_view_constraints =
-  view<_View> && is_object_v<_Fn> &&
-  regular_invocable<_Fn&, range_reference_t<_View>> &&
-  __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
+    view<_View> && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_View>> &&
+    __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
 
 #  if _LIBCPP_STD_VER >= 23
 template <input_range _View, move_constructible _Fn>
@@ -70,100 +68,99 @@ template <input_range _View, copy_constructible _Fn>
 #  endif
   requires __transform_view_constraints<_View, _Fn>
 class transform_view : public view_interface<transform_view<_View, _Fn>> {
-  template<bool> class __iterator;
-  template<bool> class __sentinel;
+  template <bool>
+  class __iterator;
+  template <bool>
+  class __sentinel;
 
   _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __func_;
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  transform_view()
-    requires default_initializable<_View> && default_initializable<_Fn> = default;
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 transform_view(_View __base, _Fn __func)
-    : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<false> begin() {
-    return __iterator<false>{*this, ranges::begin(__base_)};
+  _LIBCPP_HIDE_FROM_ABI transform_view()
+    requires default_initializable<_View> && default_initializable<_Fn>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 transform_view(_View __base, _Fn __func)
+      : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<true> begin() const
-    requires range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<false> begin() { return __iterator<false>{*this, ranges::begin(__base_)}; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<true> begin() const
+    requires range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel<false> end() {
-    return __sentinel<false>(ranges::end(__base_));
-  }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<false> end()
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel<false> end() { return __sentinel<false>(ranges::end(__base_)); }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<false> end()
     requires common_range<_View>
   {
     return __iterator<false>(*this, ranges::end(__base_));
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel<true> end() const
-    requires range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel<true> end() const
+    requires range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __sentinel<true>(ranges::end(__base_));
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<true> end() const
-    requires common_range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<true> end() const
+    requires common_range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
 };
 
-template<class _Range, class _Fn>
+template <class _Range, class _Fn>
 transform_view(_Range&&, _Fn) -> transform_view<views::all_t<_Range>, _Fn>;
 
-template<class _View>
-struct __transform_view_iterator_concept { using type = input_iterator_tag; };
+template <class _View>
+struct __transform_view_iterator_concept {
+  using type = input_iterator_tag;
+};
 
-template<random_access_range _View>
-struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
+template <random_access_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = random_access_iterator_tag;
+};
 
-template<bidirectional_range _View>
-struct __transform_view_iterator_concept<_View> { using type = bidirectional_iterator_tag; };
+template <bidirectional_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = bidirectional_iterator_tag;
+};
 
-template<forward_range _View>
-struct __transform_view_iterator_concept<_View> { using type = forward_iterator_tag; };
+template <forward_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = forward_iterator_tag;
+};
 
-template<class, class>
+template <class, class>
 struct __transform_view_iterator_category_base {};
 
-template<forward_range _View, class _Fn>
+template <forward_range _View, class _Fn>
 struct __transform_view_iterator_category_base<_View, _Fn> {
   using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
 
-  using iterator_category = conditional_t<
-    is_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
-    conditional_t<
-      derived_from<_Cat, contiguous_iterator_tag>,
-      random_access_iterator_tag,
-      _Cat
-    >,
-    input_iterator_tag
-  >;
+  using iterator_category =
+      conditional_t< is_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
+                     conditional_t< derived_from<_Cat, contiguous_iterator_tag>, random_access_iterator_tag, _Cat >,
+                     input_iterator_tag >;
 };
 
 #  if _LIBCPP_STD_VER >= 23
@@ -176,66 +173,54 @@ template <bool _Const>
 class transform_view<_View, _Fn>::__iterator : public __transform_view_iterator_category_base<_View, _Fn> {
 
   using _Parent = __maybe_const<_Const, transform_view>;
-  using _Base = __maybe_const<_Const, _View>;
+  using _Base   = __maybe_const<_Const, _View>;
 
-  _Parent *__parent_ = nullptr;
+  _Parent* __parent_ = nullptr;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__iterator;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
   iterator_t<_Base> __current_ = iterator_t<_Base>();
 
   using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
-  using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
-  using difference_type = range_difference_t<_Base>;
+  using value_type       = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
+  using difference_type  = range_difference_t<_Base>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  __iterator() requires default_initializable<iterator_t<_Base>> = default;
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires default_initializable<iterator_t<_Base>>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
-    : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
 
   // Note: `__i` should always be `__iterator<false>`, but directly using
   // `__iterator<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(__iterator<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-    : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr const iterator_t<_Base>& base() const& noexcept {
-    return __current_;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __current_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iterator_t<_Base> base() && {
-    return std::move(__current_);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() && { return std::move(__current_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator*() const
-    noexcept(noexcept(std::invoke(*__parent_->__func_, *__current_)))
-  {
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
+      noexcept(noexcept(std::invoke(*__parent_->__func_, *__current_))) {
     return std::invoke(*__parent_->__func_, *__current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
     ++__current_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator++(int) { ++__current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator++(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
     requires forward_range<_Base>
   {
     auto __tmp = *this;
@@ -243,16 +228,14 @@ public:
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator--()
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
     requires bidirectional_range<_Base>
   {
     --__current_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator--(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
     requires bidirectional_range<_Base>
   {
     auto __tmp = *this;
@@ -260,104 +243,88 @@ public:
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator+=(difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ += __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator-=(difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ -= __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](difference_type __n) const
-    noexcept(noexcept(std::invoke(*__parent_->__func_, __current_[__n])))
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
+      noexcept(noexcept(std::invoke(*__parent_->__func_, __current_[__n])))
     requires random_access_range<_Base>
   {
     return std::invoke(*__parent_->__func_, __current_[__n]);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
     requires equality_comparable<iterator_t<_Base>>
   {
     return __x.__current_ == __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ < __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ > __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ <= __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ >= __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
   {
     return __x.__current_ <=> __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ - __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
   {
     return __x.__current_ - __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr decltype(auto) iter_move(const __iterator& __i)
-    noexcept(noexcept(*__i))
-  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto) iter_move(const __iterator& __i) noexcept(noexcept(*__i)) {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
       return std::move(*__i);
     else
@@ -374,53 +341,46 @@ template <input_range _View, copy_constructible _Fn>
 template <bool _Const>
 class transform_view<_View, _Fn>::__sentinel {
   using _Parent = __maybe_const<_Const, transform_view>;
-  using _Base = __maybe_const<_Const, _View>;
+  using _Base   = __maybe_const<_Const, _View>;
 
   sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__iterator;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
 
   // Note: `__i` should always be `__sentinel<false>`, but directly using
   // `__sentinel<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-    : __end_(std::move(__i.__end_)) {}
+      : __end_(std::move(__i.__end_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr sentinel_t<_Base> base() const { return __end_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ == __y.__end_;
   }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ - __y.__end_;
   }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
     return __x.__end_ - __y.__current_;
   }
@@ -428,25 +388,25 @@ public:
 
 namespace views {
 namespace __transform {
-  struct __fn {
-    template<class _Range, class _Fn>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range, _Fn&& __f) const
+struct __fn {
+  template <class _Range, class _Fn>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Fn&& __f) const
       noexcept(noexcept(transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f))))
-      -> decltype(      transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)))
-      { return          transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)); }
-
-    template<class _Fn>
-      requires constructible_from<decay_t<_Fn>, _Fn>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Fn&& __f) const
-      noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>)
-    { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f))); }
-  };
+          -> decltype(transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f))) {
+    return transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f));
+  }
+
+  template <class _Fn>
+    requires constructible_from<decay_t<_Fn>, _Fn>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f)));
+  }
+};
 } // namespace __transform
 
 inline namespace __cpo {
-  inline constexpr auto transform = __transform::__fn{};
+inline constexpr auto transform = __transform::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/view_interface.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/view_interface.h
index e548355d29a..3216e0bd6ff 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/view_interface.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/view_interface.h
@@ -35,135 +35,117 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<class _Derived>
+template <class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface {
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Derived& __derived() noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Derived& __derived() noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived&>(*this);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Derived const& __derived() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Derived const& __derived() const noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived const&>(*this);
   }
 
 public:
-  template<class _D2 = _Derived>
+  template <class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
     requires forward_range<_D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
-  template<class _D2 = _Derived>
+  template <class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
     requires forward_range<const _D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit operator bool()
-    requires requires (_D2& __t) { ranges::empty(__t); }
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool()
+    requires requires(_D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit operator bool() const
-    requires requires (const _D2& __t) { ranges::empty(__t); }
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const
+    requires requires(const _D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto data()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data()
     requires contiguous_iterator<iterator_t<_D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto data() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
     requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
     requires forward_range<_D2> && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
   {
     return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
     requires forward_range<const _D2> && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
   {
     return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) front()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front()
     requires forward_range<_D2>
   {
-    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(),
-        "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        !empty(), "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) front() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front() const
     requires forward_range<const _D2>
   {
-    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(),
-        "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        !empty(), "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) back()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back()
     requires bidirectional_range<_D2> && common_range<_D2>
   {
-    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(),
-        "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(), "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) back() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back() const
     requires bidirectional_range<const _D2> && common_range<const _D2>
   {
-    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(),
-        "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(!empty(), "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
-  template<random_access_range _RARange = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](range_difference_t<_RARange> __index)
-  {
+  template <random_access_range _RARange = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) {
     return ranges::begin(__derived())[__index];
   }
 
-  template<random_access_range _RARange = const _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
-  {
+  template <random_access_range _RARange = const _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const {
     return ranges::begin(__derived())[__index];
   }
 };
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/views.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/views.h
index 906c4e46c34..a4de2a5e52a 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/views.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/views.h
@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-namespace views { }
+namespace views {}
 
 } // namespace ranges
 
diff --git a/contrib/libs/cxxsupp/libcxx/include/__ranges/zip_view.h b/contrib/libs/cxxsupp/libcxx/include/__ranges/zip_view.h
index 2fd1fb30475..4898c0afc87 100644
--- a/contrib/libs/cxxsupp/libcxx/include/__ranges/zip_view.h
+++ b/contrib/libs/cxxsupp/libcxx/include/__ranges/zip_view.h
@@ -52,9 +52,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class... _Ranges>
-concept __zip_is_common = (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
-                          (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
-                          ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
+concept __zip_is_common =
+    (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
+    (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
+    ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
 
 template <typename _Tp, typename _Up>
 auto __tuple_or_pair_test() -> pair<_Tp, _Up>;
@@ -87,31 +88,39 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __tuple_for_each(_Fun&& __f, _Tuple&& __tup
 
 template <class _Fun, class _Tuple1, class _Tuple2, size_t... _Indices>
 _LIBCPP_HIDE_FROM_ABI constexpr __tuple_or_pair<
-    invoke_result_t<_Fun&, typename tuple_element<_Indices, remove_cvref_t<_Tuple1>>::type,
+    invoke_result_t<_Fun&,
+                    typename tuple_element<_Indices, remove_cvref_t<_Tuple1>>::type,
                     typename tuple_element<_Indices, remove_cvref_t<_Tuple2>>::type>...>
 __tuple_zip_transform(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2, index_sequence<_Indices...>) {
-  return {std::invoke(__f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
+  return {std::invoke(__f,
+                      std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
                       std::get<_Indices>(std::forward<_Tuple2>(__tuple2)))...};
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_transform(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2) {
-  return ranges::__tuple_zip_transform(__f, std::forward<_Tuple1>(__tuple1), std::forward<_Tuple2>(__tuple2),
-                                       std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+  return ranges::__tuple_zip_transform(
+      __f,
+      std::forward<_Tuple1>(__tuple1),
+      std::forward<_Tuple2>(__tuple2),
+      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2, size_t... _Indices>
-_LIBCPP_HIDE_FROM_ABI constexpr void __tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2,
-                                                          index_sequence<_Indices...>) {
-  (std::invoke(__f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
-               std::get<_Indices>(std::forward<_Tuple2>(__tuple2))),
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2, index_sequence<_Indices...>) {
+  (std::invoke(
+       __f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)), std::get<_Indices>(std::forward<_Tuple2>(__tuple2))),
    ...);
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2) {
-  return ranges::__tuple_zip_for_each(__f, std::forward<_Tuple1>(__tuple1), std::forward<_Tuple2>(__tuple2),
-                                      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+  return ranges::__tuple_zip_for_each(
+      __f,
+      std::forward<_Tuple1>(__tuple1),
+      std::forward<_Tuple2>(__tuple2),
+      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
 }
 
 template <class _Tuple1, class _Tuple2>
@@ -130,7 +139,6 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __abs(_Tp __t) {
 template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 class zip_view : public view_interface<zip_view<_Views...>> {
-
   _LIBCPP_NO_UNIQUE_ADDRESS tuple<_Views...> __views_;
 
   template <bool>
@@ -140,27 +148,25 @@ class zip_view : public view_interface<zip_view<_Views...>> {
   class __sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  zip_view() = default;
+  _LIBCPP_HIDE_FROM_ABI zip_view() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit zip_view(_Views... __views) : __views_(std::move(__views)...) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit zip_view(_Views... __views) : __views_(std::move(__views)...) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin()
-    requires(!(__simple_view<_Views> && ...)) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!(__simple_view<_Views> && ...))
+  {
     return __iterator<false>(ranges::__tuple_transform(ranges::begin, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const
-    requires(range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires(range<const _Views> && ...)
+  {
     return __iterator<true>(ranges::__tuple_transform(ranges::begin, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end()
-    requires(!(__simple_view<_Views> && ...)) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!(__simple_view<_Views> && ...))
+  {
     if constexpr (!__zip_is_common<_Views...>) {
       return __sentinel<false>(ranges::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<_Views> && ...)) {
@@ -170,9 +176,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const
-    requires(range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires(range<const _Views> && ...)
+  {
     if constexpr (!__zip_is_common<const _Views...>) {
       return __sentinel<true>(ranges::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<const _Views> && ...)) {
@@ -182,9 +188,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size()
-    requires(sized_range<_Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires(sized_range<_Views> && ...)
+  {
     return std::apply(
         [](auto... __sizes) {
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
@@ -193,9 +199,9 @@ public:
         ranges::__tuple_transform(ranges::size, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const
-    requires(sized_range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(sized_range<const _Views> && ...)
+  {
     return std::apply(
         [](auto... __sizes) {
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
@@ -243,11 +249,10 @@ template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 template <bool _Const>
 class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base<_Const, _Views...> {
-
   __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current_;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __iterator(__tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(
+      __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
       : __current_(std::move(__current)) {}
 
   template <bool>
@@ -260,78 +265,73 @@ class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base
 
 public:
   using iterator_concept = decltype(__get_zip_view_iterator_tag<_Const, _Views...>());
-  using value_type = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
-  using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
+  using value_type       = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
+  using difference_type  = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  __iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(__iterator<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<__maybe_const<_Const, _Views>>> && ...)
-  : __current_(std::move(__i.__current_)) {}
+      : __current_(std::move(__i.__current_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator*() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const {
     return ranges::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
     ranges::__tuple_for_each([](auto& __i) { ++__i; }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator++(int) { ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator++(int)
-    requires __zip_all_forward<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires __zip_all_forward<_Const, _Views...>
+  {
     auto __tmp = *this;
     ++*this;
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator--()
-    requires __zip_all_bidirectional<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires __zip_all_bidirectional<_Const, _Views...>
+  {
     ranges::__tuple_for_each([](auto& __i) { --__i; }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator--(int)
-    requires __zip_all_bidirectional<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires __zip_all_bidirectional<_Const, _Views...>
+  {
     auto __tmp = *this;
     --*this;
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator+=(difference_type __x)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i += iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator-=(difference_type __x)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i -= iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator[](difference_type __n) const
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return ranges::__tuple_transform(
         [&]<class _Iter>(_Iter& __i) -> decltype(auto) { return __i[iter_difference_t<_Iter>(__n)]; }, __current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-    requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     if constexpr (__zip_all_bidirectional<_Const, _Views...>) {
       return __x.__current_ == __y.__current_;
     } else {
@@ -339,85 +339,85 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __x.__current_ < __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __y < __x;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return !(__y < __x);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return !(__x < __y);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> &&
-             (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+             (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     return __x.__current_ <=> __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     auto __r = __i;
     __r += __n;
     return __r;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __i + __n;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     auto __r = __i;
     __r -= __n;
     return __r;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     requires(sized_sentinel_for<iterator_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
-             ...) {
+             ...)
+  {
     const auto __diffs = ranges::__tuple_zip_transform(minus<>(), __x.__current_, __y.__current_);
     return std::apply(
         [](auto... __ds) {
-          return ranges::min({difference_type(__ds)...},
-                             [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
+          return ranges::min({difference_type(__ds)...}, [](auto __a, auto __b) {
+            return ranges::__abs(__a) < ranges::__abs(__b);
+          });
         },
         __diffs);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto iter_move(const __iterator& __i) noexcept(
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
       (noexcept(ranges::iter_move(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) && ...) &&
       (is_nothrow_move_constructible_v<range_rvalue_reference_t<__maybe_const<_Const, _Views>>> && ...)) {
     return ranges::__tuple_transform(ranges::iter_move, __i.__current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
       (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>(),
                                   std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) &&
        ...))
-    requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+    requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     ranges::__tuple_zip_for_each(ranges::iter_swap, __l.__current_, __r.__current_);
   }
 };
@@ -426,11 +426,11 @@ template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 template <bool _Const>
 class zip_view<_Views...>::__sentinel {
-
   __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end_;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(__tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end) : __end_(__end) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(
+      __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end)
+      : __end_(__end) {}
 
   friend class zip_view<_Views...>;
 
@@ -442,13 +442,11 @@ class zip_view<_Views...>::__sentinel {
   }
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && (convertible_to<sentinel_t<_Views>, sentinel_t<__maybe_const<_Const, _Views>>> && ...)
-  : __end_(std::move(__i.__end_)) {}
+      : __end_(std::move(__i.__end_)) {}
 
   template <bool _OtherConst>
     requires(sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_OtherConst, _Views>>> &&
@@ -467,8 +465,9 @@ public:
     return std::apply(
         [](auto... __ds) {
           using _Diff = common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>;
-          return ranges::min({_Diff(__ds)...},
-                             [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
+          return ranges::min({_Diff(__ds)...}, [](auto __a, auto __b) {
+            return ranges::__abs(__a) < ranges::__abs(__b);
+          });
         },
         __diffs);
   }
@@ -502,7 +501,7 @@ struct __fn {
 
 } // namespace __zip
 inline namespace __cpo {
-  inline constexpr auto zip = __zip::__fn{};
+inline constexpr auto zip = __zip::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges