Remove old code

Signed-off-by: Richard Qin <richard.qin.x@gmail.com>

7 files changed, 0 insertions, 1790 deletions

diff --git a/third_party/libcxx/include/c++/v1/__mdspan/aligned_accessor.h b/third_party/libcxx/include/c++/v1/__mdspan/aligned_accessor.h
deleted file mode 100644
index 2b8d4c5..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/aligned_accessor.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_ALIGNED_ACCESSOR_H
-#define _LIBCPP___MDSPAN_ALIGNED_ACCESSOR_H
-
-#include <__config>
-#include <__cstddef/size_t.h>
-#include <__mdspan/default_accessor.h>
-#include <__memory/assume_aligned.h>
-#include <__type_traits/is_abstract.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/remove_const.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 26
-
-template <class _ElementType, size_t _ByteAlignment>
-struct aligned_accessor {
-  static_assert(_ByteAlignment != 0 && (_ByteAlignment & (_ByteAlignment - 1)) == 0,
-                "aligned_accessor: byte alignment must be a power of two");
-  static_assert(_ByteAlignment >= alignof(_ElementType), "aligned_accessor: insufficient byte alignment");
-  static_assert(!is_array_v<_ElementType>, "aligned_accessor: template argument may not be an array type");
-  static_assert(!is_abstract_v<_ElementType>, "aligned_accessor: template argument may not be an abstract class");
-
-  using offset_policy    = default_accessor<_ElementType>;
-  using element_type     = _ElementType;
-  using reference        = _ElementType&;
-  using data_handle_type = _ElementType*;
-
-  static constexpr size_t byte_alignment = _ByteAlignment;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr aligned_accessor() noexcept = default;
-
-  template <class _OtherElementType, size_t _OtherByteAlignment>
-    requires(is_convertible_v<_OtherElementType (*)[], element_type (*)[]> && _OtherByteAlignment >= byte_alignment)
-  _LIBCPP_HIDE_FROM_ABI constexpr aligned_accessor(aligned_accessor<_OtherElementType, _OtherByteAlignment>) noexcept {}
-
-  template <class _OtherElementType>
-    requires(is_convertible_v<_OtherElementType (*)[], element_type (*)[]>)
-  _LIBCPP_HIDE_FROM_ABI explicit constexpr aligned_accessor(default_accessor<_OtherElementType>) noexcept {}
-
-  template <class _OtherElementType>
-    requires(is_convertible_v<element_type (*)[], _OtherElementType (*)[]>)
-  _LIBCPP_HIDE_FROM_ABI constexpr operator default_accessor<_OtherElementType>() const noexcept {
-    return {};
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr reference access(data_handle_type __p, size_t __i) const noexcept {
-    return std::assume_aligned<byte_alignment>(__p)[__i];
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr typename offset_policy::data_handle_type
-  offset(data_handle_type __p, size_t __i) const noexcept {
-    return std::assume_aligned<byte_alignment>(__p) + __i;
-  }
-};
-
-#endif // _LIBCPP_STD_VER >= 26
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_ALIGNED_ACCESSOR_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/default_accessor.h b/third_party/libcxx/include/c++/v1/__mdspan/default_accessor.h
deleted file mode 100644
index d6f3ddb..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/default_accessor.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
-#define _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
-
-#include <__config>
-#include <__cstddef/size_t.h>
-#include <__type_traits/is_abstract.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/remove_const.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-template <class _ElementType>
-struct default_accessor {
-  static_assert(!is_array_v<_ElementType>, "default_accessor: template argument may not be an array type");
-  static_assert(!is_abstract_v<_ElementType>, "default_accessor: template argument may not be an abstract class");
-
-  using offset_policy    = default_accessor;
-  using element_type     = _ElementType;
-  using reference        = _ElementType&;
-  using data_handle_type = _ElementType*;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr default_accessor() noexcept = default;
-  template <class _OtherElementType>
-    requires(is_convertible_v<_OtherElementType (*)[], element_type (*)[]>)
-  _LIBCPP_HIDE_FROM_ABI constexpr default_accessor(default_accessor<_OtherElementType>) noexcept {}
-
-  _LIBCPP_HIDE_FROM_ABI constexpr reference access(data_handle_type __p, size_t __i) const noexcept { return __p[__i]; }
-  _LIBCPP_HIDE_FROM_ABI constexpr data_handle_type offset(data_handle_type __p, size_t __i) const noexcept {
-    return __p + __i;
-  }
-};
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/extents.h b/third_party/libcxx/include/c++/v1/__mdspan/extents.h
deleted file mode 100644
index d16bbd2..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/extents.h
+++ /dev/null
@@ -1,536 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_EXTENTS_H
-#define _LIBCPP___MDSPAN_EXTENTS_H
-
-#include <__assert>
-#include <__config>
-
-#include <__concepts/arithmetic.h>
-#include <__type_traits/common_type.h>
-#include <__type_traits/integer_traits.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_signed.h>
-#include <__type_traits/make_unsigned.h>
-#include <__utility/integer_sequence.h>
-#include <__utility/unreachable.h>
-#include <array>
-#include <concepts>
-#include <limits>
-#include <span>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-namespace __mdspan_detail {
-
-// ------------------------------------------------------------------
-// ------------ __static_array --------------------------------------
-// ------------------------------------------------------------------
-// array like class which provides an array of static values with get
-template <class _Tp, _Tp... _Values>
-struct __static_array {
-  static constexpr array<_Tp, sizeof...(_Values)> __array = {_Values...};
-
-public:
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size() { return sizeof...(_Values); }
-  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp __get(size_t __index) noexcept { return __array[__index]; }
-
-  template <size_t _Index>
-  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp __get() {
-    return __get(_Index);
-  }
-};
-
-// ------------------------------------------------------------------
-// ------------ __possibly_empty_array  -----------------------------
-// ------------------------------------------------------------------
-
-// array like class which provides get function and operator [], and
-// has a specialization for the size 0 case.
-// This is needed to make the __maybe_static_array be truly empty, for
-// all static values.
-
-template <class _Tp, size_t _Size>
-struct __possibly_empty_array {
-  _Tp __vals_[_Size];
-  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator[](size_t __index) { return __vals_[__index]; }
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](size_t __index) const { return __vals_[__index]; }
-};
-
-template <class _Tp>
-struct __possibly_empty_array<_Tp, 0> {
-  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator[](size_t) { __libcpp_unreachable(); }
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](size_t) const { __libcpp_unreachable(); }
-};
-
-// ------------------------------------------------------------------
-// ------------ static_partial_sums ---------------------------------
-// ------------------------------------------------------------------
-
-// Provides a compile time partial sum one can index into
-
-template <size_t... _Values>
-struct __static_partial_sums {
-  _LIBCPP_HIDE_FROM_ABI static constexpr array<size_t, sizeof...(_Values)> __static_partial_sums_impl() {
-    array<size_t, sizeof...(_Values)> __values{_Values...};
-    array<size_t, sizeof...(_Values)> __partial_sums{{}};
-    size_t __running_sum = 0;
-    for (int __i = 0; __i != sizeof...(_Values); ++__i) {
-      __partial_sums[__i] = __running_sum;
-      __running_sum += __values[__i];
-    }
-    return __partial_sums;
-  }
-  static constexpr array<size_t, sizeof...(_Values)> __result{__static_partial_sums_impl()};
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __get(size_t __index) { return __result[__index]; }
-};
-
-// ------------------------------------------------------------------
-// ------------ __maybe_static_array --------------------------------
-// ------------------------------------------------------------------
-
-// array like class which has a mix of static and runtime values but
-// only stores the runtime values.
-// The type of the static and the runtime values can be different.
-// The position of a dynamic value is indicated through a tag value.
-template <class _TDynamic, class _TStatic, _TStatic _DynTag, _TStatic... _Values>
-struct __maybe_static_array {
-  static_assert(is_convertible<_TStatic, _TDynamic>::value,
-                "__maybe_static_array: _TStatic must be convertible to _TDynamic");
-  static_assert(is_convertible<_TDynamic, _TStatic>::value,
-                "__maybe_static_array: _TDynamic must be convertible to _TStatic");
-
-private:
-  // Static values member
-  static constexpr size_t __size_         = sizeof...(_Values);
-  static constexpr size_t __size_dynamic_ = ((_Values == _DynTag) + ... + 0);
-  using _StaticValues _LIBCPP_NODEBUG     = __static_array<_TStatic, _Values...>;
-  using _DynamicValues _LIBCPP_NODEBUG    = __possibly_empty_array<_TDynamic, __size_dynamic_>;
-
-  // Dynamic values member
-  _LIBCPP_NO_UNIQUE_ADDRESS _DynamicValues __dyn_vals_;
-
-  // static mapping of indices to the position in the dynamic values array
-  using _DynamicIdxMap _LIBCPP_NODEBUG = __static_partial_sums<static_cast<size_t>(_Values == _DynTag)...>;
-
-  template <size_t... _Indices>
-  _LIBCPP_HIDE_FROM_ABI static constexpr _DynamicValues __zeros(index_sequence<_Indices...>) noexcept {
-    return _DynamicValues{((void)_Indices, 0)...};
-  }
-
-public:
-  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array() noexcept
-      : __dyn_vals_{__zeros(make_index_sequence<__size_dynamic_>())} {}
-
-  // constructors from dynamic values only -- this covers the case for rank() == 0
-  template <class... _DynVals>
-    requires(sizeof...(_DynVals) == __size_dynamic_)
-  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(_DynVals... __vals)
-      : __dyn_vals_{static_cast<_TDynamic>(__vals)...} {}
-
-  template <class _Tp, size_t _Size >
-    requires(_Size == __size_dynamic_)
-  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array([[maybe_unused]] const span<_Tp, _Size>& __vals) {
-    if constexpr (_Size > 0) {
-      for (size_t __i = 0; __i < _Size; __i++)
-        __dyn_vals_[__i] = static_cast<_TDynamic>(__vals[__i]);
-    }
-  }
-
-  // constructors from all values -- here rank will be greater than 0
-  template <class... _DynVals>
-    requires(sizeof...(_DynVals) != __size_dynamic_)
-  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(_DynVals... __vals) {
-    static_assert(sizeof...(_DynVals) == __size_, "Invalid number of values.");
-    _TDynamic __values[__size_] = {static_cast<_TDynamic>(__vals)...};
-    for (size_t __i = 0; __i < __size_; __i++) {
-      _TStatic __static_val = _StaticValues::__get(__i);
-      if (__static_val == _DynTag) {
-        __dyn_vals_[_DynamicIdxMap::__get(__i)] = __values[__i];
-      } else
-        // Not catching this could lead to out of bounds errors later
-        // e.g. using my_mdspan_t = mdspan<int, extents<int, 10>>; my_mdspan_t = m(new int[5], 5);
-        // Right-hand-side construction looks ok with allocation and size matching,
-        // but since (potentially elsewhere defined) my_mdspan_t has static size m now thinks its range is 10 not 5
-        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-            __values[__i] == static_cast<_TDynamic>(__static_val),
-            "extents construction: mismatch of provided arguments with static extents.");
-    }
-  }
-
-  template <class _Tp, size_t _Size>
-    requires(_Size != __size_dynamic_)
-  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const span<_Tp, _Size>& __vals) {
-    static_assert(_Size == __size_ || __size_ == dynamic_extent);
-    for (size_t __i = 0; __i < __size_; __i++) {
-      _TStatic __static_val = _StaticValues::__get(__i);
-      if (__static_val == _DynTag) {
-        __dyn_vals_[_DynamicIdxMap::__get(__i)] = static_cast<_TDynamic>(__vals[__i]);
-      } else
-        // Not catching this could lead to out of bounds errors later
-        // e.g. using my_mdspan_t = mdspan<int, extents<int, 10>>; my_mdspan_t = m(new int[N], span<int,1>(&N));
-        // Right-hand-side construction looks ok with allocation and size matching,
-        // but since (potentially elsewhere defined) my_mdspan_t has static size m now thinks its range is 10 not N
-        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-            static_cast<_TDynamic>(__vals[__i]) == static_cast<_TDynamic>(__static_val),
-            "extents construction: mismatch of provided arguments with static extents.");
-    }
-  }
-
-  // access functions
-  _LIBCPP_HIDE_FROM_ABI static constexpr _TStatic __static_value(size_t __i) noexcept {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
-    return _StaticValues::__get(__i);
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic __value(size_t __i) const {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
-    _TStatic __static_val = _StaticValues::__get(__i);
-    return __static_val == _DynTag ? __dyn_vals_[_DynamicIdxMap::__get(__i)] : static_cast<_TDynamic>(__static_val);
-  }
-  _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic operator[](size_t __i) const {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
-    return __value(__i);
-  }
-
-  // observers
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size() { return __size_; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size_dynamic() { return __size_dynamic_; }
-};
-
-// Function to check whether a value is representable as another type
-// value must be a positive integer otherwise returns false
-// if _From is not an integral, we just check positivity
-template <integral _To, class _From>
-  requires(integral<_From>)
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
-  using _To_u   = make_unsigned_t<_To>;
-  using _From_u = make_unsigned_t<_From>;
-  if constexpr (is_signed_v<_From>) {
-    if (__value < 0)
-      return false;
-  }
-  if constexpr (static_cast<_To_u>(numeric_limits<_To>::max()) >= static_cast<_From_u>(numeric_limits<_From>::max())) {
-    return true;
-  } else {
-    return static_cast<_To_u>(numeric_limits<_To>::max()) >= static_cast<_From_u>(__value);
-  }
-}
-
-template <integral _To, class _From>
-  requires(!integral<_From>)
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
-  if constexpr (is_signed_v<_To>) {
-    if (static_cast<_To>(__value) < 0)
-      return false;
-  }
-  return true;
-}
-
-template <integral _To, class... _From>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __are_representable_as(_From... __values) {
-  return (__mdspan_detail::__is_representable_as<_To>(__values) && ... && true);
-}
-
-template <integral _To, class _From, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __are_representable_as(span<_From, _Size> __values) {
-  for (size_t __i = 0; __i < _Size; __i++)
-    if (!__mdspan_detail::__is_representable_as<_To>(__values[__i]))
-      return false;
-  return true;
-}
-
-} // namespace __mdspan_detail
-
-// ------------------------------------------------------------------
-// ------------ extents ---------------------------------------------
-// ------------------------------------------------------------------
-
-// Class to describe the extents of a multi dimensional array.
-// Used by mdspan, mdarray and layout mappings.
-// See ISO C++ standard [mdspan.extents]
-
-template <class _IndexType, size_t... _Extents>
-class extents {
-public:
-  // typedefs for integral types used
-  using index_type = _IndexType;
-  using size_type  = make_unsigned_t<index_type>;
-  using rank_type  = size_t;
-
-  static_assert(__signed_or_unsigned_integer<index_type>,
-                "extents::index_type must be a signed or unsigned integer type");
-  static_assert(((__mdspan_detail::__is_representable_as<index_type>(_Extents) || (_Extents == dynamic_extent)) && ...),
-                "extents ctor: arguments must be representable as index_type and nonnegative");
-
-private:
-  static constexpr rank_type __rank_         = sizeof...(_Extents);
-  static constexpr rank_type __rank_dynamic_ = ((_Extents == dynamic_extent) + ... + 0);
-
-  // internal storage type using __maybe_static_array
-  using _Values _LIBCPP_NODEBUG =
-      __mdspan_detail::__maybe_static_array<_IndexType, size_t, dynamic_extent, _Extents...>;
-  [[no_unique_address]] _Values __vals_;
-
-public:
-  // [mdspan.extents.obs], observers of multidimensional index space
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return __rank_; }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept { return __rank_dynamic_; }
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
-    return __vals_.__value(__r);
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
-    return _Values::__static_value(__r);
-  }
-
-  // [mdspan.extents.cons], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr extents() noexcept = default;
-
-  // Construction from just dynamic or all values.
-  // Precondition check is deferred to __maybe_static_array constructor
-  template <class... _OtherIndexTypes>
-    requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
-             (sizeof...(_OtherIndexTypes) == __rank_ || sizeof...(_OtherIndexTypes) == __rank_dynamic_))
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit extents(_OtherIndexTypes... __dynvals) noexcept
-      : __vals_(static_cast<index_type>(__dynvals)...) {
-    // Not catching this could lead to out of bounds errors later
-    // e.g. mdspan m(ptr, dextents<char, 1>(200u)); leads to an extent of -56 on m
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(__dynvals...),
-                                        "extents ctor: arguments must be representable as index_type and nonnegative");
-  }
-
-  template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
-             (_Size == __rank_ || _Size == __rank_dynamic_))
-  explicit(_Size != __rank_dynamic_)
-      _LIBCPP_HIDE_FROM_ABI constexpr extents(const array<_OtherIndexType, _Size>& __exts) noexcept
-      : __vals_(span(__exts)) {
-    // Not catching this could lead to out of bounds errors later
-    // e.g. mdspan m(ptr, dextents<char, 1>(array<unsigned,1>(200))); leads to an extent of -56 on m
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(span(__exts)),
-                                        "extents ctor: arguments must be representable as index_type and nonnegative");
-  }
-
-  template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
-             (_Size == __rank_ || _Size == __rank_dynamic_))
-  explicit(_Size != __rank_dynamic_)
-      _LIBCPP_HIDE_FROM_ABI constexpr extents(const span<_OtherIndexType, _Size>& __exts) noexcept
-      : __vals_(__exts) {
-    // Not catching this could lead to out of bounds errors later
-    // e.g. array a{200u}; mdspan<int, dextents<char,1>> m(ptr, extents(span<unsigned,1>(a))); leads to an extent of -56
-    // on m
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(__exts),
-                                        "extents ctor: arguments must be representable as index_type and nonnegative");
-  }
-
-private:
-  // Function to construct extents storage from other extents.
-  template <size_t _DynCount, size_t _Idx, class _OtherExtents, class... _DynamicValues>
-    requires(_Idx < __rank_)
-  _LIBCPP_HIDE_FROM_ABI constexpr _Values __construct_vals_from_extents(
-      integral_constant<size_t, _DynCount>,
-      integral_constant<size_t, _Idx>,
-      const _OtherExtents& __exts,
-      _DynamicValues... __dynamic_values) noexcept {
-    if constexpr (static_extent(_Idx) == dynamic_extent)
-      return __construct_vals_from_extents(
-          integral_constant<size_t, _DynCount + 1>(),
-          integral_constant<size_t, _Idx + 1>(),
-          __exts,
-          __dynamic_values...,
-          __exts.extent(_Idx));
-    else
-      return __construct_vals_from_extents(
-          integral_constant<size_t, _DynCount>(), integral_constant<size_t, _Idx + 1>(), __exts, __dynamic_values...);
-  }
-
-  template <size_t _DynCount, size_t _Idx, class _OtherExtents, class... _DynamicValues>
-    requires((_Idx == __rank_) && (_DynCount == __rank_dynamic_))
-  _LIBCPP_HIDE_FROM_ABI constexpr _Values __construct_vals_from_extents(
-      integral_constant<size_t, _DynCount>,
-      integral_constant<size_t, _Idx>,
-      const _OtherExtents&,
-      _DynamicValues... __dynamic_values) noexcept {
-    return _Values{static_cast<index_type>(__dynamic_values)...};
-  }
-
-public:
-  // Converting constructor from other extents specializations
-  template <class _OtherIndexType, size_t... _OtherExtents>
-    requires((sizeof...(_OtherExtents) == sizeof...(_Extents)) &&
-             ((_OtherExtents == dynamic_extent || _Extents == dynamic_extent || _OtherExtents == _Extents) && ...))
-  explicit((((_Extents != dynamic_extent) && (_OtherExtents == dynamic_extent)) || ...) ||
-           (static_cast<make_unsigned_t<index_type>>(numeric_limits<index_type>::max()) <
-            static_cast<make_unsigned_t<_OtherIndexType>>(numeric_limits<_OtherIndexType>::max())))
-      _LIBCPP_HIDE_FROM_ABI constexpr extents(const extents<_OtherIndexType, _OtherExtents...>& __other) noexcept
-      : __vals_(
-            __construct_vals_from_extents(integral_constant<size_t, 0>(), integral_constant<size_t, 0>(), __other)) {
-    if constexpr (rank() > 0) {
-      for (size_t __r = 0; __r < rank(); __r++) {
-        if constexpr (static_cast<make_unsigned_t<index_type>>(numeric_limits<index_type>::max()) <
-                      static_cast<make_unsigned_t<_OtherIndexType>>(numeric_limits<_OtherIndexType>::max())) {
-          // Not catching this could lead to out of bounds errors later
-          // e.g. dextents<char,1>> e(dextents<unsigned,1>(200)) leads to an extent of -56 on e
-          _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-              __mdspan_detail::__is_representable_as<index_type>(__other.extent(__r)),
-              "extents ctor: arguments must be representable as index_type and nonnegative");
-        }
-        // Not catching this could lead to out of bounds errors later
-        // e.g. mdspan<int, extents<int, 10>> m = mdspan<int, dextents<int, 1>>(new int[5], 5);
-        // Right-hand-side construction was ok, but m now thinks its range is 10 not 5
-        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-            (_Values::__static_value(__r) == dynamic_extent) ||
-                (static_cast<index_type>(__other.extent(__r)) == static_cast<index_type>(_Values::__static_value(__r))),
-            "extents construction: mismatch of provided arguments with static extents.");
-      }
-    }
-  }
-
-  // Comparison operator
-  template <class _OtherIndexType, size_t... _OtherExtents>
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator==(const extents& __lhs, const extents<_OtherIndexType, _OtherExtents...>& __rhs) noexcept {
-    if constexpr (rank() != sizeof...(_OtherExtents)) {
-      return false;
-    } else {
-      for (rank_type __r = 0; __r < __rank_; __r++) {
-        // avoid warning when comparing signed and unsigner integers and pick the wider of two types
-        using _CommonType = common_type_t<index_type, _OtherIndexType>;
-        if (static_cast<_CommonType>(__lhs.extent(__r)) != static_cast<_CommonType>(__rhs.extent(__r))) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-};
-
-// Recursive helper classes to implement dextents alias for extents
-namespace __mdspan_detail {
-
-template <class _IndexType, size_t _Rank, class _Extents = extents<_IndexType>>
-struct __make_dextents;
-
-template <class _IndexType, size_t _Rank, size_t... _ExtentsPack>
-struct __make_dextents< _IndexType, _Rank, extents<_IndexType, _ExtentsPack...>> {
-  using type _LIBCPP_NODEBUG =
-      typename __make_dextents< _IndexType, _Rank - 1, extents<_IndexType, dynamic_extent, _ExtentsPack...>>::type;
-};
-
-template <class _IndexType, size_t... _ExtentsPack>
-struct __make_dextents< _IndexType, 0, extents<_IndexType, _ExtentsPack...>> {
-  using type _LIBCPP_NODEBUG = extents<_IndexType, _ExtentsPack...>;
-};
-
-} // namespace __mdspan_detail
-
-// [mdspan.extents.dextents], alias template
-template <class _IndexType, size_t _Rank>
-using dextents = typename __mdspan_detail::__make_dextents<_IndexType, _Rank>::type;
-
-#  if _LIBCPP_STD_VER >= 26
-// [mdspan.extents.dims], alias template `dims`
-template <size_t _Rank, class _IndexType = size_t>
-using dims = dextents<_IndexType, _Rank>;
-#  endif
-
-// Deduction guide for extents
-#  if _LIBCPP_STD_VER >= 26
-template <class... _IndexTypes>
-  requires(is_convertible_v<_IndexTypes, size_t> && ...)
-explicit extents(_IndexTypes...) -> extents<size_t, __maybe_static_ext<_IndexTypes>...>;
-#  else
-template <class... _IndexTypes>
-  requires(is_convertible_v<_IndexTypes, size_t> && ...)
-explicit extents(_IndexTypes...) -> extents<size_t, size_t(((void)sizeof(_IndexTypes), dynamic_extent))...>;
-#  endif
-
-namespace __mdspan_detail {
-
-// Helper type traits for identifying a class as extents.
-template <class _Tp>
-struct __is_extents : false_type {};
-
-template <class _IndexType, size_t... _ExtentsPack>
-struct __is_extents<extents<_IndexType, _ExtentsPack...>> : true_type {};
-
-template <class _Tp>
-inline constexpr bool __is_extents_v = __is_extents<_Tp>::value;
-
-// Function to check whether a set of indices are a multidimensional
-// index into extents. This is a word of power in the C++ standard
-// requiring that the indices are larger than 0 and smaller than
-// the respective extents.
-
-template <integral _IndexType, class _From>
-  requires(integral<_From>)
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
-  if constexpr (is_signed_v<_From>) {
-    if (__value < 0)
-      return false;
-  }
-  using _Tp = common_type_t<_IndexType, _From>;
-  return static_cast<_Tp>(__value) < static_cast<_Tp>(__extent);
-}
-
-template <integral _IndexType, class _From>
-  requires(!integral<_From>)
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
-  if constexpr (is_signed_v<_IndexType>) {
-    if (static_cast<_IndexType>(__value) < 0)
-      return false;
-  }
-  return static_cast<_IndexType>(__value) < __extent;
-}
-
-template <size_t... _Idxs, class _Extents, class... _From>
-_LIBCPP_HIDE_FROM_ABI constexpr bool
-__is_multidimensional_index_in_impl(index_sequence<_Idxs...>, const _Extents& __ext, _From... __values) {
-  return (__mdspan_detail::__is_index_in_extent(__ext.extent(_Idxs), __values) && ...);
-}
-
-template <class _Extents, class... _From>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_multidimensional_index_in(const _Extents& __ext, _From... __values) {
-  return __mdspan_detail::__is_multidimensional_index_in_impl(
-      make_index_sequence<_Extents::rank()>(), __ext, __values...);
-}
-
-} // namespace __mdspan_detail
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_EXTENTS_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/layout_left.h b/third_party/libcxx/include/c++/v1/__mdspan/layout_left.h
deleted file mode 100644
index fb1b595..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/layout_left.h
+++ /dev/null
@@ -1,203 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_LAYOUT_LEFT_H
-#define _LIBCPP___MDSPAN_LAYOUT_LEFT_H
-
-#include <__assert>
-#include <__config>
-#include <__fwd/mdspan.h>
-#include <__mdspan/extents.h>
-#include <__memory/addressof.h>
-#include <__type_traits/common_type.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__utility/integer_sequence.h>
-#include <array>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-template <class _Extents>
-class layout_left::mapping {
-public:
-  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
-                "layout_left::mapping template argument must be a specialization of extents.");
-
-  using extents_type = _Extents;
-  using index_type   = extents_type::index_type;
-  using size_type    = extents_type::size_type;
-  using rank_type    = extents_type::rank_type;
-  using layout_type  = layout_left;
-
-private:
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
-    if constexpr (extents_type::rank() == 0)
-      return true;
-
-    index_type __prod = __ext.extent(0);
-    for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
-      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), std::addressof(__prod));
-      if (__overflowed)
-        return false;
-    }
-    return true;
-  }
-
-  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
-                "layout_left::mapping product of static extents must be representable as index_type.");
-
-public:
-  // [mdspan.layout.left.cons], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept               = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // mapping<dextents<char, 2>> map(dextents<char, 2>(40,40)); map(10, 3) == -126
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __required_span_size_is_representable(__ext),
-        "layout_left::mapping extents ctor: product of extents must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents>)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
-      mapping(const mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // mapping<dextents<char, 2>> map(mapping<dextents<int, 2>>(dextents<int, 2>(40,40))); map(10, 3) == -126
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-        "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents> && _OtherExtents::rank() <= 1)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
-      mapping(const layout_right::mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // Note: since this is constraint to rank 1, extents itself would catch the invalid conversion first
-    //       and thus this assertion should never be triggered, but keeping it here for consistency
-    // layout_left::mapping<dextents<char, 1>> map(
-    //           layout_right::mapping<dextents<unsigned, 1>>(dextents<unsigned, 1>(200))); map.extents().extent(0) ==
-    //           -56
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-        "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents>)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(extents_type::rank() > 0)
-      mapping(const layout_stride::mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    if constexpr (extents_type::rank() > 0) {
-      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-          ([&]() {
-            using _CommonType = common_type_t<typename extents_type::index_type, typename _OtherExtents::index_type>;
-            for (rank_type __r = 0; __r < extents_type::rank(); __r++)
-              if (static_cast<_CommonType>(stride(__r)) != static_cast<_CommonType>(__other.stride(__r)))
-                return false;
-            return true;
-          }()),
-          "layout_left::mapping from layout_stride ctor: strides are not compatible with layout_left.");
-      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-          __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-          "layout_left::mapping from layout_stride ctor: other.required_span_size() must be representable as "
-          "index_type.");
-    }
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
-
-  // [mdspan.layout.left.obs], observers
-  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
-    index_type __size = 1;
-    for (size_t __r = 0; __r < extents_type::rank(); __r++)
-      __size *= __extents_.extent(__r);
-    return __size;
-  }
-
-  template <class... _Indices>
-    requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _Indices> && ...))
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
-    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
-    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
-    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
-    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
-    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
-                                 "layout_left::mapping: out of bounds indexing");
-    array<index_type, extents_type::rank()> __idx_a{static_cast<index_type>(__idx)...};
-    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-      index_type __res = 0;
-      ((__res = __idx_a[extents_type::rank() - 1 - _Pos] + __extents_.extent(extents_type::rank() - 1 - _Pos) * __res),
-       ...);
-      return __res;
-    }(make_index_sequence<sizeof...(_Indices)>());
-  }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept
-    requires(extents_type::rank() > 0)
-  {
-    // While it would be caught by extents itself too, using a too large __r
-    // is functionally an out of bounds access on the stored information needed to compute strides
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __r < extents_type::rank(), "layout_left::mapping::stride(): invalid rank index");
-    index_type __s = 1;
-    for (rank_type __i = 0; __i < __r; __i++)
-      __s *= __extents_.extent(__i);
-    return __s;
-  }
-
-  template <class _OtherExtents>
-    requires(_OtherExtents::rank() == extents_type::rank())
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept {
-    return __lhs.extents() == __rhs.extents();
-  }
-
-private:
-  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
-};
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_LAYOUT_LEFT_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/layout_right.h b/third_party/libcxx/include/c++/v1/__mdspan/layout_right.h
deleted file mode 100644
index 7cb8280..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/layout_right.h
+++ /dev/null
@@ -1,201 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
-#define _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
-
-#include <__assert>
-#include <__config>
-#include <__cstddef/size_t.h>
-#include <__fwd/mdspan.h>
-#include <__mdspan/extents.h>
-#include <__memory/addressof.h>
-#include <__type_traits/common_type.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__utility/integer_sequence.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-template <class _Extents>
-class layout_right::mapping {
-public:
-  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
-                "layout_right::mapping template argument must be a specialization of extents.");
-
-  using extents_type = _Extents;
-  using index_type   = extents_type::index_type;
-  using size_type    = extents_type::size_type;
-  using rank_type    = extents_type::rank_type;
-  using layout_type  = layout_right;
-
-private:
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
-    if constexpr (extents_type::rank() == 0)
-      return true;
-
-    index_type __prod = __ext.extent(0);
-    for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
-      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), std::addressof(__prod));
-      if (__overflowed)
-        return false;
-    }
-    return true;
-  }
-
-  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
-                "layout_right::mapping product of static extents must be representable as index_type.");
-
-public:
-  // [mdspan.layout.right.cons], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept               = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // mapping<dextents<char, 2>> map(dextents<char, 2>(40,40)); map(3, 10) == -126
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __required_span_size_is_representable(__ext),
-        "layout_right::mapping extents ctor: product of extents must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents>)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
-      mapping(const mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // mapping<dextents<char, 2>> map(mapping<dextents<int, 2>>(dextents<int, 2>(40,40))); map(3, 10) == -126
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents> && _OtherExtents::rank() <= 1)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
-      mapping(const layout_left::mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    // not catching this could lead to out-of-bounds access later when used inside mdspan
-    // Note: since this is constraint to rank 1, extents itself would catch the invalid conversion first
-    //       and thus this assertion should never be triggered, but keeping it here for consistency
-    // layout_right::mapping<dextents<char, 1>> map(
-    //           layout_left::mapping<dextents<unsigned, 1>>(dextents<unsigned, 1>(200))); map.extents().extent(0) ==
-    //           -56
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
-  }
-
-  template <class _OtherExtents>
-    requires(is_constructible_v<extents_type, _OtherExtents>)
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(extents_type::rank() > 0)
-      mapping(const layout_stride::mapping<_OtherExtents>& __other) noexcept
-      : __extents_(__other.extents()) {
-    if constexpr (extents_type::rank() > 0) {
-      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-          ([&]() {
-            using _CommonType = common_type_t<typename extents_type::index_type, typename _OtherExtents::index_type>;
-            for (rank_type __r = 0; __r < extents_type::rank(); __r++)
-              if (static_cast<_CommonType>(stride(__r)) != static_cast<_CommonType>(__other.stride(__r)))
-                return false;
-            return true;
-          }()),
-          "layout_right::mapping from layout_stride ctor: strides are not compatible with layout_right.");
-      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-          __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-          "layout_right::mapping from layout_stride ctor: other.required_span_size() must be representable as "
-          "index_type.");
-    }
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
-
-  // [mdspan.layout.right.obs], observers
-  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
-    index_type __size = 1;
-    for (size_t __r = 0; __r < extents_type::rank(); __r++)
-      __size *= __extents_.extent(__r);
-    return __size;
-  }
-
-  template <class... _Indices>
-    requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _Indices> && ...))
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
-    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
-    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
-    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
-    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
-    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
-                                 "layout_right::mapping: out of bounds indexing");
-    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-      index_type __res = 0;
-      ((__res = static_cast<index_type>(__idx) + __extents_.extent(_Pos) * __res), ...);
-      return __res;
-    }(make_index_sequence<sizeof...(_Indices)>());
-  }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept
-    requires(extents_type::rank() > 0)
-  {
-    // While it would be caught by extents itself too, using a too large __r
-    // is functionally an out of bounds access on the stored information needed to compute strides
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __r < extents_type::rank(), "layout_right::mapping::stride(): invalid rank index");
-    index_type __s = 1;
-    for (rank_type __i = extents_type::rank() - 1; __i > __r; __i--)
-      __s *= __extents_.extent(__i);
-    return __s;
-  }
-
-  template <class _OtherExtents>
-    requires(_OtherExtents::rank() == extents_type::rank())
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept {
-    return __lhs.extents() == __rhs.extents();
-  }
-
-private:
-  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
-};
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/layout_stride.h b/third_party/libcxx/include/c++/v1/__mdspan/layout_stride.h
deleted file mode 100644
index 66d5a7f..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/layout_stride.h
+++ /dev/null
@@ -1,370 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
-#define _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
-
-#include <__assert>
-#include <__concepts/same_as.h>
-#include <__config>
-#include <__fwd/mdspan.h>
-#include <__mdspan/extents.h>
-#include <__memory/addressof.h>
-#include <__type_traits/common_type.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_integral.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_same.h>
-#include <__utility/as_const.h>
-#include <__utility/integer_sequence.h>
-#include <__utility/swap.h>
-#include <array>
-#include <limits>
-#include <span>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-namespace __mdspan_detail {
-template <class _Layout, class _Mapping>
-constexpr bool __is_mapping_of =
-    is_same_v<typename _Layout::template mapping<typename _Mapping::extents_type>, _Mapping>;
-
-template <class _Mapping>
-concept __layout_mapping_alike = requires {
-  requires __is_mapping_of<typename _Mapping::layout_type, _Mapping>;
-  requires __is_extents_v<typename _Mapping::extents_type>;
-  { _Mapping::is_always_strided() } -> same_as<bool>;
-  { _Mapping::is_always_exhaustive() } -> same_as<bool>;
-  { _Mapping::is_always_unique() } -> same_as<bool>;
-  bool_constant<_Mapping::is_always_strided()>::value;
-  bool_constant<_Mapping::is_always_exhaustive()>::value;
-  bool_constant<_Mapping::is_always_unique()>::value;
-};
-} // namespace __mdspan_detail
-
-template <class _Extents>
-class layout_stride::mapping {
-public:
-  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
-                "layout_stride::mapping template argument must be a specialization of extents.");
-
-  using extents_type = _Extents;
-  using index_type   = extents_type::index_type;
-  using size_type    = extents_type::size_type;
-  using rank_type    = extents_type::rank_type;
-  using layout_type  = layout_stride;
-
-private:
-  static constexpr rank_type __rank_ = extents_type::rank();
-
-  // Used for default construction check and mandates
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
-    if constexpr (__rank_ == 0)
-      return true;
-
-    index_type __prod = __ext.extent(0);
-    for (rank_type __r = 1; __r < __rank_; __r++) {
-      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), std::addressof(__prod));
-      if (__overflowed)
-        return false;
-    }
-    return true;
-  }
-
-  template <class _OtherIndexType>
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool
-  __required_span_size_is_representable(const extents_type& __ext, span<_OtherIndexType, __rank_> __strides) {
-    if constexpr (__rank_ == 0)
-      return true;
-
-    index_type __size = 1;
-    for (rank_type __r = 0; __r < __rank_; __r++) {
-      // We can only check correct conversion of _OtherIndexType if it is an integral
-      if constexpr (is_integral_v<_OtherIndexType>) {
-        using _CommonType = common_type_t<index_type, _OtherIndexType>;
-        if (static_cast<_CommonType>(__strides[__r]) > static_cast<_CommonType>(numeric_limits<index_type>::max()))
-          return false;
-      }
-      if (__ext.extent(__r) == static_cast<index_type>(0))
-        return true;
-      index_type __prod = (__ext.extent(__r) - 1);
-      bool __overflowed_mul =
-          __builtin_mul_overflow(__prod, static_cast<index_type>(__strides[__r]), std::addressof(__prod));
-      if (__overflowed_mul)
-        return false;
-      bool __overflowed_add = __builtin_add_overflow(__size, __prod, std::addressof(__size));
-      if (__overflowed_add)
-        return false;
-    }
-    return true;
-  }
-
-  // compute offset of a strided layout mapping
-  template <class _StridedMapping>
-  _LIBCPP_HIDE_FROM_ABI static constexpr index_type __offset(const _StridedMapping& __mapping) {
-    if constexpr (_StridedMapping::extents_type::rank() == 0) {
-      return static_cast<index_type>(__mapping());
-    } else if (__mapping.required_span_size() == static_cast<typename _StridedMapping::index_type>(0)) {
-      return static_cast<index_type>(0);
-    } else {
-      return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-        return static_cast<index_type>(__mapping((_Pos ? 0 : 0)...));
-      }(make_index_sequence<__rank_>());
-    }
-  }
-
-  // compute the permutation for sorting the stride array
-  // we never actually sort the stride array
-  _LIBCPP_HIDE_FROM_ABI constexpr void __bubble_sort_by_strides(array<rank_type, __rank_>& __permute) const {
-    for (rank_type __i = __rank_ - 1; __i > 0; __i--) {
-      for (rank_type __r = 0; __r < __i; __r++) {
-        if (__strides_[__permute[__r]] > __strides_[__permute[__r + 1]]) {
-          swap(__permute[__r], __permute[__r + 1]);
-        } else {
-          // if two strides are the same then one of the associated extents must be 1 or 0
-          // both could be, but you can't have one larger than 1 come first
-          if ((__strides_[__permute[__r]] == __strides_[__permute[__r + 1]]) &&
-              (__extents_.extent(__permute[__r]) > static_cast<index_type>(1)))
-            swap(__permute[__r], __permute[__r + 1]);
-        }
-      }
-    }
-  }
-
-  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
-                "layout_stride::mapping product of static extents must be representable as index_type.");
-
-public:
-  // [mdspan.layout.stride.cons], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept : __extents_(extents_type()) {
-    // Note the nominal precondition is covered by above static assert since
-    // if rank_dynamic is != 0 required_span_size is zero for default construction
-    if constexpr (__rank_ > 0) {
-      index_type __stride = 1;
-      for (rank_type __r = __rank_ - 1; __r > static_cast<rank_type>(0); __r--) {
-        __strides_[__r] = __stride;
-        __stride *= __extents_.extent(__r);
-      }
-      __strides_[0] = __stride;
-    }
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
-
-  template <class _OtherIndexType>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext, span<_OtherIndexType, __rank_> __strides) noexcept
-      : __extents_(__ext), __strides_([&]<size_t... _Pos>(index_sequence<_Pos...>) {
-          return __mdspan_detail::__possibly_empty_array<index_type, __rank_>{
-              static_cast<index_type>(std::as_const(__strides[_Pos]))...};
-        }(make_index_sequence<__rank_>())) {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
-          // For integrals we can do a pre-conversion check, for other types not
-          if constexpr (is_integral_v<_OtherIndexType>) {
-            return ((__strides[_Pos] > static_cast<_OtherIndexType>(0)) && ... && true);
-          } else {
-            return ((static_cast<index_type>(__strides[_Pos]) > static_cast<index_type>(0)) && ... && true);
-          }
-        }(make_index_sequence<__rank_>())),
-        "layout_stride::mapping ctor: all strides must be greater than 0");
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __required_span_size_is_representable(__ext, __strides),
-        "layout_stride::mapping ctor: required span size is not representable as index_type.");
-    if constexpr (__rank_ > 1) {
-      _LIBCPP_ASSERT_UNCATEGORIZED(
-          ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
-            // basically sort the dimensions based on strides and extents, sorting is represented in permute array
-            array<rank_type, __rank_> __permute{_Pos...};
-            __bubble_sort_by_strides(__permute);
-
-            // check that this permutations represents a growing set
-            for (rank_type __i = 1; __i < __rank_; __i++)
-              if (static_cast<index_type>(__strides[__permute[__i]]) <
-                  static_cast<index_type>(__strides[__permute[__i - 1]]) * __extents_.extent(__permute[__i - 1]))
-                return false;
-            return true;
-          }(make_index_sequence<__rank_>())),
-          "layout_stride::mapping ctor: the provided extents and strides lead to a non-unique mapping");
-    }
-  }
-
-  template <class _OtherIndexType>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext,
-                                          const array<_OtherIndexType, __rank_>& __strides) noexcept
-      : mapping(__ext, span(__strides)) {}
-
-  template <class _StridedLayoutMapping>
-    requires(__mdspan_detail::__layout_mapping_alike<_StridedLayoutMapping> &&
-             is_constructible_v<extents_type, typename _StridedLayoutMapping::extents_type> &&
-             _StridedLayoutMapping::is_always_unique() && _StridedLayoutMapping::is_always_strided())
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(
-      !(is_convertible_v<typename _StridedLayoutMapping::extents_type, extents_type> &&
-        (__mdspan_detail::__is_mapping_of<layout_left, _StridedLayoutMapping> ||
-         __mdspan_detail::__is_mapping_of<layout_right, _StridedLayoutMapping> ||
-         __mdspan_detail::__is_mapping_of<layout_stride, _StridedLayoutMapping>)))
-      mapping(const _StridedLayoutMapping& __other) noexcept
-      : __extents_(__other.extents()), __strides_([&]<size_t... _Pos>(index_sequence<_Pos...>) {
-          // stride() only compiles for rank > 0
-          if constexpr (__rank_ > 0) {
-            return __mdspan_detail::__possibly_empty_array<index_type, __rank_>{
-                static_cast<index_type>(__other.stride(_Pos))...};
-          } else {
-            return __mdspan_detail::__possibly_empty_array<index_type, 0>{};
-          }
-        }(make_index_sequence<__rank_>())) {
-    // stride() only compiles for rank > 0
-    if constexpr (__rank_ > 0) {
-      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-          ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
-            return ((static_cast<index_type>(__other.stride(_Pos)) > static_cast<index_type>(0)) && ... && true);
-          }(make_index_sequence<__rank_>())),
-          "layout_stride::mapping converting ctor: all strides must be greater than 0");
-    }
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
-        "layout_stride::mapping converting ctor: other.required_span_size() must be representable as index_type.");
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(static_cast<index_type>(0) == __offset(__other),
-                                        "layout_stride::mapping converting ctor: base offset of mapping must be zero.");
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
-
-  // [mdspan.layout.stride.obs], observers
-  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr array<index_type, __rank_> strides() const noexcept {
-    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-      return array<index_type, __rank_>{__strides_[_Pos]...};
-    }(make_index_sequence<__rank_>());
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
-    if constexpr (__rank_ == 0) {
-      return static_cast<index_type>(1);
-    } else {
-      return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-        if ((__extents_.extent(_Pos) * ... * 1) == 0)
-          return static_cast<index_type>(0);
-
-        return static_cast<index_type>(
-            static_cast<index_type>(1) + (((__extents_.extent(_Pos) - static_cast<index_type>(1)) * __strides_[_Pos]) +
-                                          ... + static_cast<index_type>(0)));
-      }(make_index_sequence<__rank_>());
-    }
-  }
-
-  template <class... _Indices>
-    requires((sizeof...(_Indices) == __rank_) && (is_convertible_v<_Indices, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _Indices> && ...))
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
-    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
-    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
-    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
-    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
-    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
-                                 "layout_stride::mapping: out of bounds indexing");
-    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-      return ((static_cast<index_type>(__idx) * __strides_[_Pos]) + ... + index_type(0));
-    }(make_index_sequence<sizeof...(_Indices)>());
-  }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return false; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
-
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
-  // The answer of this function is fairly complex in the case where one or more
-  // extents are zero.
-  // Technically it is meaningless to query is_exhaustive() in that case, but unfortunately
-  // the way the standard defines this function, we can't give a simple true or false then.
-  _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const noexcept {
-    if constexpr (__rank_ == 0)
-      return true;
-    else {
-      index_type __span_size = required_span_size();
-      if (__span_size == static_cast<index_type>(0)) {
-        if constexpr (__rank_ == 1)
-          return __strides_[0] == 1;
-        else {
-          rank_type __r_largest = 0;
-          for (rank_type __r = 1; __r < __rank_; __r++)
-            if (__strides_[__r] > __strides_[__r_largest])
-              __r_largest = __r;
-          for (rank_type __r = 0; __r < __rank_; __r++)
-            if (__extents_.extent(__r) == 0 && __r != __r_largest)
-              return false;
-          return true;
-        }
-      } else {
-        return required_span_size() == [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-          return (__extents_.extent(_Pos) * ... * static_cast<index_type>(1));
-        }(make_index_sequence<__rank_>());
-      }
-    }
-  }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
-
-  // according to the standard layout_stride does not have a constraint on stride(r) for rank>0
-  // it still has the precondition though
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__r < __rank_, "layout_stride::mapping::stride(): invalid rank index");
-    return __strides_[__r];
-  }
-
-  template <class _OtherMapping>
-    requires(__mdspan_detail::__layout_mapping_alike<_OtherMapping> &&
-             (_OtherMapping::extents_type::rank() == __rank_) && _OtherMapping::is_always_strided())
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const mapping& __lhs, const _OtherMapping& __rhs) noexcept {
-    if (__offset(__rhs))
-      return false;
-    if constexpr (__rank_ == 0)
-      return true;
-    else {
-      return __lhs.extents() == __rhs.extents() && [&]<size_t... _Pos>(index_sequence<_Pos...>) {
-        // avoid warning when comparing signed and unsigner integers and pick the wider of two types
-        using _CommonType = common_type_t<index_type, typename _OtherMapping::index_type>;
-        return ((static_cast<_CommonType>(__lhs.stride(_Pos)) == static_cast<_CommonType>(__rhs.stride(_Pos))) && ... &&
-                true);
-      }(make_index_sequence<__rank_>());
-    }
-  }
-
-private:
-  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
-  _LIBCPP_NO_UNIQUE_ADDRESS __mdspan_detail::__possibly_empty_array<index_type, __rank_> __strides_{};
-};
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
diff --git a/third_party/libcxx/include/c++/v1/__mdspan/mdspan.h b/third_party/libcxx/include/c++/v1/__mdspan/mdspan.h
deleted file mode 100644
index 54685b5..0000000
--- a/third_party/libcxx/include/c++/v1/__mdspan/mdspan.h
+++ /dev/null
@@ -1,328 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___MDSPAN_MDSPAN_H
-#define _LIBCPP___MDSPAN_MDSPAN_H
-
-#include <__assert>
-#include <__config>
-#include <__fwd/mdspan.h>
-#include <__mdspan/aligned_accessor.h>
-#include <__mdspan/default_accessor.h>
-#include <__mdspan/extents.h>
-#include <__memory/addressof.h>
-#include <__type_traits/extent.h>
-#include <__type_traits/is_abstract.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_object.h>
-#include <__type_traits/is_pointer.h>
-#include <__type_traits/is_same.h>
-#include <__type_traits/rank.h>
-#include <__type_traits/remove_all_extents.h>
-#include <__type_traits/remove_cv.h>
-#include <__type_traits/remove_pointer.h>
-#include <__type_traits/remove_reference.h>
-#include <__utility/integer_sequence.h>
-#include <array>
-#include <span>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-
-// Helper for lightweight test checking that one did pass a layout policy as LayoutPolicy template argument
-namespace __mdspan_detail {
-template <class _Layout, class _Extents>
-concept __has_invalid_mapping = !requires { typename _Layout::template mapping<_Extents>; };
-} // namespace __mdspan_detail
-
-template <class _ElementType,
-          class _Extents,
-          class _LayoutPolicy   = layout_right,
-          class _AccessorPolicy = default_accessor<_ElementType> >
-class mdspan {
-private:
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
-                "mdspan: Extents template parameter must be a specialization of extents.");
-  static_assert(
-      is_object_v<_ElementType> && requires { sizeof(_ElementType); },
-      "mdspan: ElementType template parameter must be a complete object type");
-  static_assert(!is_array_v<_ElementType>, "mdspan: ElementType template parameter may not be an array type");
-  static_assert(!is_abstract_v<_ElementType>, "mdspan: ElementType template parameter may not be an abstract class");
-  static_assert(is_same_v<_ElementType, typename _AccessorPolicy::element_type>,
-                "mdspan: ElementType template parameter must match AccessorPolicy::element_type");
-  static_assert(!__mdspan_detail::__has_invalid_mapping<_LayoutPolicy, _Extents>,
-                "mdspan: LayoutPolicy template parameter is invalid. A common mistake is to pass a layout mapping "
-                "instead of a layout policy");
-
-public:
-  using extents_type     = _Extents;
-  using layout_type      = _LayoutPolicy;
-  using accessor_type    = _AccessorPolicy;
-  using mapping_type     = layout_type::template mapping<extents_type>;
-  using element_type     = _ElementType;
-  using value_type       = remove_cv_t<element_type>;
-  using index_type       = extents_type::index_type;
-  using size_type        = extents_type::size_type;
-  using rank_type        = extents_type::rank_type;
-  using data_handle_type = accessor_type::data_handle_type;
-  using reference        = accessor_type::reference;
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return extents_type::rank(); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept {
-    return extents_type::rank_dynamic();
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
-    return extents_type::static_extent(__r);
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
-    return __map_.extents().extent(__r);
-  }
-
-  //--------------------------------------------------------------------------------
-  // [mdspan.mdspan.cons], mdspan constructors, assignment, and destructor
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan()
-    requires((extents_type::rank_dynamic() > 0) && is_default_constructible_v<data_handle_type> &&
-             is_default_constructible_v<mapping_type> && is_default_constructible_v<accessor_type>)
-  = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(const mdspan&) = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(mdspan&&)      = default;
-
-  template <class... _OtherIndexTypes>
-    requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
-             ((sizeof...(_OtherIndexTypes) == rank()) || (sizeof...(_OtherIndexTypes) == rank_dynamic())) &&
-             is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>)
-  _LIBCPP_HIDE_FROM_ABI explicit constexpr mdspan(data_handle_type __p, _OtherIndexTypes... __exts)
-      : __ptr_(std::move(__p)), __map_(extents_type(static_cast<index_type>(std::move(__exts))...)), __acc_{} {}
-
-  template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
-             ((_Size == rank()) || (_Size == rank_dynamic())) && is_constructible_v<mapping_type, extents_type> &&
-             is_default_constructible_v<accessor_type>)
-  explicit(_Size != rank_dynamic())
-      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const array<_OtherIndexType, _Size>& __exts)
-      : __ptr_(std::move(__p)), __map_(extents_type(__exts)), __acc_{} {}
-
-  template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
-             ((_Size == rank()) || (_Size == rank_dynamic())) && is_constructible_v<mapping_type, extents_type> &&
-             is_default_constructible_v<accessor_type>)
-  explicit(_Size != rank_dynamic())
-      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, span<_OtherIndexType, _Size> __exts)
-      : __ptr_(std::move(__p)), __map_(extents_type(__exts)), __acc_{} {}
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const extents_type& __exts)
-    requires(is_default_constructible_v<accessor_type> && is_constructible_v<mapping_type, const extents_type&>)
-      : __ptr_(std::move(__p)), __map_(__exts), __acc_{} {}
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const mapping_type& __m)
-    requires(is_default_constructible_v<accessor_type>)
-      : __ptr_(std::move(__p)), __map_(__m), __acc_{} {}
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const mapping_type& __m, const accessor_type& __a)
-      : __ptr_(std::move(__p)), __map_(__m), __acc_(__a) {}
-
-  template <class _OtherElementType, class _OtherExtents, class _OtherLayoutPolicy, class _OtherAccessor>
-    requires(is_constructible_v<mapping_type, const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&> &&
-             is_constructible_v<accessor_type, const _OtherAccessor&>)
-  explicit(!is_convertible_v<const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&, mapping_type> ||
-           !is_convertible_v<const _OtherAccessor&, accessor_type>)
-      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(
-          const mdspan<_OtherElementType, _OtherExtents, _OtherLayoutPolicy, _OtherAccessor>& __other)
-      : __ptr_(__other.__ptr_), __map_(__other.__map_), __acc_(__other.__acc_) {
-    static_assert(is_constructible_v<data_handle_type, const typename _OtherAccessor::data_handle_type&>,
-                  "mdspan: incompatible data_handle_type for mdspan construction");
-    static_assert(
-        is_constructible_v<extents_type, _OtherExtents>, "mdspan: incompatible extents for mdspan construction");
-
-    // The following precondition is part of the standard, but is unlikely to be triggered.
-    // The extents constructor checks this and the mapping must be storing the extents, since
-    // its extents() function returns a const reference to extents_type.
-    // The only way this can be triggered is if the mapping conversion constructor would for example
-    // always construct its extents() only from the dynamic extents, instead of from the other extents.
-    if constexpr (rank() > 0) {
-      for (size_t __r = 0; __r < rank(); __r++) {
-        // Not catching this could lead to out of bounds errors later
-        // e.g. mdspan<int, dextents<char,1>, non_checking_layout> m =
-        //        mdspan<int, dextents<unsigned, 1>, non_checking_layout>(ptr, 200); leads to an extent of -56 on m
-        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
-            (static_extent(__r) == dynamic_extent) ||
-                (static_cast<index_type>(__other.extent(__r)) == static_cast<index_type>(static_extent(__r))),
-            "mdspan: conversion mismatch of source dynamic extents with static extents");
-      }
-    }
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan& operator=(const mdspan&) = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr mdspan& operator=(mdspan&&)      = default;
-
-  //--------------------------------------------------------------------------------
-  // [mdspan.mdspan.members], members
-
-  template <class... _OtherIndexTypes>
-    requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
-             (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
-             (sizeof...(_OtherIndexTypes) == rank()))
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](_OtherIndexTypes... __indices) const {
-    // Note the standard layouts would also check this, but user provided ones may not, so we
-    // check the precondition here
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__is_multidimensional_index_in(extents(), __indices...),
-                                        "mdspan: operator[] out of bounds access");
-    return __acc_.access(__ptr_, __map_(static_cast<index_type>(std::move(__indices))...));
-  }
-
-  template <class _OtherIndexType>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference
-  operator[](const array< _OtherIndexType, rank()>& __indices) const {
-    return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
-      return __map_(__indices[_Idxs]...);
-    }(make_index_sequence<rank()>()));
-  }
-
-  template <class _OtherIndexType>
-    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
-             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](span<_OtherIndexType, rank()> __indices) const {
-    return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
-      return __map_(__indices[_Idxs]...);
-    }(make_index_sequence<rank()>()));
-  }
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept {
-    // Could leave this as only checked in debug mode: semantically size() is never
-    // guaranteed to be related to any accessible range
-    _LIBCPP_ASSERT_UNCATEGORIZED(
-        false == ([&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
-          size_type __prod = 1;
-          return (__builtin_mul_overflow(__prod, extent(_Idxs), std::addressof(__prod)) || ... || false);
-        }(make_index_sequence<rank()>())),
-        "mdspan: size() is not representable as size_type");
-    return [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
-      return ((static_cast<size_type>(__map_.extents().extent(_Idxs))) * ... * size_type(1));
-    }(make_index_sequence<rank()>());
-  }
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept {
-    return [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
-      return (rank() > 0) && ((__map_.extents().extent(_Idxs) == index_type(0)) || ... || false);
-    }(make_index_sequence<rank()>());
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(mdspan& __x, mdspan& __y) noexcept {
-    swap(__x.__ptr_, __y.__ptr_);
-    swap(__x.__map_, __y.__map_);
-    swap(__x.__acc_, __y.__acc_);
-  }
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept {
-    return __map_.extents();
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const data_handle_type& data_handle() const noexcept { return __ptr_; }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const mapping_type& mapping() const noexcept { return __map_; }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const accessor_type& accessor() const noexcept { return __acc_; }
-
-  // per LWG-4021 "mdspan::is_always_meow() should be noexcept"
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept {
-    return mapping_type::is_always_unique();
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept {
-    return mapping_type::is_always_exhaustive();
-  }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept {
-    return mapping_type::is_always_strided();
-  }
-
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_unique() const { return __map_.is_unique(); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const { return __map_.is_exhaustive(); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_strided() const { return __map_.is_strided(); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const { return __map_.stride(__r); }
-
-private:
-  _LIBCPP_NO_UNIQUE_ADDRESS data_handle_type __ptr_{};
-  _LIBCPP_NO_UNIQUE_ADDRESS mapping_type __map_{};
-  _LIBCPP_NO_UNIQUE_ADDRESS accessor_type __acc_{};
-
-  template <class, class, class, class>
-  friend class mdspan;
-};
-
-#  if _LIBCPP_STD_VER >= 26
-template <class _ElementType, class... _OtherIndexTypes>
-  requires((is_convertible_v<_OtherIndexTypes, size_t> && ...) && (sizeof...(_OtherIndexTypes) > 0))
-explicit mdspan(_ElementType*, _OtherIndexTypes...)
-    -> mdspan<_ElementType, extents<size_t, __maybe_static_ext<_OtherIndexTypes>...>>;
-#  else
-template <class _ElementType, class... _OtherIndexTypes>
-  requires((is_convertible_v<_OtherIndexTypes, size_t> && ...) && (sizeof...(_OtherIndexTypes) > 0))
-explicit mdspan(_ElementType*, _OtherIndexTypes...)
-    -> mdspan<_ElementType, dextents<size_t, sizeof...(_OtherIndexTypes)>>;
-#  endif
-
-template <class _Pointer>
-  requires(is_pointer_v<remove_reference_t<_Pointer>>)
-mdspan(_Pointer&&) -> mdspan<remove_pointer_t<remove_reference_t<_Pointer>>, extents<size_t>>;
-
-template <class _CArray>
-  requires(is_array_v<_CArray> && (rank_v<_CArray> == 1))
-mdspan(_CArray&) -> mdspan<remove_all_extents_t<_CArray>, extents<size_t, extent_v<_CArray, 0>>>;
-
-template <class _ElementType, class _OtherIndexType, size_t _Size>
-mdspan(_ElementType*, const array<_OtherIndexType, _Size>&) -> mdspan<_ElementType, dextents<size_t, _Size>>;
-
-template <class _ElementType, class _OtherIndexType, size_t _Size>
-mdspan(_ElementType*, span<_OtherIndexType, _Size>) -> mdspan<_ElementType, dextents<size_t, _Size>>;
-
-// This one is necessary because all the constructors take `data_handle_type`s, not
-// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
-// seems to throw off automatic deduction guides.
-template <class _ElementType, class _OtherIndexType, size_t... _ExtentsPack>
-mdspan(_ElementType*, const extents<_OtherIndexType, _ExtentsPack...>&)
-    -> mdspan<_ElementType, extents<_OtherIndexType, _ExtentsPack...>>;
-
-template <class _ElementType, class _MappingType>
-mdspan(_ElementType*, const _MappingType&)
-    -> mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
-
-template <class _MappingType, class _AccessorType>
-mdspan(typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
-    -> mdspan<typename _AccessorType::element_type,
-              typename _MappingType::extents_type,
-              typename _MappingType::layout_type,
-              _AccessorType>;
-
-#endif // _LIBCPP_STD_VER >= 23
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP___MDSPAN_MDSPAN_H