diff --git a/libcxx/include/__iterator/move_iterator.h b/libcxx/include/__iterator/move_iterator.h
--- a/libcxx/include/__iterator/move_iterator.h
+++ b/libcxx/include/__iterator/move_iterator.h
@@ -16,7 +16,6 @@
 #include <__concepts/convertible_to.h>
 #include <__concepts/derived_from.h>
 #include <__concepts/same_as.h>
-#include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
@@ -33,31 +32,35 @@
 #include <__utility/declval.h>
 #include <__utility/move.h>
 
+#include <__config>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
-template<class _Iter, class = void>
+template <class _Iter, class = void>
 struct __move_iter_category_base {};
 
-template<class _Iter>
-  requires requires { typename iterator_traits<_Iter>::iterator_category; }
+template <class _Iter>
+requires requires { typename iterator_traits<_Iter>::iterator_category; }
 struct __move_iter_category_base<_Iter> {
-    using iterator_category = _If<
-        derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
-        random_access_iterator_tag,
-        typename iterator_traits<_Iter>::iterator_category
-    >;
+  using iterator_category =
+      _If<derived_from<typename iterator_traits<_Iter>::iterator_category,
+                       random_access_iterator_tag>,
+          random_access_iterator_tag,
+          typename iterator_traits<_Iter>::iterator_category>;
 };
 
-template<class _Iter, class _Sent>
+template <class _Iter, class _Sent>
 concept __move_iter_comparable = requires {
-    { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
+  {
+    std::declval<const _Iter&>() == std::declval<_Sent>()
+    } -> convertible_to<bool>;
 };
-#endif // _LIBCPP_STD_VER > 17
+#endif  // _LIBCPP_STD_VER > 17
 
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS move_iterator
@@ -65,269 +68,304 @@
     : public __move_iter_category_base<_Iter>
 #endif
 {
-public:
 #if _LIBCPP_STD_VER > 17
-    using iterator_type = _Iter;
-    using iterator_concept = input_iterator_tag;
-    // iterator_category is inherited and not always present
-    using value_type = iter_value_t<_Iter>;
-    using difference_type = iter_difference_t<_Iter>;
-    using pointer = _Iter;
-    using reference = iter_rvalue_reference_t<_Iter>;
-#else
-    typedef _Iter iterator_type;
-    typedef _If<
-        __is_cpp17_random_access_iterator<_Iter>::value,
-        random_access_iterator_tag,
-        typename iterator_traits<_Iter>::iterator_category
-    > iterator_category;
-    typedef typename iterator_traits<iterator_type>::value_type value_type;
-    typedef typename iterator_traits<iterator_type>::difference_type difference_type;
-    typedef iterator_type pointer;
-
-    typedef typename iterator_traits<iterator_type>::reference __reference;
-    typedef typename conditional<
-            is_reference<__reference>::value,
-            __libcpp_remove_reference_t<__reference>&&,
-            __reference
-        >::type reference;
-#endif // _LIBCPP_STD_VER > 17
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator++() { ++__current_; return *this; }
-
-    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    pointer operator->() const { return __current_; }
-
-#if _LIBCPP_STD_VER > 17
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator() requires is_constructible_v<_Iter> : __current_() {}
-
-    template <class _Up>
-        requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
-
-    template <class _Up>
-        requires (!_IsSame<_Up, _Iter>::value) &&
-                 convertible_to<const _Up&, _Iter> &&
-                 assignable_from<_Iter&, const _Up&>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator& operator=(const move_iterator<_Up>& __u) {
-        __current_ = __u.base();
-        return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const & noexcept { return __current_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    reference operator*() const { return ranges::iter_move(__current_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    reference operator[](difference_type __n) const { return ranges::iter_move(__current_ + __n); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    auto operator++(int)
-        requires forward_iterator<_Iter>
-    {
-        move_iterator __tmp(*this); ++__current_; return __tmp;
+ public:
+  using iterator_type = _Iter;
+  // iterator_category is inherited and not always present
+  using value_type = iter_value_t<_Iter>;
+  using difference_type = iter_difference_t<_Iter>;
+  using pointer = _Iter;
+  using reference = iter_rvalue_reference_t<_Iter>;
+#if _LIBCPP_STD_VER > 20
+ private:
+  static consteval auto __get_iterator_concept() {
+    if constexpr (random_access_iterator<_Iter>) {
+      return random_access_iterator_tag{};
+    } else if constexpr (bidirectional_iterator<_Iter>) {
+      return bidirectional_iterator_tag{};
+    } else if constexpr (forward_iterator<_Iter>) {
+      return forward_iterator_tag{};
+    } else {
+      return input_iterator_tag{};
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    void operator++(int) { ++__current_; }
+ public:
+  using iterator_concept = decltype(__get_iterator_concept());
+#endif  //  _LIBCPP_STD_VER > 20
 #else
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator() : __current_() {}
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<const _Up&, _Iter>::value &&
-        is_assignable<_Iter&, const _Up&>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator=(const move_iterator<_Up>& __u) {
-        __current_ = __u.base();
-        return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    _Iter base() const { return __current_; }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator*() const { return static_cast<reference>(*__current_); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
-#endif // _LIBCPP_STD_VER > 17
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator--() { --__current_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; }
+ public:
+  typedef _Iter iterator_type;
+  typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
+              random_access_iterator_tag,
+              typename iterator_traits<_Iter>::iterator_category>
+      iterator_category;
+  typedef typename iterator_traits<iterator_type>::value_type value_type;
+  typedef
+      typename iterator_traits<iterator_type>::difference_type difference_type;
+  typedef iterator_type pointer;
+
+  typedef typename iterator_traits<iterator_type>::reference __reference;
+  typedef typename conditional<is_reference<__reference>::value,
+                               __libcpp_remove_reference_t<__reference>&&,
+                               __reference>::type reference;
+#endif  // _LIBCPP_STD_VER > 17
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit move_iterator(
+      _Iter __i)
+      : __current_(std::move(__i)) {}
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator&
+  operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI
+      _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer
+      operator->() const {
+    return __current_;
+  }
 
 #if _LIBCPP_STD_VER > 17
-    template<sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
-        requires __move_iter_comparable<_Iter, _Sent>
-    {
-        return __x.base() == __y.base();
-    }
-
-    template<sized_sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_difference_t<_Iter> operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
-    {
-        return __x.base() - __y.base();
-    }
-
-    template<sized_sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_difference_t<_Iter> operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
-    {
-        return __x.base() - __y.base();
-    }
-
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_rvalue_reference_t<_Iter> iter_move(const move_iterator& __i)
-        noexcept(noexcept(ranges::iter_move(__i.__current_)))
-    {
-        return ranges::iter_move(__i.__current_);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr move_iterator() requires
+      is_constructible_v<_Iter> : __current_() {}
+
+  template <class _Up>
+  requires(!_IsSame<_Up, _Iter>::value) &&
+      convertible_to<const _Up&, _Iter> _LIBCPP_HIDE_FROM_ABI
+      constexpr move_iterator(const move_iterator<_Up>& __u)
+      : __current_(__u.base()) {}
+
+  template <class _Up>
+  requires(!_IsSame<_Up, _Iter>::value) &&
+      convertible_to<const _Up&, _Iter>&& assignable_from<
+          _Iter&, const _Up&> _LIBCPP_HIDE_FROM_ABI constexpr move_iterator&
+      operator=(const move_iterator<_Up>& __u) {
+    __current_ = __u.base();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const& noexcept {
+    return __current_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && {
+    return std::move(__current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const {
+    return ranges::iter_move(__current_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](
+      difference_type __n) const {
+    return ranges::iter_move(__current_ + __n);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator++(int) requires
+      forward_iterator<_Iter> {
+    move_iterator __tmp(*this);
+    ++__current_;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
+#else
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator()
+      : __current_() {}
+
+  template <class _Up,
+            class = __enable_if_t<!is_same<_Up, _Iter>::value &&
+                                  is_convertible<const _Up&, _Iter>::value> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+  move_iterator(const move_iterator<_Up>& __u)
+      : __current_(__u.base()) {}
+
+  template <class _Up,
+            class = __enable_if_t<!is_same<_Up, _Iter>::value &&
+                                  is_convertible<const _Up&, _Iter>::value &&
+                                  is_assignable<_Iter&, const _Up&>::value> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator=(
+      const move_iterator<_Up>& __u) {
+    __current_ = __u.base();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const {
+    return __current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference
+  operator*() const {
+    return static_cast<reference>(*__current_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference
+  operator[](difference_type __n) const {
+    return static_cast<reference>(__current_[__n]);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator
+  operator++(int) {
+    move_iterator __tmp(*this);
+    ++__current_;
+    return __tmp;
+  }
+#endif  // _LIBCPP_STD_VER > 17
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator&
+  operator--() {
+    --__current_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator
+  operator--(int) {
+    move_iterator __tmp(*this);
+    --__current_;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator
+  operator+(difference_type __n) const {
+    return move_iterator(__current_ + __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator+=(
+      difference_type __n) {
+    __current_ += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator
+  operator-(difference_type __n) const {
+    return move_iterator(__current_ - __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator-=(
+      difference_type __n) {
+    __current_ -= __n;
+    return *this;
+  }
 
-    template<indirectly_swappable<_Iter> _It2>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    void iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y)
-        noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
-    {
-        return ranges::iter_swap(__x.__current_, __y.__current_);
-    }
-#endif // _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17
+  template <sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(
+      const move_iterator& __x, const move_sentinel<_Sent>& __y) requires
+      __move_iter_comparable<_Iter, _Sent> {
+    return __x.base() == __y.base();
+  }
 
-private:
-    template<class _It2> friend class move_iterator;
+  template <sized_sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter> operator-(
+      const move_sentinel<_Sent>& __x, const move_iterator& __y) {
+    return __x.base() - __y.base();
+  }
 
-    _Iter __current_;
+  template <sized_sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter> operator-(
+      const move_iterator& __x, const move_sentinel<_Sent>& __y) {
+    return __x.base() - __y.base();
+  }
+
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_rvalue_reference_t<_Iter>
+  iter_move(const move_iterator& __i) noexcept(
+      noexcept(ranges::iter_move(__i.__current_))) {
+    return ranges::iter_move(__i.__current_);
+  }
+
+  template <indirectly_swappable<_Iter> _It2>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr void
+  iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y) noexcept(
+      noexcept(ranges::iter_swap(__x.__current_, __y.__current_))) {
+    return ranges::iter_swap(__x.__current_, __y.__current_);
+  }
+#endif  // _LIBCPP_STD_VER > 17
+ private:
+  template <class _It2>
+  friend class move_iterator;
+
+  _Iter __current_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() == __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator==(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() == __y.base();
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() != __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator!=(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() != __y.base();
 }
-#endif // _LIBCPP_STD_VER <= 17
+#endif  // _LIBCPP_STD_VER <= 17
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() < __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator<(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() > __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator>(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() > __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() <= __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator<=(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() <= __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() >= __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator>=(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() >= __y.base();
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr
-auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-    -> compare_three_way_result_t<_Iter1, _Iter2>
-{
-    return __x.base() <=> __y.base();
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
+    -> compare_three_way_result_t<_Iter1, _Iter2> {
+  return __x.base() <=> __y.base();
 }
-#endif // _LIBCPP_STD_VER > 17
+#endif  // _LIBCPP_STD_VER > 17
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-    -> decltype(__x.base() - __y.base())
-{
-    return __x.base() - __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto operator-(
+    const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
+    -> decltype(__x.base() - __y.base()) {
+  return __x.base() - __y.base();
 }
 #else
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename move_iterator<_Iter1>::difference_type
-operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() - __y.base();
+inline _LIBCPP_HIDE_FROM_ABI typename move_iterator<_Iter1>::difference_type
+operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() - __y.base();
 }
-#endif // !_LIBCPP_CXX03_LANG
+#endif  // !_LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 17
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI constexpr
-move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
-    requires requires { { __x.base() + __n } -> same_as<_Iter>; }
-{
-    return __x + __n;
+inline _LIBCPP_HIDE_FROM_ABI constexpr move_iterator<_Iter> operator+(
+    iter_difference_t<_Iter> __n,
+    const move_iterator<_Iter>& __x) requires requires {
+  { __x.base() + __n } -> same_as<_Iter>;
 }
+{ return __x + __n; }
 #else
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-move_iterator<_Iter>
-operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
-{
-    return move_iterator<_Iter>(__x.base() + __n);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
+operator+(typename move_iterator<_Iter>::difference_type __n,
+          const move_iterator<_Iter>& __x) {
+  return move_iterator<_Iter>(__x.base() + __n);
 }
-#endif // _LIBCPP_STD_VER > 17
+#endif  // _LIBCPP_STD_VER > 17
 
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-move_iterator<_Iter>
-make_move_iterator(_Iter __i)
-{
-    return move_iterator<_Iter>(std::move(__i));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
+make_move_iterator(_Iter __i) {
+  return move_iterator<_Iter>(std::move(__i));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H
+#endif  // _LIBCPP___ITERATOR_MOVE_ITERATOR_H
diff --git a/libcxx/include/version b/libcxx/include/version
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -195,7 +195,8 @@
 __cpp_lib_unreachable                                   202202L <utility>
 __cpp_lib_unwrap_ref                                    201811L <functional>
 __cpp_lib_variant                                       202102L <variant>
-__cpp_lib_void_t                                        201411L <type_traits>
+__cpp_lib_void_t                                        201411L <type_traits> 
+__cpp_lib_move_iterator_concept                         202207L <iterator>
 
 */
 
@@ -412,6 +413,7 @@
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
+# define __cpp_lib_move_iterator_concept                202207L 
 # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp
@@ -341,11 +341,13 @@
   {
     // check that the iterator isn't moved from multiple times
     std::shared_ptr<int> a[] = { std::make_shared<int>(42) };
+   #if TEST_STD_VER <= 20
     auto range = std::ranges::subrange(std::move_iterator(a), std::move_iterator(a + 1));
     auto [min, max] = std::ranges::minmax(range);
     assert(a[0] == nullptr);
     assert(min != nullptr);
     assert(max == min);
+    #endif
   }
 
   return 0;
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp
@@ -15,6 +15,8 @@
 #include "test_iterators.h"
 #include "test_macros.h"
 
+#if TEST_STD_VER <= 20
+
 void test()
 {
   {
@@ -137,3 +139,5 @@
     static_assert( std::indirectly_swappable<iterator, iterator>);
   }
 }
+
+#endif
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_specializations.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_specializations.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_specializations.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// move_iterator
+
+#include <iterator>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// Tests for move_iterator specializations
+#if TEST_STD_VER > 20
+static_assert(
+    std::is_same_v<
+        typename std::move_iterator<forward_iterator<char*>>::iterator_concept,
+        std::forward_iterator_tag>);
+static_assert(
+    std::is_same_v<typename std::move_iterator<
+                       bidirectional_iterator<char*>>::iterator_concept,
+                   std::bidirectional_iterator_tag>);
+static_assert(
+    std::is_same_v<typename std::move_iterator<
+                       random_access_iterator<char*>>::iterator_concept,
+                   std::random_access_iterator_tag>);
+static_assert(std::is_same_v<typename std::move_iterator<
+                                 contiguous_iterator<char*>>::iterator_concept,
+                             std::random_access_iterator_tag>);
+static_assert(
+    std::is_same_v<typename std::move_iterator<char*>::iterator_concept,
+                   std::random_access_iterator_tag>);
+
+#endif
+int main() {}  // COMPILE-ONLY
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -98,7 +98,7 @@
   static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 #endif
 
-#if TEST_STD_VER > 17
+#if TEST_STD_VER < 20
   static_assert(std::is_same_v<typename R::iterator_concept, std::input_iterator_tag>);
 #endif
 }
@@ -140,7 +140,7 @@
   }
 #endif
 
-#if TEST_STD_VER > 17
+#if TEST_STD_VER <= 20
   test<contiguous_iterator<char*>>();
   static_assert(std::is_same_v<typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
   static_assert(std::is_same_v<typename std::move_iterator<bidirectional_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp
@@ -59,6 +59,10 @@
 #   error "__cpp_lib_ssize should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#  error "__cpp_lib_move_iterator_concept should not be defined before c++2b" 
+# endif
+
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_array_constexpr
@@ -95,6 +99,10 @@
 #   error "__cpp_lib_ssize should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#  error "__cpp_lib_move_iterator_concept should not be defined before c++2b" 
+# endif
+
 #elif TEST_STD_VER == 17
 
 # ifndef __cpp_lib_array_constexpr
@@ -188,6 +196,10 @@
 #   error "__cpp_lib_ssize should have the value 201902L in c++20"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#  error "__cpp_lib_move_iterator_concept should not be defined before c++2b" 
+# endif
+
 #elif TEST_STD_VER > 20
 
 # ifndef __cpp_lib_array_constexpr
@@ -238,6 +250,12 @@
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++2b"
 # endif
+# ifndef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should be defined in c++2b"
+# endif
+# if __cpp_lib_move_iterator_concept != 202207L
+#   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++2b"
+# endif
 
 #endif // TEST_STD_VER > 20
 
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -763,7 +763,11 @@
     "name": "__cpp_lib_void_t",
     "values": { "c++17": 201411 },
     "headers": ["type_traits"],
-  }
+  }, {
+    "name": "__cpp_lib_move_iterator_concept",
+    "values": {"c++2b": 202207 }, 
+    "headers": ["iterator"],
+  },
 ]]
 
 assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"])