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

1 files changed, 600 insertions, 600 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/iterator b/contrib/libs/cxxsupp/libcxx/include/iterator
index 1f34d250f5..f4fb32889e 100644
--- a/contrib/libs/cxxsupp/libcxx/include/iterator
+++ b/contrib/libs/cxxsupp/libcxx/include/iterator
@@ -1,345 +1,345 @@
-// -*- C++ -*-
-//===-------------------------- iterator ----------------------------------===//
-//
+// -*- C++ -*- 
+//===-------------------------- iterator ----------------------------------===// 
+// 
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_ITERATOR
-#define _LIBCPP_ITERATOR
-
-/*
-    iterator synopsis
-
-#include <concepts>
-
-namespace std
-{
-template<class> struct incrementable_traits;       // since C++20
-template<class T>
-  using iter_difference_t = see below;             // since C++20
-
-template<class> struct indirectly_readable_traits; // since C++20
-template<class T>
-  using iter_value_t = see below;                  // since C++20
-
-template<class Iterator>
-struct iterator_traits;
-
-template<class T>
-  requires is_object_v<T>                    // since C++20
-struct iterator_traits<T*>;
-
-template<dereferenceable T>
-  using iter_reference_t = decltype(*declval<T&>());
-
-namespace ranges::inline unspecified {
-    inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension
-}}
-
-template<dereferenceable T>
-  requires ...
-using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20
-
-// [iterator.concepts], iterator concepts
-// [iterator.concept.readable], concept indirectly_readable
-template<class In>
-  concept indirectly_readable = see below;                      // since C++20
-
-template<indirectly_readable T>
-  using iter_common_reference_t =
-    common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;  // since C++20
-
-// [iterator.concept.writable], concept indirectly_writable
-template<class Out, class T>
-  concept indirectly_writable = see below;                // since C++20
-
-// [iterator.concept.winc], concept weakly_incrementable
-template<class I>
-  concept weakly_incrementable = see below;                // since C++20
-
-// [iterator.concept.inc], concept incrementable
-template<class I>
-  concept incrementable = see below;                       // since C++20
-
-// [iterator.concept.iterator], concept input_or_output_iterator
-  template<class I>
-    concept input_or_output_iterator = see below;          // since C++20
-
-// [iterator.concept.sentinel], concept sentinel_for
-template<class S, class I>
-  concept sentinel_for = see below;                        // since C++20
-
-// [iterator.concept.sizedsentinel], concept sized_sentinel_for
-template<class S, class I>
-  inline constexpr bool disable_sized_sentinel_for = false;
-
-template<class S, class I>
-  concept sized_sentinel_for = see below;
-
-// [iterator.concept.input], concept input_iterator
-template<class I>
-  concept input_iterator = see below;                      // since C++20
-
-// [iterator.concept.output], concept output_iterator
-template<class I, class T>
-  concept output_iterator = see below;                     // since C++20
-
-// [iterator.concept.forward], concept forward_iterator
-template<class I>
-  concept forward_iterator = see below;                    // since C++20
-
-// [iterator.concept.bidir], concept bidirectional_iterator
-template<class I>
-  concept bidirectional_iterator = see below;              // since C++20
-
-// [iterator.concept.random.access], concept random_access_iterator
-template<class I>
-  concept random_access_iterator = see below;              // since C++20
-
-// [indirectcallable]
-// [indirectcallable.indirectinvocable]
-template<class F, class I>
-  concept indirectly_unary_invocable = see below;          // since C++20
-
-template<class F, class I>
-  concept indirectly_regular_unary_invocable = see below;  // since C++20
-
-template<class F, class I>
-  concept indirect_unary_predicate = see below;            // since C++20
-
-template<class F, class I1, class I2>
-  concept indirect_binary_predicate = see below;           // since C++20
-
-template<class F, class I1, class I2 = I1>
-  concept indirect_equivalence_relation = see below;       // since C++20
-
-template<class F, class I1, class I2 = I1>
-  concept indirect_strict_weak_order = see below;          // since C++20
-
-template<class F, class... Is>
-  using indirect_result_t = see below;                     // since C++20
-
-// [projected], projected
-template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
-  struct projected;                                        // since C++20
-
-template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj>
-  struct incrementable_traits<projected<I, Proj>>;         // since C++20
-
-// [alg.req.ind.move], concept indirectly_movable
-template<class In, class Out>
-  concept indirectly_movable = see below;                  // since C++20
-
-template<class In, class Out>
-  concept indirectly_movable_storable = see below;         // since C++20
-
-// [alg.req.ind.swap], concept indirectly_swappable
-template<class I1, class I2 = I1>
-  concept indirectly_swappable = see below;                // since C++20
-
-template<input_or_output_iterator I, sentinel_for<I> S>
-  requires (!same_as<I, S> && copyable<I>)
-class common_iterator;                                     // since C++20
-
-template<class Category, class T, class Distance = ptrdiff_t,
-         class Pointer = T*, class Reference = T&>
-struct iterator                                            // deprecated in C++17
-{
-    typedef T         value_type;
-    typedef Distance  difference_type;
-    typedef Pointer   pointer;
-    typedef Reference reference;
-    typedef Category  iterator_category;
-};
-
-struct input_iterator_tag  {};
-struct output_iterator_tag {};
-struct forward_iterator_tag       : public input_iterator_tag         {};
-struct bidirectional_iterator_tag : public forward_iterator_tag       {};
-struct random_access_iterator_tag : public bidirectional_iterator_tag {};
-
-// 27.4.3, iterator operations
-template <class InputIterator, class Distance>  // constexpr in C++17
-  constexpr void advance(InputIterator& i, Distance n);
-
-template <class InputIterator>  // constexpr in C++17
-  constexpr typename iterator_traits<InputIterator>::difference_type
-    distance(InputIterator first, InputIterator last);
-
-template <class InputIterator>  // constexpr in C++17
-  constexpr InputIterator next(InputIterator x,
-typename iterator_traits<InputIterator>::difference_type n = 1);
-
-template <class BidirectionalIterator>  // constexpr in C++17
-  constexpr BidirectionalIterator prev(BidirectionalIterator x,
-    typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
-
-// [range.iter.ops], range iterator operations
-namespace ranges {
-  // [range.iter.op.advance], ranges::advance
-  template<input_or_output_iterator I>
-    constexpr void advance(I& i, iter_difference_t<I> n);                          // since C++20
-  template<input_or_output_iterator I, sentinel_for<I> S>
-    constexpr void advance(I& i, S bound);                                         // since C++20
-  template<input_or_output_iterator I, sentinel_for<I> S>
-    constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20
-}
-
-template <class Iterator>
-class reverse_iterator
-    : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17
-                      typename iterator_traits<Iterator>::value_type,
-                      typename iterator_traits<Iterator>::difference_type,
-                      typename iterator_traits<Iterator>::pointer,
-                      typename iterator_traits<Iterator>::reference>
-{
-protected:
-    Iterator current;
-public:
-    typedef Iterator                                            iterator_type;
-    typedef typename iterator_traits<Iterator>::difference_type difference_type;
-    typedef typename iterator_traits<Iterator>::reference       reference;
-    typedef typename iterator_traits<Iterator>::pointer         pointer;
-
-    constexpr reverse_iterator();
-    constexpr explicit reverse_iterator(Iterator x);
-    template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
-    template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
-    constexpr Iterator base() const;
-    constexpr reference operator*() const;
-    constexpr pointer   operator->() const;
-    constexpr reverse_iterator& operator++();
-    constexpr reverse_iterator  operator++(int);
-    constexpr reverse_iterator& operator--();
-    constexpr reverse_iterator  operator--(int);
-    constexpr reverse_iterator  operator+ (difference_type n) const;
-    constexpr reverse_iterator& operator+=(difference_type n);
-    constexpr reverse_iterator  operator- (difference_type n) const;
-    constexpr reverse_iterator& operator-=(difference_type n);
-    constexpr reference         operator[](difference_type n) const;
-};
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr bool                          // constexpr in C++17
-operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
-constexpr auto
-operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
--> decltype(__y.base() - __x.base());   // constexpr in C++17
-
-template <class Iterator>
-constexpr reverse_iterator<Iterator>
-operator+(typename reverse_iterator<Iterator>::difference_type n,
-          const reverse_iterator<Iterator>& x);   // constexpr in C++17
-
-template <class Iterator>
-constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
-
-template <class Container>
-class back_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
-{
-protected:
-    Container* container;
-public:
-    typedef Container                   container_type;
-    typedef void                        value_type;
-    typedef void                        difference_type; // until C++20
-    typedef ptrdiff_t                   difference_type; // since C++20
-    typedef void                        reference;
-    typedef void                        pointer;
-
-    explicit back_insert_iterator(Container& x);  // constexpr in C++20
-    back_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
-    back_insert_iterator& operator*();  // constexpr in C++20
-    back_insert_iterator& operator++();  // constexpr in C++20
-    back_insert_iterator  operator++(int);  // constexpr in C++20
-};
-
-template <class Container> back_insert_iterator<Container> back_inserter(Container& x);  // constexpr in C++20
-
-template <class Container>
-class front_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
-{
-protected:
-    Container* container;
-public:
-    typedef Container                    container_type;
-    typedef void                         value_type;
-    typedef void                         difference_type; // until C++20
-    typedef ptrdiff_t                    difference_type; // since C++20
-    typedef void                         reference;
-    typedef void                         pointer;
-
-    explicit front_insert_iterator(Container& x);  // constexpr in C++20
-    front_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
-    front_insert_iterator& operator*();  // constexpr in C++20
-    front_insert_iterator& operator++();  // constexpr in C++20
-    front_insert_iterator  operator++(int);  // constexpr in C++20
-};
-
-template <class Container> front_insert_iterator<Container> front_inserter(Container& x);  // constexpr in C++20
-
-template <class Container>
-class insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
-{
-protected:
-    Container* container;
-    typename Container::iterator iter;
-public:
-    typedef Container              container_type;
-    typedef void                   value_type;
-    typedef void                   difference_type; // until C++20
-    typedef ptrdiff_t              difference_type; // since C++20
-    typedef void                   reference;
-    typedef void                   pointer;
-
-    insert_iterator(Container& x, typename Container::iterator i);  // constexpr in C++20
-    insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
-    insert_iterator& operator*();  // constexpr in C++20
-    insert_iterator& operator++();  // constexpr in C++20
-    insert_iterator& operator++(int);  // constexpr in C++20
-};
-
-template <class Container, class Iterator>
-insert_iterator<Container> inserter(Container& x, Iterator i);  // constexpr in C++20
-
-template <class Iterator>
-class move_iterator {
-public:
-    typedef Iterator                                              iterator_type;
-    typedef typename iterator_traits<Iterator>::difference_type   difference_type;
-    typedef Iterator                                              pointer;
-    typedef typename iterator_traits<Iterator>::value_type        value_type;
-    typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
-    typedef value_type&&                                          reference;
-
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPP_ITERATOR 
+#define _LIBCPP_ITERATOR 
+ 
+/* 
+    iterator synopsis 
+ 
+#include <concepts> 
+ 
+namespace std 
+{ 
+template<class> struct incrementable_traits;       // since C++20 
+template<class T> 
+  using iter_difference_t = see below;             // since C++20 
+ 
+template<class> struct indirectly_readable_traits; // since C++20 
+template<class T> 
+  using iter_value_t = see below;                  // since C++20 
+ 
+template<class Iterator> 
+struct iterator_traits; 
+ 
+template<class T> 
+  requires is_object_v<T>                    // since C++20 
+struct iterator_traits<T*>; 
+ 
+template<dereferenceable T> 
+  using iter_reference_t = decltype(*declval<T&>()); 
+ 
+namespace ranges::inline unspecified { 
+    inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension 
+}} 
+ 
+template<dereferenceable T> 
+  requires ... 
+using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20 
+ 
+// [iterator.concepts], iterator concepts 
+// [iterator.concept.readable], concept indirectly_readable 
+template<class In> 
+  concept indirectly_readable = see below;                      // since C++20 
+ 
+template<indirectly_readable T> 
+  using iter_common_reference_t = 
+    common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;  // since C++20 
+ 
+// [iterator.concept.writable], concept indirectly_writable 
+template<class Out, class T> 
+  concept indirectly_writable = see below;                // since C++20 
+ 
+// [iterator.concept.winc], concept weakly_incrementable 
+template<class I> 
+  concept weakly_incrementable = see below;                // since C++20 
+ 
+// [iterator.concept.inc], concept incrementable 
+template<class I> 
+  concept incrementable = see below;                       // since C++20 
+ 
+// [iterator.concept.iterator], concept input_or_output_iterator 
+  template<class I> 
+    concept input_or_output_iterator = see below;          // since C++20 
+ 
+// [iterator.concept.sentinel], concept sentinel_for 
+template<class S, class I> 
+  concept sentinel_for = see below;                        // since C++20 
+ 
+// [iterator.concept.sizedsentinel], concept sized_sentinel_for 
+template<class S, class I> 
+  inline constexpr bool disable_sized_sentinel_for = false; 
+ 
+template<class S, class I> 
+  concept sized_sentinel_for = see below; 
+ 
+// [iterator.concept.input], concept input_iterator 
+template<class I> 
+  concept input_iterator = see below;                      // since C++20 
+ 
+// [iterator.concept.output], concept output_iterator 
+template<class I, class T> 
+  concept output_iterator = see below;                     // since C++20 
+ 
+// [iterator.concept.forward], concept forward_iterator 
+template<class I> 
+  concept forward_iterator = see below;                    // since C++20 
+ 
+// [iterator.concept.bidir], concept bidirectional_iterator 
+template<class I> 
+  concept bidirectional_iterator = see below;              // since C++20 
+ 
+// [iterator.concept.random.access], concept random_access_iterator 
+template<class I> 
+  concept random_access_iterator = see below;              // since C++20 
+ 
+// [indirectcallable] 
+// [indirectcallable.indirectinvocable] 
+template<class F, class I> 
+  concept indirectly_unary_invocable = see below;          // since C++20 
+ 
+template<class F, class I> 
+  concept indirectly_regular_unary_invocable = see below;  // since C++20 
+ 
+template<class F, class I> 
+  concept indirect_unary_predicate = see below;            // since C++20 
+ 
+template<class F, class I1, class I2> 
+  concept indirect_binary_predicate = see below;           // since C++20 
+ 
+template<class F, class I1, class I2 = I1> 
+  concept indirect_equivalence_relation = see below;       // since C++20 
+ 
+template<class F, class I1, class I2 = I1> 
+  concept indirect_strict_weak_order = see below;          // since C++20 
+ 
+template<class F, class... Is> 
+  using indirect_result_t = see below;                     // since C++20 
+ 
+// [projected], projected 
+template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj> 
+  struct projected;                                        // since C++20 
+ 
+template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj> 
+  struct incrementable_traits<projected<I, Proj>>;         // since C++20 
+ 
+// [alg.req.ind.move], concept indirectly_movable 
+template<class In, class Out> 
+  concept indirectly_movable = see below;                  // since C++20 
+ 
+template<class In, class Out> 
+  concept indirectly_movable_storable = see below;         // since C++20 
+ 
+// [alg.req.ind.swap], concept indirectly_swappable 
+template<class I1, class I2 = I1> 
+  concept indirectly_swappable = see below;                // since C++20 
+ 
+template<input_or_output_iterator I, sentinel_for<I> S> 
+  requires (!same_as<I, S> && copyable<I>) 
+class common_iterator;                                     // since C++20 
+ 
+template<class Category, class T, class Distance = ptrdiff_t, 
+         class Pointer = T*, class Reference = T&> 
+struct iterator                                            // deprecated in C++17 
+{ 
+    typedef T         value_type; 
+    typedef Distance  difference_type; 
+    typedef Pointer   pointer; 
+    typedef Reference reference; 
+    typedef Category  iterator_category; 
+}; 
+ 
+struct input_iterator_tag  {}; 
+struct output_iterator_tag {}; 
+struct forward_iterator_tag       : public input_iterator_tag         {}; 
+struct bidirectional_iterator_tag : public forward_iterator_tag       {}; 
+struct random_access_iterator_tag : public bidirectional_iterator_tag {}; 
+ 
+// 27.4.3, iterator operations 
+template <class InputIterator, class Distance>  // constexpr in C++17 
+  constexpr void advance(InputIterator& i, Distance n); 
+ 
+template <class InputIterator>  // constexpr in C++17 
+  constexpr typename iterator_traits<InputIterator>::difference_type 
+    distance(InputIterator first, InputIterator last); 
+ 
+template <class InputIterator>  // constexpr in C++17 
+  constexpr InputIterator next(InputIterator x, 
+typename iterator_traits<InputIterator>::difference_type n = 1); 
+ 
+template <class BidirectionalIterator>  // constexpr in C++17 
+  constexpr BidirectionalIterator prev(BidirectionalIterator x, 
+    typename iterator_traits<BidirectionalIterator>::difference_type n = 1); 
+ 
+// [range.iter.ops], range iterator operations 
+namespace ranges { 
+  // [range.iter.op.advance], ranges::advance 
+  template<input_or_output_iterator I> 
+    constexpr void advance(I& i, iter_difference_t<I> n);                          // since C++20 
+  template<input_or_output_iterator I, sentinel_for<I> S> 
+    constexpr void advance(I& i, S bound);                                         // since C++20 
+  template<input_or_output_iterator I, sentinel_for<I> S> 
+    constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20 
+} 
+ 
+template <class Iterator> 
+class reverse_iterator 
+    : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17 
+                      typename iterator_traits<Iterator>::value_type, 
+                      typename iterator_traits<Iterator>::difference_type, 
+                      typename iterator_traits<Iterator>::pointer, 
+                      typename iterator_traits<Iterator>::reference> 
+{ 
+protected: 
+    Iterator current; 
+public: 
+    typedef Iterator                                            iterator_type; 
+    typedef typename iterator_traits<Iterator>::difference_type difference_type; 
+    typedef typename iterator_traits<Iterator>::reference       reference; 
+    typedef typename iterator_traits<Iterator>::pointer         pointer; 
+ 
+    constexpr reverse_iterator(); 
+    constexpr explicit reverse_iterator(Iterator x); 
+    template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u); 
+    template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u); 
+    constexpr Iterator base() const; 
+    constexpr reference operator*() const; 
+    constexpr pointer   operator->() const; 
+    constexpr reverse_iterator& operator++(); 
+    constexpr reverse_iterator  operator++(int); 
+    constexpr reverse_iterator& operator--(); 
+    constexpr reverse_iterator  operator--(int); 
+    constexpr reverse_iterator  operator+ (difference_type n) const; 
+    constexpr reverse_iterator& operator+=(difference_type n); 
+    constexpr reverse_iterator  operator- (difference_type n) const; 
+    constexpr reverse_iterator& operator-=(difference_type n); 
+    constexpr reference         operator[](difference_type n) const; 
+}; 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr bool                          // constexpr in C++17 
+operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
+constexpr auto 
+operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y) 
+-> decltype(__y.base() - __x.base());   // constexpr in C++17 
+ 
+template <class Iterator> 
+constexpr reverse_iterator<Iterator> 
+operator+(typename reverse_iterator<Iterator>::difference_type n, 
+          const reverse_iterator<Iterator>& x);   // constexpr in C++17 
+ 
+template <class Iterator> 
+constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 
+ 
+template <class Container> 
+class back_insert_iterator 
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17 
+{ 
+protected: 
+    Container* container; 
+public: 
+    typedef Container                   container_type; 
+    typedef void                        value_type; 
+    typedef void                        difference_type; // until C++20 
+    typedef ptrdiff_t                   difference_type; // since C++20 
+    typedef void                        reference; 
+    typedef void                        pointer; 
+ 
+    explicit back_insert_iterator(Container& x);  // constexpr in C++20 
+    back_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20 
+    back_insert_iterator& operator*();  // constexpr in C++20 
+    back_insert_iterator& operator++();  // constexpr in C++20 
+    back_insert_iterator  operator++(int);  // constexpr in C++20 
+}; 
+ 
+template <class Container> back_insert_iterator<Container> back_inserter(Container& x);  // constexpr in C++20 
+ 
+template <class Container> 
+class front_insert_iterator 
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17 
+{ 
+protected: 
+    Container* container; 
+public: 
+    typedef Container                    container_type; 
+    typedef void                         value_type; 
+    typedef void                         difference_type; // until C++20 
+    typedef ptrdiff_t                    difference_type; // since C++20 
+    typedef void                         reference; 
+    typedef void                         pointer; 
+ 
+    explicit front_insert_iterator(Container& x);  // constexpr in C++20 
+    front_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20 
+    front_insert_iterator& operator*();  // constexpr in C++20 
+    front_insert_iterator& operator++();  // constexpr in C++20 
+    front_insert_iterator  operator++(int);  // constexpr in C++20 
+}; 
+ 
+template <class Container> front_insert_iterator<Container> front_inserter(Container& x);  // constexpr in C++20 
+ 
+template <class Container> 
+class insert_iterator 
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17 
+{ 
+protected: 
+    Container* container; 
+    typename Container::iterator iter; 
+public: 
+    typedef Container              container_type; 
+    typedef void                   value_type; 
+    typedef void                   difference_type; // until C++20 
+    typedef ptrdiff_t              difference_type; // since C++20 
+    typedef void                   reference; 
+    typedef void                   pointer; 
+ 
+    insert_iterator(Container& x, typename Container::iterator i);  // constexpr in C++20 
+    insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20 
+    insert_iterator& operator*();  // constexpr in C++20 
+    insert_iterator& operator++();  // constexpr in C++20 
+    insert_iterator& operator++(int);  // constexpr in C++20 
+}; 
+ 
+template <class Container, class Iterator> 
+insert_iterator<Container> inserter(Container& x, Iterator i);  // constexpr in C++20 
+ 
+template <class Iterator> 
+class move_iterator { 
+public: 
+    typedef Iterator                                              iterator_type; 
+    typedef typename iterator_traits<Iterator>::difference_type   difference_type; 
+    typedef Iterator                                              pointer; 
+    typedef typename iterator_traits<Iterator>::value_type        value_type; 
+    typedef typename iterator_traits<Iterator>::iterator_category iterator_category; 
+    typedef value_type&&                                          reference; 
+ 
     constexpr move_iterator();  // all the constexprs are in C++17
     constexpr explicit move_iterator(Iterator i);
     template <class U>
@@ -353,277 +353,277 @@ public:
     constexpr move_iterator operator++(int);
     constexpr move_iterator& operator--();
     constexpr move_iterator operator--(int);
-    constexpr move_iterator operator+(difference_type n) const;
-    constexpr move_iterator& operator+=(difference_type n);
-    constexpr move_iterator operator-(difference_type n) const;
-    constexpr move_iterator& operator-=(difference_type n);
+    constexpr move_iterator operator+(difference_type n) const; 
+    constexpr move_iterator& operator+=(difference_type n); 
+    constexpr move_iterator operator-(difference_type n) const; 
+    constexpr move_iterator& operator-=(difference_type n); 
     constexpr unspecified operator[](difference_type n) const;
-private:
-    Iterator current; // exposition only
-};
-
-template <class Iterator1, class Iterator2>
+private: 
+    Iterator current; // exposition only 
+}; 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr bool   // constexpr in C++17
-operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-
-template <class Iterator1, class Iterator2>
+operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 
+ 
+template <class Iterator1, class Iterator2> 
 constexpr auto   // constexpr in C++17
-operator-(const move_iterator<Iterator1>& x,
-          const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
-
-template <class Iterator>
+operator-(const move_iterator<Iterator1>& x, 
+          const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 
+ 
+template <class Iterator> 
 constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
-            typename move_iterator<Iterator>::difference_type n,
+            typename move_iterator<Iterator>::difference_type n, 
             const move_iterator<Iterator>& x);
-
+ 
 template <class Iterator>   // constexpr in C++17
 constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
-
-// [default.sentinel], default sentinel
-struct default_sentinel_t;
-inline constexpr default_sentinel_t default_sentinel{};
-
-// [iterators.counted], counted iterators
-template<input_or_output_iterator I> class counted_iterator;
-
-template<input_iterator I>
-  requires see below
-  struct iterator_traits<counted_iterator<I>>;
-
-// [unreachable.sentinel], unreachable sentinel
-struct unreachable_sentinel_t;
-inline constexpr unreachable_sentinel_t unreachable_sentinel{};
-
-template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
-class istream_iterator
-    : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
-{
-public:
-    typedef input_iterator_tag           iterator_category;
-    typedef T                            value_type;
-    typedef Distance                     difference_type;
-    typedef const T*                     pointer;
-    typedef const T&                     reference;
-
-    typedef charT                        char_type;
-    typedef traits                       traits_type;
-    typedef basic_istream<charT, traits> istream_type;
-
-    constexpr istream_iterator();
-    istream_iterator(istream_type& s);
-    istream_iterator(const istream_iterator& x);
-    ~istream_iterator();
-
-    const T& operator*() const;
-    const T* operator->() const;
-    istream_iterator& operator++();
-    istream_iterator  operator++(int);
-};
-
-template <class T, class charT, class traits, class Distance>
-bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
-                const istream_iterator<T,charT,traits,Distance>& y);
-template <class T, class charT, class traits, class Distance>
-bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
-                const istream_iterator<T,charT,traits,Distance>& y);
-
-template <class T, class charT = char, class traits = char_traits<charT> >
-class ostream_iterator
-    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
-{
-public:
-    typedef output_iterator_tag         iterator_category;
-    typedef void                        value_type;
-    typedef void                        difference_type; // until C++20
-    typedef ptrdiff_t                   difference_type; // since C++20
-    typedef void                        pointer;
-    typedef void                        reference;
-
-    typedef charT char_type;
-    typedef traits traits_type;
-    typedef basic_ostream<charT,traits> ostream_type;
-
-    ostream_iterator(ostream_type& s);
-    ostream_iterator(ostream_type& s, const charT* delimiter);
-    ostream_iterator(const ostream_iterator& x);
-    ~ostream_iterator();
-    ostream_iterator& operator=(const T& value);
-
-    ostream_iterator& operator*();
-    ostream_iterator& operator++();
-    ostream_iterator& operator++(int);
-};
-
-template<class charT, class traits = char_traits<charT> >
-class istreambuf_iterator
-    : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
-{
-public:
-    typedef input_iterator_tag              iterator_category;
-    typedef charT                           value_type;
-    typedef traits::off_type                difference_type;
-    typedef unspecified                     pointer;
-    typedef charT                           reference;
-
-    typedef charT                           char_type;
-    typedef traits                          traits_type;
-    typedef traits::int_type                int_type;
-    typedef basic_streambuf<charT, traits>  streambuf_type;
-    typedef basic_istream<charT, traits>    istream_type;
-
-    istreambuf_iterator() noexcept;
-    istreambuf_iterator(istream_type& s) noexcept;
-    istreambuf_iterator(streambuf_type* s) noexcept;
-    istreambuf_iterator(a-private-type) noexcept;
-
-    charT                operator*() const;
-    pointer operator->() const;
-    istreambuf_iterator& operator++();
-    a-private-type       operator++(int);
-
-    bool equal(const istreambuf_iterator& b) const;
-};
-
-template <class charT, class traits>
-bool operator==(const istreambuf_iterator<charT,traits>& a,
-                const istreambuf_iterator<charT,traits>& b);
-template <class charT, class traits>
-bool operator!=(const istreambuf_iterator<charT,traits>& a,
-                const istreambuf_iterator<charT,traits>& b);
-
-template <class charT, class traits = char_traits<charT> >
-class ostreambuf_iterator
-    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
-{
-public:
-    typedef output_iterator_tag            iterator_category;
-    typedef void                           value_type;
-    typedef void                           difference_type; // until C++20
-    typedef ptrdiff_t                      difference_type; // since C++20
-    typedef void                           pointer;
-    typedef void                           reference;
-
-    typedef charT                          char_type;
-    typedef traits                         traits_type;
-    typedef basic_streambuf<charT, traits> streambuf_type;
-    typedef basic_ostream<charT, traits>   ostream_type;
-
-    ostreambuf_iterator(ostream_type& s) noexcept;
-    ostreambuf_iterator(streambuf_type* s) noexcept;
-    ostreambuf_iterator& operator=(charT c);
-    ostreambuf_iterator& operator*();
-    ostreambuf_iterator& operator++();
-    ostreambuf_iterator& operator++(int);
-    bool failed() const noexcept;
-};
-
-template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
-template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
-template <class C> constexpr auto end(C& c) -> decltype(c.end());
-template <class C> constexpr auto end(const C& c) -> decltype(c.end());
-template <class T, size_t N> constexpr T* begin(T (&array)[N]);
-template <class T, size_t N> constexpr T* end(T (&array)[N]);
-
-template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c));        // C++14
-template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c));            // C++14
-template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin());                 // C++14
-template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin());           // C++14
-template <class C> auto constexpr rend(C& c) -> decltype(c.rend());                     // C++14
-template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());               // C++14
-template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14
-template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il);   // C++14
-template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]);      // C++14
-template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]);        // C++14
-template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));      // C++14
-template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));          // C++14
-
-// 24.8, container access:
-template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17
-template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
-
-template <class C> constexpr auto ssize(const C& c)
-    -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;                    // C++20
-template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
-
-template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());       // C++17
-template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;  // C++17
-template <class E> constexpr bool empty(initializer_list<E> il) noexcept;         // C++17
-template <class C> constexpr auto data(C& c) -> decltype(c.data());               // C++17
-template <class C> constexpr auto data(const C& c) -> decltype(c.data());         // C++17
-template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17
-template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
-
-}  // std
-
-*/
-
-#include <__config>
-#include <__debug>
-#include <__functional_base>
-#include <__iterator/access.h>
-#include <__iterator/advance.h>
-#include <__iterator/back_insert_iterator.h>
-#include <__iterator/common_iterator.h>
-#include <__iterator/concepts.h>
-#include <__iterator/counted_iterator.h>
-#include <__iterator/data.h>
-#include <__iterator/default_sentinel.h>
-#include <__iterator/distance.h>
-#include <__iterator/empty.h>
-#include <__iterator/erase_if_container.h>
-#include <__iterator/front_insert_iterator.h>
-#include <__iterator/incrementable_traits.h>
-#include <__iterator/insert_iterator.h>
-#include <__iterator/istreambuf_iterator.h>
-#include <__iterator/istream_iterator.h>
-#include <__iterator/iterator.h>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/iter_move.h>
-#include <__iterator/iter_swap.h>
-#include <__iterator/move_iterator.h>
-#include <__iterator/next.h>
-#include <__iterator/ostreambuf_iterator.h>
-#include <__iterator/ostream_iterator.h>
-#include <__iterator/prev.h>
-#include <__iterator/projected.h>
-#include <__iterator/readable_traits.h>
-#include <__iterator/reverse_access.h>
-#include <__iterator/reverse_iterator.h>
-#include <__iterator/size.h>
-#include <__iterator/unreachable_sentinel.h>
-#include <__iterator/wrap_iter.h>
-#include <__memory/addressof.h>
-#include <__memory/pointer_traits.h>
-#include <__utility/forward.h>
-#include <compare>
-#include <concepts> // Mandated by the Standard.
-#include <cstddef>
-#include <initializer_list>
-#include <type_traits>
+ 
+// [default.sentinel], default sentinel 
+struct default_sentinel_t; 
+inline constexpr default_sentinel_t default_sentinel{}; 
+ 
+// [iterators.counted], counted iterators 
+template<input_or_output_iterator I> class counted_iterator; 
+ 
+template<input_iterator I> 
+  requires see below 
+  struct iterator_traits<counted_iterator<I>>; 
+ 
+// [unreachable.sentinel], unreachable sentinel 
+struct unreachable_sentinel_t; 
+inline constexpr unreachable_sentinel_t unreachable_sentinel{}; 
+ 
+template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 
+class istream_iterator 
+    : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 
+{ 
+public: 
+    typedef input_iterator_tag           iterator_category; 
+    typedef T                            value_type; 
+    typedef Distance                     difference_type; 
+    typedef const T*                     pointer; 
+    typedef const T&                     reference; 
+ 
+    typedef charT                        char_type; 
+    typedef traits                       traits_type; 
+    typedef basic_istream<charT, traits> istream_type; 
+ 
+    constexpr istream_iterator(); 
+    istream_iterator(istream_type& s); 
+    istream_iterator(const istream_iterator& x); 
+    ~istream_iterator(); 
+ 
+    const T& operator*() const; 
+    const T* operator->() const; 
+    istream_iterator& operator++(); 
+    istream_iterator  operator++(int); 
+}; 
+ 
+template <class T, class charT, class traits, class Distance> 
+bool operator==(const istream_iterator<T,charT,traits,Distance>& x, 
+                const istream_iterator<T,charT,traits,Distance>& y); 
+template <class T, class charT, class traits, class Distance> 
+bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 
+                const istream_iterator<T,charT,traits,Distance>& y); 
+ 
+template <class T, class charT = char, class traits = char_traits<charT> > 
+class ostream_iterator 
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17 
+{ 
+public: 
+    typedef output_iterator_tag         iterator_category; 
+    typedef void                        value_type; 
+    typedef void                        difference_type; // until C++20 
+    typedef ptrdiff_t                   difference_type; // since C++20 
+    typedef void                        pointer; 
+    typedef void                        reference; 
+ 
+    typedef charT char_type; 
+    typedef traits traits_type; 
+    typedef basic_ostream<charT,traits> ostream_type; 
+ 
+    ostream_iterator(ostream_type& s); 
+    ostream_iterator(ostream_type& s, const charT* delimiter); 
+    ostream_iterator(const ostream_iterator& x); 
+    ~ostream_iterator(); 
+    ostream_iterator& operator=(const T& value); 
+ 
+    ostream_iterator& operator*(); 
+    ostream_iterator& operator++(); 
+    ostream_iterator& operator++(int); 
+}; 
+ 
+template<class charT, class traits = char_traits<charT> > 
+class istreambuf_iterator 
+    : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17 
+{ 
+public: 
+    typedef input_iterator_tag              iterator_category; 
+    typedef charT                           value_type; 
+    typedef traits::off_type                difference_type; 
+    typedef unspecified                     pointer; 
+    typedef charT                           reference; 
+ 
+    typedef charT                           char_type; 
+    typedef traits                          traits_type; 
+    typedef traits::int_type                int_type; 
+    typedef basic_streambuf<charT, traits>  streambuf_type; 
+    typedef basic_istream<charT, traits>    istream_type; 
+ 
+    istreambuf_iterator() noexcept; 
+    istreambuf_iterator(istream_type& s) noexcept; 
+    istreambuf_iterator(streambuf_type* s) noexcept; 
+    istreambuf_iterator(a-private-type) noexcept; 
+ 
+    charT                operator*() const; 
+    pointer operator->() const; 
+    istreambuf_iterator& operator++(); 
+    a-private-type       operator++(int); 
+ 
+    bool equal(const istreambuf_iterator& b) const; 
+}; 
+ 
+template <class charT, class traits> 
+bool operator==(const istreambuf_iterator<charT,traits>& a, 
+                const istreambuf_iterator<charT,traits>& b); 
+template <class charT, class traits> 
+bool operator!=(const istreambuf_iterator<charT,traits>& a, 
+                const istreambuf_iterator<charT,traits>& b); 
+ 
+template <class charT, class traits = char_traits<charT> > 
+class ostreambuf_iterator 
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17 
+{ 
+public: 
+    typedef output_iterator_tag            iterator_category; 
+    typedef void                           value_type; 
+    typedef void                           difference_type; // until C++20 
+    typedef ptrdiff_t                      difference_type; // since C++20 
+    typedef void                           pointer; 
+    typedef void                           reference; 
+ 
+    typedef charT                          char_type; 
+    typedef traits                         traits_type; 
+    typedef basic_streambuf<charT, traits> streambuf_type; 
+    typedef basic_ostream<charT, traits>   ostream_type; 
+ 
+    ostreambuf_iterator(ostream_type& s) noexcept; 
+    ostreambuf_iterator(streambuf_type* s) noexcept; 
+    ostreambuf_iterator& operator=(charT c); 
+    ostreambuf_iterator& operator*(); 
+    ostreambuf_iterator& operator++(); 
+    ostreambuf_iterator& operator++(int); 
+    bool failed() const noexcept; 
+}; 
+ 
+template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 
+template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 
+template <class C> constexpr auto end(C& c) -> decltype(c.end()); 
+template <class C> constexpr auto end(const C& c) -> decltype(c.end()); 
+template <class T, size_t N> constexpr T* begin(T (&array)[N]); 
+template <class T, size_t N> constexpr T* end(T (&array)[N]); 
+ 
+template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c));        // C++14 
+template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c));            // C++14 
+template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin());                 // C++14 
+template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin());           // C++14 
+template <class C> auto constexpr rend(C& c) -> decltype(c.rend());                     // C++14 
+template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());               // C++14 
+template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 
+template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il);   // C++14 
+template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]);      // C++14 
+template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]);        // C++14 
+template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));      // C++14 
+template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));          // C++14 
+ 
+// 24.8, container access: 
+template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17 
+template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 
+ 
+template <class C> constexpr auto ssize(const C& c) 
+    -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;                    // C++20 
+template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 
+ 
+template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());       // C++17 
+template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;  // C++17 
+template <class E> constexpr bool empty(initializer_list<E> il) noexcept;         // C++17 
+template <class C> constexpr auto data(C& c) -> decltype(c.data());               // C++17 
+template <class C> constexpr auto data(const C& c) -> decltype(c.data());         // C++17 
+template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17 
+template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17 
+ 
+}  // std 
+ 
+*/ 
+
+#include <__config> 
+#include <__debug> 
+#include <__functional_base> 
+#include <__iterator/access.h> 
+#include <__iterator/advance.h> 
+#include <__iterator/back_insert_iterator.h> 
+#include <__iterator/common_iterator.h> 
+#include <__iterator/concepts.h> 
+#include <__iterator/counted_iterator.h> 
+#include <__iterator/data.h> 
+#include <__iterator/default_sentinel.h> 
+#include <__iterator/distance.h> 
+#include <__iterator/empty.h> 
+#include <__iterator/erase_if_container.h> 
+#include <__iterator/front_insert_iterator.h> 
+#include <__iterator/incrementable_traits.h> 
+#include <__iterator/insert_iterator.h> 
+#include <__iterator/istreambuf_iterator.h> 
+#include <__iterator/istream_iterator.h> 
+#include <__iterator/iterator.h> 
+#include <__iterator/iterator_traits.h> 
+#include <__iterator/iter_move.h> 
+#include <__iterator/iter_swap.h> 
+#include <__iterator/move_iterator.h> 
+#include <__iterator/next.h> 
+#include <__iterator/ostreambuf_iterator.h> 
+#include <__iterator/ostream_iterator.h> 
+#include <__iterator/prev.h> 
+#include <__iterator/projected.h> 
+#include <__iterator/readable_traits.h> 
+#include <__iterator/reverse_access.h> 
+#include <__iterator/reverse_iterator.h> 
+#include <__iterator/size.h> 
+#include <__iterator/unreachable_sentinel.h> 
+#include <__iterator/wrap_iter.h> 
+#include <__memory/addressof.h> 
+#include <__memory/pointer_traits.h> 
+#include <__utility/forward.h> 
+#include <compare> 
+#include <concepts> // Mandated by the Standard. 
+#include <cstddef> 
+#include <initializer_list> 
+#include <type_traits> 
 #include <version>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-#endif // _LIBCPP_ITERATOR
+ 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
+#pragma GCC system_header 
+#endif 
+ 
+#endif // _LIBCPP_ITERATOR