diff --git a/include/atomic b/include/atomic
index f953855..3423642 100644
--- a/include/atomic
+++ b/include/atomic
@@ -669,7 +669,7 @@
   "unexpected underlying type for std::memory_order");
 
 #if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) || \
-	defined(_LIBCPP_ATOMIC_ONLY_USE_BUILTINS)
+    defined(_LIBCPP_ATOMIC_ONLY_USE_BUILTINS)
 
 // [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because
 // the default operator= in an object is not volatile, a byte-by-byte copy
diff --git a/include/barrier b/include/barrier
index be213a6..e650773 100644
--- a/include/barrier
+++ b/include/barrier
@@ -309,11 +309,11 @@
     {
         __b.wait(_VSTD::move(__phase));
     }
-	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_wait()
     {
         wait(arrive());
-	}
+    }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_drop()
     {
diff --git a/include/cmath b/include/cmath
index 9c493ce..1efd4e4 100644
--- a/include/cmath
+++ b/include/cmath
@@ -622,9 +622,9 @@
     if (__t == 1) return __b;
     const _Fp __x = __a + __t * (__b - __a);
     if (__t > 1 == __b > __a)
-    	return __b < __x ? __x : __b;
+        return __b < __x ? __x : __b;
     else
-    	return __x < __b ? __x : __b;
+        return __x < __b ? __x : __b;
 }
 
 constexpr float
diff --git a/include/iterator b/include/iterator
index 5e9e822..c94d275 100644
--- a/include/iterator
+++ b/include/iterator
@@ -406,7 +406,7 @@
 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
+    -> 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
diff --git a/include/numeric b/include/numeric
index 4f202bb..862396d 100644
--- a/include/numeric
+++ b/include/numeric
@@ -613,8 +613,8 @@
 enable_if_t<is_floating_point_v<_Fp>, _Fp>
 midpoint(_Fp __a, _Fp __b) noexcept
 {
-	constexpr _Fp __lo = numeric_limits<_Fp>::min()*2;
-	constexpr _Fp __hi = numeric_limits<_Fp>::max()/2;
+    constexpr _Fp __lo = numeric_limits<_Fp>::min()*2;
+    constexpr _Fp __hi = numeric_limits<_Fp>::max()/2;
     return __fp_abs(__a) <= __hi && __fp_abs(__b) <= __hi ?  // typical case: overflow is impossible
       (__a + __b)/2 :                                        // always correctly rounded
       __fp_abs(__a) < __lo ? __a + __b/2 :                   // not safe to halve a
diff --git a/include/type_traits b/include/type_traits
index 43a04cb..38cad33 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -2424,7 +2424,7 @@
 #endif
 
 #if _LIBCPP_STD_VER > 11
-// Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM’s
+// Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's
 // top-level cv-qualifiers.
 template <class _From, class _To>
 struct __copy_cv
@@ -2493,8 +2493,8 @@
   using __apply = __copy_cvref_t<_Tp, _Up>;
 };
 
-// Given types `A` and `B`, let `X` be `remove_­reference_­t<A>`, let `Y` be `remove_­reference_­t<B>`,
-// and let `COMMON-​REF(A, B)` be:
+// Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>,
+// and let COMMON-REF(A, B) be:
 template<class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>>
 struct __common_ref;
 
@@ -2505,8 +2505,8 @@
 using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
 
 
-//    If `A` and `B` are both lvalue reference types, `COMMON-REF(A, B)` is
-//    `COND-RES(COPYCV(X, Y) &, COPYCV(​Y, X) &)` if that type exists and is a reference type.
+//    If A and B are both lvalue reference types, COMMON-REF(A, B) is
+//    COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires requires { typename __cv_cond_res<_Xp, _Yp>; } && is_reference_v<__cv_cond_res<_Xp, _Yp>>
 struct __common_ref<_Ap&, _Bp&, _Xp, _Yp>
@@ -2514,13 +2514,13 @@
     using __type = __cv_cond_res<_Xp, _Yp>;
 };
 
-//    Otherwise, let `C` be `remove_­reference_­t<COMMON-REF(X&, Y&)>&&`....
+//    Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
 template <class _Xp, class _Yp>
 using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
 
 
-//    .... If `A` and `B` are both rvalue reference types, `C` is well-formed, and
-//    `is_­convertible_­v<A, C> && is_­convertible_­v<B, C>` is `true`, then `COMMON-REF(A, B)` is `C`.
+//    .... If A and B are both rvalue reference types, C is well-formed, and
+//    is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires
   requires { typename __common_ref_C<_Xp, _Yp>; } &&
@@ -2531,12 +2531,12 @@
     using __type = __common_ref_C<_Xp, _Yp>;
 };
 
-//    Otherwise, let `D` be `COMMON-REF(const X&, Y&)`....
+//    Otherwise, let D be COMMON-REF(const X&, Y&). ...
 template <class _Tp, class _Up>
 using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
 
-//    ... If `A` is an rvalue reference and `B` is an lvalue reference and `D` is well-formed and
-//    `is_­convertible_­v<A, D>` is `true`, then `COMMON-REF(A, B)` is `D`.
+//    ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
+//    is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires requires { typename __common_ref_D<_Xp, _Yp>; } &&
          is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>
@@ -2545,12 +2545,12 @@
     using __type = __common_ref_D<_Xp, _Yp>;
 };
 
-//    Otherwise, if `A` is an lvalue reference and `B` is an rvalue reference, then
-//    `COMMON-REF(A, B)` is `COMMON-REF(B, A)`.
+//    Otherwise, if A is an lvalue reference and B is an rvalue reference, then
+//    COMMON-REF(A, B) is COMMON-REF(B, A).
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 struct __common_ref<_Ap&, _Bp&&, _Xp, _Yp> : __common_ref<_Bp&&, _Ap&> {};
 
-//    Otherwise, `COMMON-REF(A, B)` is ill-formed.
+//    Otherwise, COMMON-REF(A, B) is ill-formed.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 struct __common_ref {};
 
@@ -2578,8 +2578,8 @@
 template <class _Tp, class _Up> struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up> {};
 template <class _Tp, class _Up> struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up> {};
 
-// sub-bullet 1 - If `T1` and `T2` are reference types and `COMMON-REF(T1, T2)` is well-formed, then
-// the member typedef type denotes that type.
+// sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then
+// the member typedef `type` denotes that type.
 template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
 
 template <class _Tp, class _Up>
@@ -2589,8 +2589,8 @@
     using type = __common_ref_t<_Tp, _Up>;
 };
 
-// sub-bullet 2 - Otherwise, if `basic_­common_­reference<remove_­cvref_­t<T1>, remove_­cvref_­t<T2>, ​XREF(​T1), XREF(T2)>​::​type`
-// is well-formed, then the member typedef type denotes that type.
+// sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type
+// is well-formed, then the member typedef `type` denotes that type.
 template <class, class, template <class> class, template <class> class> struct basic_common_reference {};
 
 template <class _Tp, class _Up>
@@ -2605,8 +2605,8 @@
     using type = __basic_common_reference_t<_Tp, _Up>;
 };
 
-// sub-bullet 3 - Otherwise, if `COND-RES(T1, T2)` is well-formed, then the member typedef type
-// denotes that type.
+// sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed,
+// then the member typedef `type` denotes that type.
 template <class _Tp, class _Up>
 requires requires { typename __cond_res<_Tp, _Up>; }
 struct __common_reference_sub_bullet3<_Tp, _Up>
@@ -2615,20 +2615,20 @@
 };
 
 
-// sub-bullet 4 & 5 - Otherwise, if `common_­type_­t<T1, T2>` is well-formed, then the member typedef
-//                    type denotes that type.
-//                  - Otherwise, there shall be no member type.
+// sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed,
+//                    then the member typedef `type` denotes that type.
+//                  - Otherwise, there shall be no member `type`.
 template <class _Tp, class _Up> struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {};
 
 // bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if
-//            any, as `common_­reference_­t<C, Rest...>`.
+//            any, as `common_reference_t<C, Rest...>`.
 template <class _Tp, class _Up, class _Vp, class... _Rest>
 requires requires { typename common_reference_t<_Tp, _Up>; }
 struct common_reference<_Tp, _Up, _Vp, _Rest...>
     : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
 {};
 
-// bullet 5 - Otherwise, there shall be no member type.
+// bullet 5 - Otherwise, there shall be no member `type`.
 template <class...> struct common_reference {};
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)