Add files using upload-large-folder tool

.gitattributes

@@ -89,3 +89,4 @@ miniCUDA124/bin/nppidei64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nppitc64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvcc.exe filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nppist64_12.dll filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/bin/nppig64_12.dll filter=lfs diff=lfs merge=lfs -text

miniCUDA124/bin/nppig64_12.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d2f6940b8fa725b26b31aab185472a2b218e5563e01b2bcf020f6711ad43754
+size 39356416

miniCUDA124/include/cuda/std/detail/libcxx/include/__mdspan/standard_layout_static_array.h

@@ -0,0 +1,703 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP
+#define _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/compressed_pair.h"
+#include "../__mdspan/dynamic_extent.h"
+#include "../__mdspan/macros.h"
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#include "../__mdspan/no_unique_address.h"
+#endif
+#include "../__type_traits/enable_if.h"
+#include "../__utility/integer_sequence.h"
+#include "../array"
+#include "../cstddef"
+#include "../span"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+//==============================================================================
+
+struct __construct_psa_from_dynamic_exts_values_tag_t {};
+_LIBCUDACXX_CPO_ACCESSIBILITY __construct_psa_from_dynamic_exts_values_tag_t __construct_psa_from_dynamic_exts_values_tag;
+
+struct __construct_psa_from_all_exts_values_tag_t {};
+_LIBCUDACXX_CPO_ACCESSIBILITY __construct_psa_from_all_exts_values_tag_t __construct_psa_from_all_exts_values_tag;
+
+struct __construct_psa_from_all_exts_array_tag_t {};
+template <size_t _Np = 0>
+struct __construct_psa_from_dynamic_exts_array_tag_t {};
+
+//==============================================================================
+
+template <size_t _Ip, class _Tp> using __repeated_with_idxs = _Tp;
+
+//==============================================================================
+
+#if __MDSPAN_PRESERVE_STANDARD_LAYOUT
+
+/**
+ *  PSA = "partially static array"
+ *
+ * @tparam _Tp
+ * @tparam _ValsSeq
+ * @tparam __sentinal
+ */
+template <class _Tag, class _Tp, class _static_t, class _ValsSeq, _static_t __sentinal = static_cast<_static_t>(dynamic_extent),
+          class _IdxsSeq = _CUDA_VSTD::make_index_sequence<_ValsSeq::size()>>
+struct __standard_layout_psa;
+
+//==============================================================================
+// Static case
+template <class _Tag, class _Tp, class _static_t, _static_t __value, _static_t... __values_or_sentinals,
+          _static_t __sentinal, size_t _Idx, size_t... _Idxs>
+struct __standard_layout_psa<
+    _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __value, __values_or_sentinals...>,
+    __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idx, _Idxs...>>
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : private __no_unique_address_emulation<__standard_layout_psa<
+          _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>, __sentinal,
+          _CUDA_VSTD::integer_sequence<size_t, _Idxs...>>>
+#endif
+{
+
+  //--------------------------------------------------------------------------
+
+  using __next_t =
+      __standard_layout_psa<_Tag, _Tp, _static_t,
+                            _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>,
+                            __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>>;
+
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __next_t __next_;
+#else
+  using __base_t = __no_unique_address_emulation<__next_t>;
+#endif
+
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t &__next() noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    return __next_;
+#else
+    return this->__base_t::__ref();
+#endif
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    return __next_;
+#else
+    return this->__base_t::__ref();
+#endif
+  }
+
+  static constexpr auto __size = sizeof...(_Idxs) + 1;
+  static constexpr auto __size_dynamic = __next_t::__size_dynamic;
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept =
+      default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__standard_layout_psa() noexcept = default;
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __standard_layout_psa(
+      __construct_psa_from_all_exts_values_tag_t, _Tp const & /*__val*/,
+      __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __construct_psa_from_all_exts_values_tag, __vals...
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class... _Ts>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_values_tag_t,
+      _Ts const &... __vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __construct_psa_from_dynamic_exts_values_tag, __vals...
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      array<_Up, _Np> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t const & __tag,
+      array<_Up, _NStatic> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __tag, __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag,
+      array<_Up, _NDynamic> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __tag, __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      _CUDA_VSTD::span<_Up, _Np> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t const & __tag,
+      _CUDA_VSTD::span<_Up, _NStatic> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __tag, __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag,
+      _CUDA_VSTD::span<_Up, _NDynamic> const &__vals) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __tag, __vals
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  template <class _UTag, class _Up, class _static_U, class _UValsSeq, _static_U __u_sentinal,
+            class _IdxsSeq>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _IdxsSeq> const
+          &__rhs) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __next_{
+#else
+      : __base_t(__base_t{__next_t(
+#endif
+          __rhs.__next()
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+  { }
+
+  //--------------------------------------------------------------------------
+
+  // See https://godbolt.org/z/_KSDNX for a summary-by-example of why this is
+  // necessary. We're using inheritance here instead of an alias template
+  // because we have to deduce __values_or_sentinals in several places, and
+  // alias templates don't permit that in this context.
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr __standard_layout_psa const &__enable_psa_conversion() const
+      noexcept {
+    return *this;
+  }
+
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept {
+    return __next().template __get_n<_Ip>();
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, int> = 1>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept {
+    return __value;
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr void
+  __set_n(_Tp const &__rhs) noexcept {
+    __next().__set_value(__rhs);
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, int> = 1>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr void
+  __set_n(_Tp const &) noexcept {
+    // Don't assert here because that would break constexpr. This better
+    // not change anything, though
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, _static_t> = __sentinal>
+  __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
+    return __value;
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, _static_t> __default = __sentinal>
+  __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
+    return __next_t::template __get_static_n<_Ip, __default>();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t __n) const noexcept {
+    return __value * (_Tp(_Idx == __n)) + __next().__get(__n);
+  }
+
+  //--------------------------------------------------------------------------
+};
+
+//==============================================================================
+
+// Dynamic case, __next_t may or may not be empty
+template <class _Tag, class _Tp, class _static_t, _static_t __sentinal, _static_t... __values_or_sentinals,
+          size_t _Idx, size_t... _Idxs>
+struct __standard_layout_psa<
+    _Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __sentinal, __values_or_sentinals...>,
+    __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idx, _Idxs...>> {
+  //--------------------------------------------------------------------------
+
+  using __next_t =
+      __standard_layout_psa<_Tag, _Tp, _static_t,
+                            _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>,
+                            __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>>;
+
+  using __value_pair_t = __compressed_pair<_Tp, __next_t>;
+  __value_pair_t __value_pair;
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t &__next() noexcept {
+    return __value_pair.__second();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept {
+    return __value_pair.__second();
+  }
+
+  static constexpr auto __size = sizeof...(_Idxs) + 1;
+  static constexpr auto __size_dynamic = 1 + __next_t::__size_dynamic;
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept =
+      default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__standard_layout_psa() noexcept = default;
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __standard_layout_psa(
+      __construct_psa_from_all_exts_values_tag_t, _Tp const &__val,
+      __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept
+      : __value_pair(__val,
+                     __next_t(__construct_psa_from_all_exts_values_tag,
+                              __vals...)) {}
+
+  template <class... _Ts>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_values_tag_t, _Tp const &__val,
+      _Ts const &... __vals) noexcept
+      : __value_pair(__val,
+                     __next_t(__construct_psa_from_dynamic_exts_values_tag,
+                              __vals...)) {}
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      array<_Up, _Np> const &__vals) noexcept
+      : __value_pair(_CUDA_VSTD::get<_Idx>(__vals), __vals) {}
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t __tag,
+      array<_Up, _NStatic> const &__vals) noexcept
+      : __value_pair(
+            _CUDA_VSTD::get<_Idx>(__vals),
+            __next_t(__tag,
+                     __vals)) {}
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
+      array<_Up, _NDynamic> const &__vals) noexcept
+      : __value_pair(
+            _CUDA_VSTD::get<_IDynamic>(__vals),
+            __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{},
+                     __vals)) {}
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      _CUDA_VSTD::span<_Up, _Np> const &__vals) noexcept
+      : __value_pair(__vals[_Idx], __vals) {}
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t __tag,
+      _CUDA_VSTD::span<_Up, _NStatic> const &__vals) noexcept
+      : __value_pair(
+            __vals[_Idx],
+            __next_t(__tag,
+                     __vals)) {}
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
+      _CUDA_VSTD::span<_Up, _NDynamic> const &__vals) noexcept
+      : __value_pair(
+            __vals[_IDynamic],
+            __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{},
+                     __vals)) {}
+
+  template <class _UTag, class _Up, class _static_U, class _UValsSeq, _static_U __u_sentinal,
+            class _UIdxsSeq>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const
+          &__rhs) noexcept
+      : __value_pair(__rhs.template __get_n<_Idx>(), __rhs.__next()) {}
+
+  //--------------------------------------------------------------------------
+
+  // See comment in the previous partial specialization for why this is
+  // necessary.  Or just trust me that it's messy.
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr __standard_layout_psa const &__enable_psa_conversion() const
+      noexcept {
+    return *this;
+  }
+
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept {
+    return __next().template __get_n<_Ip>();
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, int> = 1>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept {
+    return __value_pair.__first();
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr void
+  __set_n(_Tp const &__rhs) noexcept {
+    __next().__set_value(__rhs);
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, int> = 1>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr void
+  __set_n(_Tp const &__rhs) noexcept {
+    __value_pair.__first() = __rhs;
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip == _Idx, _static_t> __default = __sentinal>
+  __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
+    return __default;
+  }
+  template <size_t _Ip, _CUDA_VSTD::enable_if_t<_Ip != _Idx, _static_t> __default = __sentinal>
+  __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
+    return __next_t::template __get_static_n<_Ip, __default>();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t __n) const noexcept {
+    return __value_pair.__first() * (_Tp(_Idx == __n)) + __next().__get(__n);
+  }
+
+  //--------------------------------------------------------------------------
+};
+
+// empty/terminal case
+template <class _Tag, class _Tp, class _static_t, _static_t __sentinal>
+struct __standard_layout_psa<_Tag, _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t>, __sentinal,
+                             _CUDA_VSTD::integer_sequence<size_t>> {
+  //--------------------------------------------------------------------------
+
+  static constexpr auto __size = 0;
+  static constexpr auto __size_dynamic = 0;
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
+  operator=(__standard_layout_psa &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__standard_layout_psa() noexcept = default;
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __standard_layout_psa(
+      __construct_psa_from_all_exts_values_tag_t) noexcept {}
+
+  template <class... _Ts>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_values_tag_t) noexcept {}
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      array<_Up, _Np> const &) noexcept {}
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t,
+      array<_Up, _NStatic> const &) noexcept {}
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
+      array<_Up, _NDynamic> const &) noexcept {}
+
+  template <class _Up, size_t _Np>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      _CUDA_VSTD::span<_Up, _Np> const &) noexcept {}
+
+  template <class _Up, size_t _NStatic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_all_exts_array_tag_t,
+      _CUDA_VSTD::span<_Up, _NStatic> const &) noexcept {}
+
+  template <class _Up, size_t _IDynamic, size_t _NDynamic>
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
+      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
+      _CUDA_VSTD::span<_Up, _NDynamic> const &) noexcept {}
+
+  template <class _UTag, class _Up, class _static_U, class _UValsSeq, _static_U __u_sentinal,
+            class _UIdxsSeq>
+  __MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
+      __standard_layout_psa<_UTag, _Up, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const&) noexcept {}
+
+  // See comment in the previous partial specialization for why this is
+  // necessary.  Or just trust me that it's messy.
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr __standard_layout_psa const &__enable_psa_conversion() const
+      noexcept {
+    return *this;
+  }
+
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get(size_t /*n*/) const noexcept {
+    return 0;
+  }
+};
+
+// Same thing, but with a disambiguator so that same-base issues doesn't cause
+// a loss of standard-layout-ness.
+template <class _Tag, class T, class _static_t, _static_t... __values_or_sentinals>
+struct __partially_static_sizes_tagged
+    : __standard_layout_psa<
+          _Tag, T, _static_t,
+          _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>> {
+  using __tag_t = _Tag;
+  using __psa_impl_t = __standard_layout_psa<
+      _Tag, T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>>;
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __psa_impl_t, _Args...), int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr
+  __partially_static_sizes_tagged(_Args&&... __args) noexcept(noexcept(__psa_impl_t(_CUDA_VSTD::declval<_Args>()...)))
+      : __psa_impl_t(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __psa_impl_t::__psa_impl_t;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
+  __MDSPAN_INLINE_FUNCTION
+#endif
+  constexpr __partially_static_sizes_tagged() noexcept
+#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
+    : __psa_impl_t() { }
+#else
+    = default;
+#endif
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __partially_static_sizes_tagged(
+      __partially_static_sizes_tagged const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __partially_static_sizes_tagged(
+      __partially_static_sizes_tagged &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged &
+  operator=(__partially_static_sizes_tagged const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged &
+  operator=(__partially_static_sizes_tagged &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__partially_static_sizes_tagged() noexcept = default;
+
+  template <class _UTag>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr explicit __partially_static_sizes_tagged(
+    __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...> const& __vals
+  ) noexcept : __psa_impl_t(__vals.__enable_psa_conversion()) { }
+};
+
+struct __no_tag {};
+template <class T, class _static_t, _static_t... __values_or_sentinals>
+struct __partially_static_sizes
+    : __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...> {
+private:
+  using __base_t =
+      __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...>;
+  template <class _UTag>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes(
+    __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>&& __vals
+  ) noexcept : __base_t(_CUDA_VSTD::move(__vals)) { }
+public:
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base_t, _Args...), int> = 0>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr
+  __partially_static_sizes(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...)))
+      : __base_t(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base_t::__base_t;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+#ifdef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __partially_static_sizes() noexcept : __base_t() { }
+#endif
+  template <class _UTag>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes_tagged<
+      _UTag, T, _static_t, __values_or_sentinals...>
+  __with_tag() const noexcept {
+    return __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>(*this);
+  }
+};
+
+#endif // __MDSPAN_PRESERVE_STATIC_LAYOUT
+
+} // end namespace __detail
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_STANDARD_LAYOUT_STATIC_ARRAY_HPP

miniCUDA124/include/cuda/std/detail/libcxx/include/__mdspan/static_array.h

@@ -0,0 +1,325 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP
+#define _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/span.h" // dynamic_extent
+#include "../__mdspan/dynamic_extent.h"
+#include "../__mdspan/macros.h"
+#include "../__mdspan/maybe_static_value.h"
+#include "../__mdspan/standard_layout_static_array.h"
+#include "../__mdspan/type_list.h"
+#include "../__utility/integer_sequence.h"
+#include "../array"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !__MDSPAN_PRESERVE_STANDARD_LAYOUT
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+//==============================================================================
+
+template <class _Tp, _Tp _Val, bool _Mask> struct __mask_element {};
+
+template <class _Tp, _Tp... _Result>
+struct __mask_sequence_assign_op {
+  template <_Tp _V>
+  __mask_sequence_assign_op<_Tp, _Result..., _V>
+  operator=(__mask_element<_Tp, _V, true>&&);
+  template <_Tp _V>
+  __mask_sequence_assign_op<_Tp, _Result...>
+  operator=(__mask_element<_Tp, _V, false>&&);
+  using __result = _CUDA_VSTD::integer_sequence<_Tp, _Result...>;
+};
+
+template <class _Seq, class _Mask>
+struct __mask_sequence;
+
+template <class _Tp, _Tp... _Vals, bool... _Masks>
+struct __mask_sequence<_CUDA_VSTD::integer_sequence<_Tp, _Vals...>, _CUDA_VSTD::integer_sequence<bool, _Masks...>>
+{
+  using type = typename decltype(
+    __MDSPAN_FOLD_ASSIGN_LEFT(
+      __mask_sequence_assign_op<_Tp>{}, /* = ... = */ __mask_element<_Tp, _Vals, _Masks>{}
+    )
+  )::__result;
+};
+
+//==============================================================================
+
+template <class _Tp, class _static_t, class _Vals, _static_t __sentinal,
+          class _Idxs, class _IdxsDynamic, class _IdxsDynamicIdxs>
+class __partially_static_array_impl;
+
+template <
+  class _Tp, class _static_t,
+  _static_t... __values_or_sentinals, _static_t __sentinal,
+  size_t... _Idxs,
+  size_t... _IdxsDynamic,
+  size_t... _IdxsDynamicIdxs
+>
+class __partially_static_array_impl<
+  _Tp,
+  _static_t,
+  _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>,
+  __sentinal,
+  _CUDA_VSTD::integer_sequence<size_t, _Idxs...>,
+  _CUDA_VSTD::integer_sequence<size_t, _IdxsDynamic...>,
+  _CUDA_VSTD::integer_sequence<size_t, _IdxsDynamicIdxs...>
+>
+    : private __maybe_static_value<_Tp, _static_t, __values_or_sentinals, __sentinal,
+                                   _Idxs>... {
+private:
+
+  template <size_t _Np>
+  using __base_n = typename __type_at<_Np,
+    __type_list<__maybe_static_value<_Tp, _static_t, __values_or_sentinals, __sentinal, _Idxs>...>
+  >::type;
+
+public:
+
+  static constexpr auto __size = sizeof...(_Idxs);
+  static constexpr auto __size_dynamic =
+    __MDSPAN_FOLD_PLUS_RIGHT(static_cast<int>((__values_or_sentinals == __sentinal)), /* + ... + */ 0);
+
+  //--------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __partially_static_array_impl() = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __partially_static_array_impl(
+      __partially_static_array_impl const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __partially_static_array_impl(
+      __partially_static_array_impl &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl &
+  operator=(__partially_static_array_impl const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl &
+  operator=(__partially_static_array_impl &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__partially_static_array_impl() noexcept = default;
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __partially_static_array_impl(
+      __construct_psa_from_all_exts_values_tag_t,
+      __repeated_with_idxs<_Idxs, _Tp> const &... __vals) noexcept
+      : __base_n<_Idxs>(__base_n<_Idxs>{{__vals}})... {}
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr __partially_static_array_impl(
+      __construct_psa_from_dynamic_exts_values_tag_t,
+      __repeated_with_idxs<_IdxsDynamicIdxs, _Tp> const &... __vals) noexcept
+      : __base_n<_IdxsDynamic>(__base_n<_IdxsDynamic>{{__vals}})... {}
+
+  __MDSPAN_INLINE_FUNCTION constexpr explicit __partially_static_array_impl(
+    _CUDA_VSTD::array<_Tp, sizeof...(_Idxs)> const& __vals) noexcept
+    : __partially_static_array_impl(
+        __construct_psa_from_all_exts_values_tag,
+        _CUDA_VSTD::get<_Idxs>(__vals)...) {}
+
+  // clang-format off
+  __MDSPAN_FUNCTION_REQUIRES(
+    (__MDSPAN_INLINE_FUNCTION constexpr explicit),
+    __partially_static_array_impl,
+    (_CUDA_VSTD::array<_Tp, __size_dynamic> const &__vals), noexcept,
+    /* requires */
+      (sizeof...(_Idxs) != __size_dynamic)
+  ): __partially_static_array_impl(
+       __construct_psa_from_dynamic_exts_values_tag,
+       _CUDA_VSTD::get<_IdxsDynamicIdxs>(__vals)...) {}
+  // clang-format on
+
+  template <class _Up, class _static_u, class _UValsSeq, _static_u __u_sentinal, class _UIdxsSeq,
+            class _UIdxsDynamicSeq, class _UIdxsDynamicIdxsSeq>
+  __MDSPAN_INLINE_FUNCTION constexpr __partially_static_array_impl(
+    __partially_static_array_impl<
+      _Up, _static_u, _UValsSeq, __u_sentinal, _UIdxsSeq,
+     _UIdxsDynamicSeq, _UIdxsDynamicIdxsSeq> const &__rhs) noexcept
+    : __partially_static_array_impl(
+        __construct_psa_from_all_exts_values_tag,
+        __rhs.template __get_n<_Idxs>()...) {}
+
+  //--------------------------------------------------------------------------
+
+  // See comment in the previous partial specialization for why this is
+  // necessary.  Or just trust me that it's messy.
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr __partially_static_array_impl const &__enable_psa_conversion() const
+  noexcept {
+      return *this;
+  }
+
+  template <size_t _Ip>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp __get_n() const noexcept {
+    return static_cast<__base_n<_Ip> const*>(this)->__value();
+  }
+
+  template <class _Up, size_t _Ip>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr void __set_n(_Up&& __rhs) noexcept {
+    static_cast<__base_n<_Ip>*>(this)->__set_value((_Up&&)__rhs);
+  }
+
+  template <size_t _Ip, _static_t __default = __sentinal>
+  __MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t
+  __get_static_n() noexcept {
+    return __base_n<_Ip>::__static_value == __sentinal ?
+      __default : __base_n<_Ip>::__static_value;
+  }
+
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp
+  __get(size_t __n) const noexcept {
+    return __MDSPAN_FOLD_PLUS_RIGHT(
+      (_Tp(_Idxs == __n) * __get_n<_Idxs>()), /* + ... + */ _Tp(0)
+    );
+  }
+
+};
+
+//==============================================================================
+
+template <class _Tp, class _static_t, class _ValSeq, _static_t __sentinal, class _Idxs = _CUDA_VSTD::make_index_sequence<_ValSeq::size()>>
+struct __partially_static_array_impl_maker;
+
+template <
+  class _Tp, class _static_t,  _static_t... _Vals, _static_t __sentinal, size_t... _Idxs
+>
+struct __partially_static_array_impl_maker<
+  _Tp, _static_t, _CUDA_VSTD::integer_sequence<_static_t, _Vals...>, __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>
+>
+{
+  using __dynamic_idxs = typename __mask_sequence<
+    _CUDA_VSTD::integer_sequence<size_t, _Idxs...>,
+    _CUDA_VSTD::integer_sequence<bool, (_Vals == __sentinal)...>
+  >::type;
+  using __impl_base =
+    __partially_static_array_impl<_Tp, _static_t,
+      _CUDA_VSTD::integer_sequence<_static_t, _Vals...>,
+      __sentinal, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>,
+      __dynamic_idxs,
+      _CUDA_VSTD::make_index_sequence<__dynamic_idxs::size()>
+    >;
+};
+
+template <class _Tp, class _static_t, class _ValsSeq, _static_t __sentinal = dynamic_extent>
+class __partially_static_array_with_sentinal
+  : public __partially_static_array_impl_maker<_Tp, _static_t, _ValsSeq, __sentinal>::__impl_base
+{
+private:
+  using __base_t = typename __partially_static_array_impl_maker<_Tp, _static_t, _ValsSeq, __sentinal>::__impl_base;
+public:
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+  constexpr __partially_static_array_with_sentinal() = default;
+
+  template<class... _Args>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr
+  __partially_static_array_with_sentinal(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...)))
+      : __base_t(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base_t::__base_t;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+};
+
+//==============================================================================
+
+template <class T, class _static_t, _static_t... __values_or_sentinals>
+struct __partially_static_sizes :
+  __partially_static_array_with_sentinal<
+    T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>>
+{
+private:
+  using __base_t = __partially_static_array_with_sentinal<
+    T, _static_t, _CUDA_VSTD::integer_sequence<_static_t, __values_or_sentinals...>>;
+public:
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+  constexpr __partially_static_sizes() = default;
+
+  template<class... _Args>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr
+  __partially_static_sizes(_Args&&... __args) noexcept(noexcept(__base_t(_CUDA_VSTD::declval<_Args>()...)))
+      : __base_t(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base_t::__base_t;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+  template <class _UTag>
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes<T, _static_t, __values_or_sentinals...>
+  __with_tag() const noexcept {
+    return *this;
+  }
+};
+
+// Tags are needed for the standard layout version, but not here
+template <class T, class _static_t, _static_t... __values_or_sentinals>
+using __partially_static_sizes_tagged = __partially_static_sizes<T, _static_t, __values_or_sentinals...>;
+
+} // end namespace __detail
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // !__MDSPAN_PRESERVE_STANDARD_LAYOUT
+
+#endif // _LIBCUDACXX___MDSPAN_STATIC_ARRAY_HPP

miniCUDA124/include/cuda/std/detail/libcxx/include/__mdspan/submdspan.h

@@ -0,0 +1,609 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+
+#ifndef _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP
+#define _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/dynamic_extent.h"
+#include "../__mdspan/full_extent_t.h"
+#include "../__mdspan/layout_left.h"
+#include "../__mdspan/layout_right.h"
+#include "../__mdspan/layout_stride.h"
+#include "../__mdspan/macros.h"
+#include "../__mdspan/mdspan.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_signed.h"
+#include "../__type_traits/remove_const.h"
+#include "../__type_traits/remove_reference.h"
+#include "../__utility/move.h"
+#include "../__utility/pair.h"
+#include "../tuple"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+template <size_t _OldExtent, size_t _OldStaticStride, class _Tp>
+struct __slice_wrap {
+  _Tp slice;
+  size_t old_extent;
+  size_t old_stride;
+};
+
+//--------------------------------------------------------------------------------
+
+template <size_t _OldExtent, size_t _OldStaticStride>
+__MDSPAN_INLINE_FUNCTION constexpr
+__slice_wrap<_OldExtent, _OldStaticStride, size_t>
+__wrap_slice(size_t __val, size_t __ext, size_t __stride) { return { __val, __ext, __stride }; }
+
+template <size_t _OldExtent, size_t _OldStaticStride, class _IntegerType, _IntegerType _Value0>
+__MDSPAN_INLINE_FUNCTION constexpr
+__slice_wrap<_OldExtent, _OldStaticStride, integral_constant<_IntegerType, _Value0>>
+__wrap_slice(size_t __val, size_t __ext, integral_constant<_IntegerType, _Value0> __stride)
+{
+#if __MDSPAN_HAS_CXX_17
+  if constexpr (_CUDA_VSTD::is_signed_v<_IntegerType>) {
+    static_assert(_Value0 >= _IntegerType(0), "Invalid slice specifier");
+  }
+#endif // __MDSPAN_HAS_CXX_17
+
+  return { __val, __ext, __stride };
+}
+
+template <size_t _OldExtent, size_t _OldStaticStride>
+__MDSPAN_INLINE_FUNCTION constexpr
+__slice_wrap<_OldExtent, _OldStaticStride, full_extent_t>
+__wrap_slice(full_extent_t __val, size_t __ext, size_t __stride) { return { __val, __ext, __stride }; }
+
+// TODO generalize this to anything that works with get<0> and get<1>
+template <size_t _OldExtent, size_t _OldStaticStride>
+__MDSPAN_INLINE_FUNCTION constexpr
+__slice_wrap<_OldExtent, _OldStaticStride, _CUDA_VSTD::tuple<size_t, size_t>>
+__wrap_slice(_CUDA_VSTD::tuple<size_t, size_t> const& __val, size_t __ext, size_t __stride)
+{
+  return { __val, __ext, __stride };
+}
+
+template <size_t _OldExtent, size_t _OldStaticStride,
+	  class _IntegerType0, _IntegerType0 _Value0,
+	  class _IntegerType1, _IntegerType1 _Value1>
+__MDSPAN_INLINE_FUNCTION constexpr
+  __slice_wrap<_OldExtent, _OldStaticStride,
+               _CUDA_VSTD::tuple<integral_constant<_IntegerType0, _Value0>,
+                          integral_constant<_IntegerType1, _Value1>>>
+__wrap_slice(_CUDA_VSTD::tuple<integral_constant<_IntegerType0, _Value0>, integral_constant<_IntegerType1, _Value1>> const& __val, size_t __ext, size_t __stride)
+{
+  static_assert(_Value1 >= _Value0, "Invalid slice tuple");
+  return { __val, __ext, __stride };
+}
+
+//--------------------------------------------------------------------------------
+
+
+// a layout right remains a layout right if it is indexed by 0 or more scalars,
+// then optionally a pair and finally 0 or more all
+template <
+  // what we encountered until now preserves the layout right
+  bool _Result=true,
+  // we only encountered 0 or more scalars, no pair or all
+  bool _EncounteredOnlyScalar=true
+>
+struct preserve_layout_right_analysis : integral_constant<bool, _Result> {
+  using layout_type_if_preserved = layout_right;
+  using encounter_pair = preserve_layout_right_analysis<
+    // if we encounter a pair, the layout remains a layout right only if it was one before
+    // and that only scalars were encountered until now
+    _Result && _EncounteredOnlyScalar,
+    // if we encounter a pair, we didn't encounter scalars only
+    false
+  >;
+  using encounter_all = preserve_layout_right_analysis<
+    // if we encounter a all, the layout remains a layout right if it was one before
+    _Result,
+    // if we encounter a all, we didn't encounter scalars only
+    false
+  >;
+  using encounter_scalar = preserve_layout_right_analysis<
+    // if we encounter a scalar, the layout remains a layout right only if it was one before
+    // and that only scalars were encountered until now
+    _Result && _EncounteredOnlyScalar,
+    // if we encounter a scalar, the fact that we encountered scalars only doesn't change
+    _EncounteredOnlyScalar
+  >;
+};
+
+// a layout left remains a layout left if it is indexed by 0 or more all,
+// then optionally a pair and finally 0 or more scalars
+template <
+  bool _Result=true,
+  bool _EncounteredOnlyAll=true
+>
+struct preserve_layout_left_analysis : integral_constant<bool, _Result> {
+  using layout_type_if_preserved = layout_left;
+  using encounter_pair = preserve_layout_left_analysis<
+    // if we encounter a pair, the layout remains a layout left only if it was one before
+    // and that only all were encountered until now
+    _Result && _EncounteredOnlyAll,
+    // if we encounter a pair, we didn't encounter all only
+    false
+  >;
+  using encounter_all = preserve_layout_left_analysis<
+    // if we encounter a all, the layout remains a layout left only if it was one before
+    // and that only all were encountered until now
+    _Result && _EncounteredOnlyAll,
+    // if we encounter a all, the fact that we encountered scalars all doesn't change
+    _EncounteredOnlyAll
+  >;
+  using encounter_scalar = preserve_layout_left_analysis<
+    // if we encounter a scalar, the layout remains a layout left if it was one before
+    _Result,
+    // if we encounter a scalar, we didn't encounter scalars only
+    false
+  >;
+};
+
+struct ignore_layout_preservation : integral_constant<bool, false> {
+  using layout_type_if_preserved = void;
+  using encounter_pair = ignore_layout_preservation;
+  using encounter_all = ignore_layout_preservation;
+  using encounter_scalar = ignore_layout_preservation;
+};
+
+template <class _Layout>
+struct preserve_layout_analysis
+  : ignore_layout_preservation { };
+template <>
+struct preserve_layout_analysis<layout_right>
+  : preserve_layout_right_analysis<> { };
+template <>
+struct preserve_layout_analysis<layout_left>
+  : preserve_layout_left_analysis<> { };
+
+//--------------------------------------------------------------------------------
+
+template <
+  class _IndexT,
+  class _PreserveLayoutAnalysis,
+  class _OffsetsArray=__partially_static_sizes<_IndexT, size_t>,
+  class _ExtsArray=__partially_static_sizes<_IndexT, size_t>,
+  class _StridesArray=__partially_static_sizes<_IndexT, size_t>,
+  class = _CUDA_VSTD::make_index_sequence<_OffsetsArray::__size>,
+  class = _CUDA_VSTD::make_index_sequence<_ExtsArray::__size>,
+  class = _CUDA_VSTD::make_index_sequence<_StridesArray::__size>
+>
+struct __assign_op_slice_handler;
+
+/* clang-format: off */
+template <
+  class _IndexT,
+  class _PreserveLayoutAnalysis,
+  size_t... _Offsets,
+  size_t... _Exts,
+  size_t... _Strides,
+  size_t... _OffsetIdxs,
+  size_t... _ExtIdxs,
+  size_t... _StrideIdxs>
+struct __assign_op_slice_handler<
+  _IndexT,
+  _PreserveLayoutAnalysis,
+  __partially_static_sizes<_IndexT, size_t, _Offsets...>,
+  __partially_static_sizes<_IndexT, size_t, _Exts...>,
+  __partially_static_sizes<_IndexT, size_t, _Strides...>,
+  _CUDA_VSTD::integer_sequence<size_t, _OffsetIdxs...>,
+  _CUDA_VSTD::integer_sequence<size_t, _ExtIdxs...>,
+  _CUDA_VSTD::integer_sequence<size_t, _StrideIdxs...>>
+{
+  // TODO remove this for better compiler performance
+  static_assert(
+    __MDSPAN_FOLD_AND((_Strides == dynamic_extent || _Strides > 0) /* && ... */),
+    " "
+  );
+  static_assert(
+    __MDSPAN_FOLD_AND((_Offsets == dynamic_extent || _Offsets >= 0) /* && ... */),
+    " "
+  );
+
+  using __offsets_storage_t = __partially_static_sizes<_IndexT, size_t, _Offsets...>;
+  using __extents_storage_t = __partially_static_sizes<_IndexT, size_t, _Exts...>;
+  using __strides_storage_t = __partially_static_sizes<_IndexT, size_t, _Strides...>;
+  __offsets_storage_t __offsets;
+  __extents_storage_t __exts;
+  __strides_storage_t __strides;
+
+#ifdef __INTEL_COMPILER
+#if __INTEL_COMPILER <= 1800
+  __MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler(__assign_op_slice_handler&& __other) noexcept
+    : __offsets(_CUDA_VSTD::move(__other.__offsets)), __exts(_CUDA_VSTD::move(__other.__exts)), __strides(_CUDA_VSTD::move(__other.__strides))
+  { }
+  __MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler(
+    __offsets_storage_t&& __o,
+    __extents_storage_t&& __e,
+    __strides_storage_t&& __s
+  ) noexcept
+    : __offsets(_CUDA_VSTD::move(__o)), __exts(_CUDA_VSTD::move(__e)), __strides(_CUDA_VSTD::move(__s))
+  { }
+#endif
+#endif
+
+// Don't define this unless we need it; they have a cost to compile
+#ifndef __MDSPAN_USE_RETURN_TYPE_DEDUCTION
+  using __extents_type = _CUDA_VSTD::extents<_IndexT, _Exts...>;
+#endif
+
+  // For size_t slice, skip the extent and stride, but add an offset corresponding to the value
+  template <size_t _OldStaticExtent, size_t _OldStaticStride>
+  __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
+  constexpr auto
+  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, size_t>&& __slice) noexcept
+    -> __assign_op_slice_handler<
+         _IndexT,
+         typename _PreserveLayoutAnalysis::encounter_scalar,
+         __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>,
+         __partially_static_sizes<_IndexT, size_t, _Exts...>,
+         __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> {
+    return {
+      __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>(
+        __construct_psa_from_all_exts_values_tag,
+        __offsets.template __get_n<_OffsetIdxs>()..., __slice.slice),
+      _CUDA_VSTD::move(__exts),
+      _CUDA_VSTD::move(__strides)
+    };
+  }
+
+  // Treat integral_constant slice like size_t slice, but with a compile-time offset.
+  // The result's extents_type can't take advantage of that,
+  // but it might help for specialized layouts.
+  template <size_t _OldStaticExtent, size_t _OldStaticStride, class _IntegerType, _IntegerType _Value0>
+  __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
+  constexpr auto
+  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, integral_constant<_IntegerType, _Value0>>&&) noexcept
+    -> __assign_op_slice_handler<
+         _IndexT,
+         typename _PreserveLayoutAnalysis::encounter_scalar,
+         __partially_static_sizes<_IndexT, size_t, _Offsets..., _Value0>,
+         __partially_static_sizes<_IndexT, size_t, _Exts...>,
+         __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> {
+#if __MDSPAN_HAS_CXX_17
+    if constexpr (_CUDA_VSTD::is_signed_v<_IntegerType>) {
+      static_assert(_Value0 >= _IntegerType(0), "Invalid slice specifier");
+    }
+#endif // __MDSPAN_HAS_CXX_17
+    return {
+      __partially_static_sizes<_IndexT, size_t, _Offsets..., _Value0>(
+        __construct_psa_from_all_exts_values_tag,
+        __offsets.template __get_n<_OffsetIdxs>()..., size_t(_Value0)),
+      _CUDA_VSTD::move(__exts),
+      _CUDA_VSTD::move(__strides)
+    };
+  }
+
+  // For a _CUDA_VSTD::full_extent, offset 0 and old extent
+  template <size_t _OldStaticExtent, size_t _OldStaticStride>
+  __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
+  constexpr auto
+  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, full_extent_t>&& __slice) noexcept
+    -> __assign_op_slice_handler<
+         _IndexT,
+         typename _PreserveLayoutAnalysis::encounter_all,
+         __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>,
+         __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>,
+         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
+    return {
+      __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>(
+        __construct_psa_from_all_exts_values_tag,
+        __offsets.template __get_n<_OffsetIdxs>()..., size_t(0)),
+      __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>(
+        __construct_psa_from_all_exts_values_tag,
+        __exts.template __get_n<_ExtIdxs>()..., __slice.old_extent),
+      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
+        __construct_psa_from_all_exts_values_tag,
+        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
+    };
+  }
+
+  // For a _CUDA_VSTD::tuple, add an offset and add a new dynamic extent (strides still preserved)
+  template <size_t _OldStaticExtent, size_t _OldStaticStride>
+  __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
+  constexpr auto
+  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple<size_t, size_t>>&& __slice) noexcept
+    -> __assign_op_slice_handler<
+         _IndexT,
+         typename _PreserveLayoutAnalysis::encounter_pair,
+         __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>,
+         __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>,
+         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
+    return {
+      __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>(
+        __construct_psa_from_all_exts_values_tag,
+        __offsets.template __get_n<_OffsetIdxs>()..., _CUDA_VSTD::get<0>(__slice.slice)),
+      __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>(
+        __construct_psa_from_all_exts_values_tag,
+        __exts.template __get_n<_ExtIdxs>()..., _CUDA_VSTD::get<1>(__slice.slice) - _CUDA_VSTD::get<0>(__slice.slice)),
+      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
+        __construct_psa_from_all_exts_values_tag,
+        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
+    };
+  }
+
+  // For a _CUDA_VSTD::tuple of two integral_constant, do something like
+  // we did above for a tuple of two size_t, but make sure the
+  // result's extents type make the values compile-time constants.
+  template <size_t _OldStaticExtent, size_t _OldStaticStride,
+	    class _IntegerType0, _IntegerType0 _Value0,
+	    class _IntegerType1, _IntegerType1 _Value1>
+  __MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
+  constexpr auto
+  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple<integral_constant<_IntegerType0, _Value0>, integral_constant<_IntegerType1, _Value1>>>&& __slice) noexcept
+    -> __assign_op_slice_handler<
+         _IndexT,
+         typename _PreserveLayoutAnalysis::encounter_pair,
+         __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(_Value0)>,
+         __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(_Value1 - _Value0)>,
+         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
+    static_assert(_Value1 >= _Value0, "Invalid slice specifier");
+    return {
+      // We're still turning the template parameters _Value0 and _Value1
+      // into (constexpr) run-time values here.
+      __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(_Value0) > (
+        __construct_psa_from_all_exts_values_tag,
+        __offsets.template __get_n<_OffsetIdxs>()..., _Value0),
+      __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(_Value1 - _Value0) > (
+        __construct_psa_from_all_exts_values_tag,
+        __exts.template __get_n<_ExtIdxs>()..., _Value1 - _Value0),
+      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
+        __construct_psa_from_all_exts_values_tag,
+        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
+    };
+  }
+
+   // TODO defer instantiation of this?
+  using layout_type = conditional_t<
+    _PreserveLayoutAnalysis::value,
+    typename _PreserveLayoutAnalysis::layout_type_if_preserved,
+    layout_stride
+  >;
+
+  // TODO noexcept specification
+  template <class NewLayout>
+  __MDSPAN_INLINE_FUNCTION
+  __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
+    (
+      constexpr /* auto */
+      _make_layout_mapping_impl(NewLayout) noexcept
+    ),
+    (
+      /* not layout stride, so don't pass dynamic_strides */
+      /* return */ typename NewLayout::template mapping<_CUDA_VSTD::extents<_IndexT, _Exts...>>(
+        extents<_IndexT, _Exts...>::__make_extents_impl(_CUDA_VSTD::move(__exts))
+      ) /* ; */
+    )
+  )
+
+  __MDSPAN_INLINE_FUNCTION
+  __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
+    (
+      constexpr /* auto */
+      _make_layout_mapping_impl(layout_stride) noexcept
+    ),
+    (
+      /* return */ layout_stride::template mapping<_CUDA_VSTD::extents<_IndexT, _Exts...>>
+        ::__make_mapping(_CUDA_VSTD::move(__exts), _CUDA_VSTD::move(__strides)) /* ; */
+    )
+  )
+
+  template <class _OldLayoutMapping> // mostly for deferred instantiation, but maybe we'll use this in the future
+  __MDSPAN_INLINE_FUNCTION
+  __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
+    (
+      constexpr /* auto */
+      make_layout_mapping(_OldLayoutMapping const&) noexcept
+    ),
+    (
+      /* return */ this->_make_layout_mapping_impl(layout_type{}) /* ; */
+    )
+  )
+};
+
+//==============================================================================
+
+#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION
+// Forking this because the C++11 version will be *completely* unreadable
+template <class _ET, class _ST, size_t... _Exts, class _LP, class _AP, class... _SliceSpecs, size_t... _Idxs>
+__MDSPAN_INLINE_FUNCTION
+constexpr auto _submdspan_impl(
+  _CUDA_VSTD::integer_sequence<size_t, _Idxs...>,
+  mdspan<_ET, _CUDA_VSTD::extents<_ST, _Exts...>, _LP, _AP> const& __src,
+  _SliceSpecs&&... __slices
+) noexcept
+{
+  using __index_t = _ST;
+  auto __handled =
+    __MDSPAN_FOLD_ASSIGN_LEFT(
+      (
+        __detail::__assign_op_slice_handler<
+          __index_t,
+          __detail::preserve_layout_analysis<_LP>
+        >{
+          __partially_static_sizes<__index_t, size_t>{},
+          __partially_static_sizes<__index_t, size_t>{},
+          __partially_static_sizes<__index_t, size_t>{}
+        }
+      ),
+        /* = ... = */
+      __detail::__wrap_slice<
+        _Exts, dynamic_extent
+      >(
+        __slices, __src.extents().template __extent<_Idxs>(),
+        __src.mapping().stride(_Idxs)
+      )
+    );
+
+  size_t __offset_size = __src.mapping()(__handled.__offsets.template __get_n<_Idxs>()...);
+  auto __offset_ptr = __src.accessor().offset(__src.data_handle(), __offset_size);
+  auto __map = __handled.make_layout_mapping(__src.mapping());
+  auto __acc_pol = typename _AP::offset_policy(__src.accessor());
+  return mdspan<
+    _ET, remove_const_t<_CUDA_VSTD::remove_reference_t<decltype(__map.extents())>>,
+        typename decltype(__handled)::layout_type, remove_const_t<_CUDA_VSTD::remove_reference_t<decltype(__acc_pol)>>
+  >(
+    _CUDA_VSTD::move(__offset_ptr), _CUDA_VSTD::move(__map), _CUDA_VSTD::move(__acc_pol)
+  );
+}
+#else
+
+template <class _ET, class _AP, class _Src, class _Handled, size_t... _Idxs>
+auto _submdspan_impl_helper(_Src&& __src, _Handled&& __h, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>)
+  -> mdspan<
+       _ET, typename _Handled::__extents_type, typename _Handled::layout_type, typename _AP::offset_policy
+     >
+{
+  return {
+    __src.accessor().offset(__src.data_handle(), __src.mapping()(__h.__offsets.template __get_n<_Idxs>()...)),
+    __h.make_layout_mapping(__src.mapping()),
+    typename _AP::offset_policy(__src.accessor())
+  };
+}
+
+template <class _ET, class _ST, size_t... _Exts, class _LP, class _AP, class... _SliceSpecs, size_t... _Idxs>
+__MDSPAN_INLINE_FUNCTION
+__MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
+  (
+    constexpr /* auto */ _submdspan_impl(
+      _CUDA_VSTD::integer_sequence<size_t, _Idxs...> __seq,
+      mdspan<_ET, _CUDA_VSTD::extents<_ST, _Exts...>, _LP, _AP> const& __src,
+      _SliceSpecs&&... __slices
+    ) noexcept
+  ),
+  (
+    /* return */ _submdspan_impl_helper<_ET, _AP>(
+      __src,
+      __MDSPAN_FOLD_ASSIGN_LEFT(
+        (
+          __detail::__assign_op_slice_handler<
+            size_t,
+            __detail::preserve_layout_analysis<_LP>
+          >{
+            __partially_static_sizes<_ST, size_t>{},
+            __partially_static_sizes<_ST, size_t>{},
+            __partially_static_sizes<_ST, size_t>{}
+          }
+        ),
+        /* = ... = */
+        __detail::__wrap_slice<
+          _Exts, dynamic_extent
+        >(
+          __slices, __src.extents().template __extent<_Idxs>(), __src.mapping().stride(_Idxs)
+        )
+      ),
+      __seq
+    ) /* ; */
+  )
+)
+
+#endif
+
+template <class _Tp> struct _is_layout_stride : false_type { };
+template<>
+struct _is_layout_stride<
+  layout_stride
+> : true_type
+{ };
+
+} // namespace __detail
+
+//==============================================================================
+
+__MDSPAN_TEMPLATE_REQUIRES(
+  class _ET, class _EXT, class _LP, class _AP, class... _SliceSpecs,
+  /* requires */ (
+    (
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, _LP, layout_left)
+        || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, _LP, layout_right)
+        || __detail::_is_layout_stride<_LP>::value
+    ) &&
+    __MDSPAN_FOLD_AND((
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, size_t)
+        || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, tuple<size_t, size_t>)
+        || _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _SliceSpecs, full_extent_t)
+    ) /* && ... */) &&
+    sizeof...(_SliceSpecs) == _EXT::rank()
+  )
+)
+__MDSPAN_INLINE_FUNCTION
+__MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
+  (
+    constexpr submdspan(
+      mdspan<_ET, _EXT, _LP, _AP> const& __src, _SliceSpecs... __slices
+    ) noexcept
+  ),
+  (
+    /* return */
+      __detail::_submdspan_impl(_CUDA_VSTD::make_index_sequence<sizeof...(_SliceSpecs)>{}, __src, __slices...) /*;*/
+  )
+)
+/* clang-format: on */
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_SUBMDSPAN_HPP

miniCUDA124/include/cuda/std/detail/libcxx/include/__mdspan/type_list.h

@@ -0,0 +1,137 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP
+#define _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/macros.h"
+#include "../__utility/integer_sequence.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+//==============================================================================
+
+namespace __detail {
+
+template <class... _Ts> struct __type_list { static constexpr auto __size = sizeof...(_Ts); };
+
+// Implementation of type_list at() that's heavily optimized for small typelists
+template <size_t, class> struct __type_at;
+template <size_t, class _Seq, class=_CUDA_VSTD::make_index_sequence<_Seq::__size>> struct __type_at_large_impl;
+
+template <size_t _Ip, size_t _Idx, class _Tp>
+struct __type_at_entry { };
+
+template <class _Result>
+struct __type_at_assign_op_ignore_rest {
+  template <class _Tp>
+  _LIBCUDACXX_HOST_DEVICE
+  __type_at_assign_op_ignore_rest<_Result> operator=(_Tp&&);
+  using type = _Result;
+};
+
+struct __type_at_assign_op_impl {
+  template <size_t _Ip, size_t _Idx, class _Tp>
+  _LIBCUDACXX_HOST_DEVICE
+  __type_at_assign_op_impl operator=(__type_at_entry<_Ip, _Idx, _Tp>&&);
+  template <size_t _Ip, class _Tp>
+  _LIBCUDACXX_HOST_DEVICE
+  __type_at_assign_op_ignore_rest<_Tp> operator=(__type_at_entry<_Ip, _Ip, _Tp>&&);
+};
+
+template <size_t _Ip, class... _Ts, size_t... _Idxs>
+struct __type_at_large_impl<_Ip, __type_list<_Ts...>, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>>
+  : decltype(
+      __MDSPAN_FOLD_ASSIGN_LEFT(__type_at_assign_op_impl{}, /* = ... = */ __type_at_entry<_Ip, _Idxs, _Ts>{})
+    )
+{ };
+
+template <size_t _Ip, class... _Ts>
+struct __type_at<_Ip, __type_list<_Ts...>>
+    : __type_at_large_impl<_Ip, __type_list<_Ts...>>
+{ };
+
+template <class _T0, class... _Ts>
+struct __type_at<0, __type_list<_T0, _Ts...>> {
+  using type = _T0;
+};
+
+template <class _T0, class _T1, class... _Ts>
+struct __type_at<1, __type_list<_T0, _T1, _Ts...>> {
+  using type = _T1;
+};
+
+template <class _T0, class _T1, class _T2, class... _Ts>
+struct __type_at<2, __type_list<_T0, _T1, _T2, _Ts...>> {
+  using type = _T2;
+};
+
+template <class _T0, class _T1, class _T2, class _T3, class... _Ts>
+struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> {
+  using type = _T3;
+};
+
+
+} // namespace __detail
+
+//==============================================================================
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_TYPE_LIST_HPP

miniCUDA124/include/cuda/std/detail/libcxx/include/__memory/addressof.h

@@ -0,0 +1,98 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ADDRESSOF_H
+#define _LIBCUDACXX___MEMORY_ADDRESSOF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// addressof
+// NVCXX has the builtin defined but did not mark it as supported
+#if defined(_LIBCUDACXX_ADDRESSOF)
+
+template <class _Tp>
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+_LIBCUDACXX_NO_CFI _LIBCUDACXX_INLINE_VISIBILITY
+_Tp*
+addressof(_Tp& __x) noexcept
+{
+    return __builtin_addressof(__x);
+}
+
+#else
+
+template <class _Tp>
+inline _LIBCUDACXX_NO_CFI _LIBCUDACXX_INLINE_VISIBILITY
+_Tp*
+addressof(_Tp& __x) noexcept
+{
+  return reinterpret_cast<_Tp *>(
+      const_cast<char *>(&reinterpret_cast<const volatile char &>(__x)));
+}
+
+#endif // defined(_LIBCUDACXX_ADDRESSOF)
+
+#if defined(_LIBCUDACXX_HAS_OBJC_ARC) && !defined(_LIBCUDACXX_PREDEFINED_OBJC_ARC_ADDRESSOF)
+// Objective-C++ Automatic Reference Counting uses qualified pointers
+// that require special addressof() signatures. When
+// _LIBCUDACXX_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
+// itself is providing these definitions. Otherwise, we provide them.
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__strong _Tp*
+addressof(__strong _Tp& __x) noexcept
+{
+  return &__x;
+}
+
+#ifdef _LIBCUDACXX_HAS_OBJC_ARC_WEAK
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__weak _Tp*
+addressof(__weak _Tp& __x) noexcept
+{
+  return &__x;
+}
+#endif
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__autoreleasing _Tp*
+addressof(__autoreleasing _Tp& __x) noexcept
+{
+  return &__x;
+}
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__unsafe_unretained _Tp*
+addressof(__unsafe_unretained _Tp& __x) noexcept
+{
+  return &__x;
+}
+#endif
+
+template <class _Tp> _Tp* addressof(const _Tp&&) noexcept = delete;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ADDRESSOF_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__memory/construct_at.h

@@ -0,0 +1,275 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H
+#define _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif //__cuda_std__
+
+#include "../__assert"
+#include "../__concepts/__concept_macros.h"
+#include "../__iterator/access.h"
+#include "../__memory/addressof.h"
+#include "../__memory/voidify.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_arithmetic.h"
+#include "../__type_traits/is_array.h"
+#include "../__type_traits/is_constant_evaluated.h"
+#include "../__type_traits/is_trivially_move_assignable.h"
+#include "../__type_traits/is_trivially_constructible.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#ifdef _LIBCUDACXX_COMPILER_CLANG_CUDA
+#  include <new>
+#endif // _LIBCUDACXX_COMPILER_CLANG_CUDA
+
+#if defined(__cuda_std__) && _LIBCUDACXX_STD_VER > 17 // need to backfill ::std::construct_at
+#  ifndef _LIBCUDACXX_COMPILER_NVRTC
+#    include <memory>
+#  endif // _LIBCUDACXX_COMPILER_NVRTC
+
+#  ifndef __cpp_lib_constexpr_dynamic_alloc
+namespace std
+{
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args)
+{
+#    if defined(_LIBCUDACXX_ADDRESSOF)
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#    else
+  return ::new (const_cast<void*>(static_cast<const volatile void*>(__location)))
+    _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#    endif
+}
+} // namespace std
+#  endif // __cpp_lib_constexpr_dynamic_alloc
+#endif // __cuda_std__ && _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// There is a performance issue with placement new, where EDG based compiler insert a nullptr check that is superfluous
+// Because this is a noticable performance regression, we specialize it for certain types
+// This is possible because we are calling ::new ignoring any user defined overloads of operator placement new
+namespace __detail
+{
+// We cannot allow narrowing conversions between arithmetic types as the assignment will give errors
+template <class _To, class...>
+struct __is_narrowing_impl : false_type
+{};
+
+template <class _To, class _From>
+struct __is_narrowing_impl<_To, _From> : true_type
+{};
+
+// This is a bit hacky, but we rely on the fact that arithmetic types cannot have more than one argument to their constructor
+template <class _To, class _From>
+struct __is_narrowing_impl<_To, _From, __void_t<decltype(_To{_CUDA_VSTD::declval<_From>()})>> : false_type
+{};
+
+template <class _Tp, class... _Args>
+using __is_narrowing = _If<_LIBCUDACXX_TRAIT(is_arithmetic, _Tp), __is_narrowing_impl<_Tp, _Args...>, false_type>;
+
+// The destination type must be trivially constructible from the arguments and also trivially assignable, because we
+// technically move assign in the optimization
+template <class _Tp, class... _Args>
+struct __can_optimize_construct_at
+    : integral_constant<bool,
+                        _LIBCUDACXX_TRAIT(is_trivially_constructible, _Tp, _Args...)
+                          && _LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp)
+                          && !__is_narrowing<_Tp, _Args...>::value>
+{};
+} // namespace __detail
+
+// construct_at
+#if _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_DISABLE_EXEC_CHECK
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 __enable_if_t<!__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+  construct_at(_Tp* __location, _Args&&... __args)
+{
+  _LIBCUDACXX_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#  if defined(__cuda_std__)
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (__libcpp_is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+#  endif // __cuda_std__
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+_LIBCUDACXX_DISABLE_EXEC_CHECK
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 __enable_if_t<__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+  construct_at(_Tp* __location, _Args&&... __args)
+{
+  _LIBCUDACXX_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#  if defined(__cuda_std__)
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (__libcpp_is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+  *__location = _Tp{_CUDA_VSTD::forward<_Args>(__args)...};
+  return __location;
+#  else // ^^^ __cuda_std__ ^^^ / vvv !__cuda_std__ vvv
+  // NVCC always considers construction + move assignment, other compilers are smarter using copy construction
+  // So rather than adding all kinds of workarounds simply fall back to the correct implementation for libcxx mode
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#  endif // !__cuda_std__
+}
+
+#endif // _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_DISABLE_EXEC_CHECK
+template <class _Tp, class... _Args>
+_LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 __enable_if_t<!__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+  __construct_at(_Tp* __location, _Args&&... __args)
+{
+  _LIBCUDACXX_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#if defined(__cuda_std__) && _LIBCUDACXX_STD_VER > 17
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (__libcpp_is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+#endif // __cuda_std__ && _LIBCUDACXX_STD_VER > 17
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+_LIBCUDACXX_DISABLE_EXEC_CHECK
+template <class _Tp, class... _Args>
+_LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 __enable_if_t<__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+  __construct_at(_Tp* __location, _Args&&... __args)
+{
+  _LIBCUDACXX_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#if defined(__cuda_std__) && _LIBCUDACXX_STD_VER > 17
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (__libcpp_is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+#endif // __cuda_std__ && _LIBCUDACXX_STD_VER > 17
+  *__location = _Tp{_CUDA_VSTD::forward<_Args>(__args)...};
+  return __location;
+}
+
+// destroy_at
+
+// The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
+// taking an array).
+template <class _ForwardIterator>
+_LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
+
+template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void __destroy_at(_Tp* __loc)
+{
+  _LIBCUDACXX_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  __loc->~_Tp();
+}
+
+#if _LIBCUDACXX_STD_VER > 17
+template <class _Tp, __enable_if_t<is_array<_Tp>::value, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void __destroy_at(_Tp* __loc)
+{
+  _LIBCUDACXX_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  _CUDA_VSTD::__destroy(_CUDA_VSTD::begin(*__loc), _CUDA_VSTD::end(*__loc));
+}
+#endif
+
+template <class _ForwardIterator>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+__destroy(_ForwardIterator __first, _ForwardIterator __last)
+{
+  for (; __first != __last; ++__first)
+  {
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__first));
+  }
+  return __first;
+}
+
+template <class _BidirectionalIterator>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator
+__reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last)
+{
+  while (__last != __first)
+  {
+    --__last;
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__last));
+  }
+  return __last;
+}
+
+#if _LIBCUDACXX_STD_VER > 14
+
+template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void destroy_at(_Tp* __loc)
+{
+  _LIBCUDACXX_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  __loc->~_Tp();
+}
+
+#  if _LIBCUDACXX_STD_VER > 17
+template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void destroy_at(_Tp* __loc)
+{
+  _CUDA_VSTD::__destroy_at(__loc);
+}
+#  endif // _LIBCUDACXX_STD_VER > 17
+
+template <class _ForwardIterator>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void
+destroy(_ForwardIterator __first, _ForwardIterator __last)
+{
+  (void) _CUDA_VSTD::__destroy(_CUDA_VSTD::move(__first), _CUDA_VSTD::move(__last));
+}
+
+template <class _ForwardIterator, class _Size>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+destroy_n(_ForwardIterator __first, _Size __n)
+{
+  for (; __n > 0; (void) ++__first, --__n)
+  {
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__first));
+  }
+  return __first;
+}
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__memory/pointer_traits.h

@@ -0,0 +1,347 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_POINTER_TRAITS_H
+#define _LIBCUDACXX___MEMORY_POINTER_TRAITS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__memory/addressof.h"
+#include "../__type_traits/conjunction.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_class.h"
+#include "../__type_traits/is_function.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class = void>
+struct __has_element_type : false_type {};
+
+template <class _Tp>
+struct __has_element_type<_Tp,
+              __void_t<typename _Tp::element_type>> : true_type {};
+
+template <class _Ptr, bool = __has_element_type<_Ptr>::value>
+struct __pointer_traits_element_type;
+
+template <class _Ptr>
+struct __pointer_traits_element_type<_Ptr, true>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename _Ptr::element_type type;
+};
+
+#ifndef _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <template <class, class...> class _Sp, class _Tp, class ..._Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::element_type type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class ..._Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE _Tp type;
+};
+
+#else  // _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <template <class> class _Sp, class _Tp>
+struct __pointer_traits_element_type<_Sp<_Tp>, true>
+{
+    typedef typename _Sp<_Tp>::element_type type;
+};
+
+template <template <class> class _Sp, class _Tp>
+struct __pointer_traits_element_type<_Sp<_Tp>, false>
+{
+    typedef _Tp type;
+};
+
+template <template <class, class> class _Sp, class _Tp, class _A0>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true>
+{
+    typedef typename _Sp<_Tp, _A0>::element_type type;
+};
+
+template <template <class, class> class _Sp, class _Tp, class _A0>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false>
+{
+    typedef _Tp type;
+};
+
+template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true>
+{
+    typedef typename _Sp<_Tp, _A0, _A1>::element_type type;
+};
+
+template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false>
+{
+    typedef _Tp type;
+};
+
+template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
+                                                           class _A1, class _A2>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true>
+{
+    typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type;
+};
+
+template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
+                                                           class _A1, class _A2>
+struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false>
+{
+    typedef _Tp type;
+};
+
+#endif  // _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <class _Tp, class = void>
+struct __has_difference_type : false_type {};
+
+template <class _Tp>
+struct __has_difference_type<_Tp,
+            __void_t<typename _Tp::difference_type>> : true_type {};
+
+template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
+struct __pointer_traits_difference_type
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE ptrdiff_t type;
+};
+
+template <class _Ptr>
+struct __pointer_traits_difference_type<_Ptr, true>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename _Ptr::difference_type type;
+};
+
+template <class _Tp, class _Up>
+struct __has_rebind
+{
+private:
+    template <class _Xp> _LIBCUDACXX_INLINE_VISIBILITY static false_type __test(...);
+    _LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+    template <class _Xp> _LIBCUDACXX_INLINE_VISIBILITY static true_type __test(typename _Xp::template rebind<_Up>* = 0);
+    _LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+public:
+    static const bool value = decltype(__test<_Tp>(0))::value;
+};
+
+template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
+struct __pointer_traits_rebind
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename _Tp::template rebind<_Up> type;
+};
+
+#ifndef _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
+{
+    typedef _Sp<_Up, _Args...> type;
+};
+
+#else  // _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <template <class> class _Sp, class _Tp, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true>
+{
+    typedef typename _Sp<_Tp>::template rebind<_Up> type;
+};
+
+template <template <class> class _Sp, class _Tp, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false>
+{
+    typedef _Sp<_Up> type;
+};
+
+template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true>
+{
+    typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type;
+};
+
+template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false>
+{
+    typedef _Sp<_Up, _A0> type;
+};
+
+template <template <class, class, class> class _Sp, class _Tp, class _A0,
+                                         class _A1, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true>
+{
+    typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type;
+};
+
+template <template <class, class, class> class _Sp, class _Tp, class _A0,
+                                         class _A1, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false>
+{
+    typedef _Sp<_Up, _A0, _A1> type;
+};
+
+template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
+                                                class _A1, class _A2, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true>
+{
+    typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type;
+};
+
+template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
+                                                class _A1, class _A2, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
+{
+    typedef _Sp<_Up, _A0, _A1, _A2> type;
+};
+
+#endif  // _LIBCUDACXX_HAS_NO_VARIADICS
+
+template <class _Ptr>
+struct _LIBCUDACXX_TEMPLATE_VIS pointer_traits
+{
+    typedef _Ptr                                                     pointer;
+    typedef typename __pointer_traits_element_type<pointer>::type    element_type;
+    typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
+
+    template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
+
+private:
+    struct __nat {};
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r)
+        {return pointer::pointer_to(__r);}
+};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS pointer_traits<_Tp*>
+{
+    typedef _Tp*      pointer;
+    typedef _Tp       element_type;
+    typedef ptrdiff_t difference_type;
+
+    template <class _Up> using rebind = _Up*;
+
+private:
+    struct __nat {};
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) noexcept
+        {return _CUDA_VSTD::addressof(__r);}
+};
+
+template <class _From, class _To>
+struct __rebind_pointer {
+    typedef typename pointer_traits<_From>::template rebind<_To>        type;
+};
+
+// to_address
+
+template <class _Pointer, class = void>
+struct __to_address_helper;
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+_Tp* __to_address(_Tp* __p) noexcept {
+    static_assert(!is_function<_Tp>::value, "_Tp is a function type");
+    return __p;
+}
+
+template <class _Pointer, class = void>
+struct _HasToAddress : false_type {};
+
+template <class _Pointer>
+struct _HasToAddress<_Pointer,
+    decltype((void)pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))
+> : true_type {};
+
+template <class _Pointer, class = void>
+struct _HasArrow : false_type {};
+
+template <class _Pointer>
+struct _HasArrow<_Pointer,
+    decltype((void)declval<const _Pointer&>().operator->())
+> : true_type {};
+
+template <class _Pointer>
+struct _IsFancyPointer {
+  static const bool value = _HasArrow<_Pointer>::value || _HasToAddress<_Pointer>::value;
+};
+
+// enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
+template <class _Pointer, class = __enable_if_t<
+    _And<is_class<_Pointer>, _IsFancyPointer<_Pointer> >::value
+> >
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+__decay_t<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>
+__to_address(const _Pointer& __p) noexcept {
+    return __to_address_helper<_Pointer>::__call(__p);
+}
+
+template <class _Pointer, class>
+struct __to_address_helper {
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    static decltype(_CUDA_VSTD::__to_address(declval<const _Pointer&>().operator->()))
+    __call(const _Pointer& __p) noexcept {
+        return _CUDA_VSTD::__to_address(__p.operator->());
+    }
+};
+
+template <class _Pointer>
+struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))> {
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))
+    __call(const _Pointer& __p) noexcept {
+        return pointer_traits<_Pointer>::to_address(__p);
+    }
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY constexpr
+auto to_address(_Tp *__p) noexcept {
+    return _CUDA_VSTD::__to_address(__p);
+}
+
+template <class _Pointer>
+inline _LIBCUDACXX_INLINE_VISIBILITY constexpr
+auto to_address(const _Pointer& __p) noexcept -> decltype(_CUDA_VSTD::__to_address(__p)) {
+    return _CUDA_VSTD::__to_address(__p);
+}
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_POINTER_TRAITS_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__memory/voidify.h

@@ -0,0 +1,38 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_VOIDIFY_H
+#define _LIBCUDACXX___MEMORY_VOIDIFY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__memory/addressof.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <typename _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void* __voidify(_Tp& __from) {
+  // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
+  return const_cast<void*>(static_cast<const volatile void*>(_CUDA_VSTD::addressof(__from)));
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_VOIDIFY_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/apply_cv.h

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_APPLY_CV_H
+#define _LIBCUDACXX___TUPLE_APPLY_CV_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_const.h"
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/is_volatile.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
+struct __apply_cv_mf;
+template <>
+struct __apply_cv_mf<false, false, false>
+{
+  template <class _Tp>
+  using __apply = _Tp;
+};
+template <>
+struct __apply_cv_mf<false, true, false>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = const _Tp;
+};
+template <>
+struct __apply_cv_mf<false, false, true>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = volatile _Tp;
+};
+template <>
+struct __apply_cv_mf<false, true, true>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = const volatile _Tp;
+};
+template <>
+struct __apply_cv_mf<true, false, false>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, true, false>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = const _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, false, true>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = volatile _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, true, true>
+{
+  template <class _Tp>
+  using __apply _LIBCUDACXX_NODEBUG_TYPE = const volatile _Tp&;
+};
+template <class _Tp, class _RawTp = __libcpp_remove_reference_t<_Tp> >
+using __apply_cv_t _LIBCUDACXX_NODEBUG_TYPE =
+    __apply_cv_mf<_LIBCUDACXX_TRAIT(is_lvalue_reference, _Tp),
+                  _LIBCUDACXX_TRAIT(is_const, _RawTp),
+                  _LIBCUDACXX_TRAIT(is_volatile, _RawTp)>;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_APPLY_CV_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/make_tuple_types.h

@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_MAKE_TUPLE_TYPES_H
+#define _LIBCUDACXX___TUPLE_MAKE_TUPLE_TYPES_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/array.h"
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/apply_cv.h"
+#include "../__tuple_dir/tuple_element.h"
+#include "../__tuple_dir/tuple_indices.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__tuple_dir/tuple_types.h"
+#include "../__type_traits/remove_cv.h"
+#include "../__type_traits/remove_reference.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
+// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
+// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>.  If _Tuple is a
+// lvalue_reference type, then __tuple_types<_Types&...> is the result.
+
+template <class _TupleTypes, class _TupleIndices>
+struct __make_tuple_types_flat;
+
+template <template <class...> class _Tuple, class... _Types, size_t... _Idx>
+struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>>
+{
+  // Specialization for pair, tuple, and __tuple_types
+  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
+  using __apply_quals _LIBCUDACXX_NODEBUG_TYPE =
+      __tuple_types< typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>... >;
+};
+
+template <class _Vt, size_t _Np, size_t... _Idx>
+struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>>
+{
+  template <size_t>
+  using __value_type = _Vt;
+  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
+  using __apply_quals = __tuple_types< typename _ApplyFn::template __apply<__value_type<_Idx>>... >;
+};
+
+template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp>>::value, size_t _Sp = 0,
+    bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp>>::value)>
+struct __make_tuple_types
+{
+  static_assert(_Sp <= _Ep, "__make_tuple_types input error");
+  using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp>>;
+  using _Maker = __make_tuple_types_flat<_RawTp, __make_tuple_indices_t<_Ep, _Sp>>;
+  using type   = typename _Maker::template __apply_quals<_Tp>;
+};
+
+template <class... _Types, size_t _Ep>
+struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE __tuple_types<_Types...> type;
+};
+
+template <class... _Types, size_t _Ep>
+struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE __tuple_types<_Types...> type;
+};
+
+template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp>>::value, size_t _Sp = 0>
+using __make_tuple_types_t = typename __make_tuple_types<_Tp, _Ep, _Sp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_MAKE_TUPLE_TYPES_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/sfinae_helpers.h

@@ -0,0 +1,211 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_SFINAE_HELPERS_H
+#define _LIBCUDACXX___TUPLE_SFINAE_HELPERS_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/make_tuple_types.h"
+#include "../__tuple_dir/tuple_element.h"
+#include "../__tuple_dir/tuple_like.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__tuple_dir/tuple_types.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_assignable.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__type_traits/remove_reference.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool... _Preds>
+struct __all_dummy;
+
+template <bool... _Pred>
+using __all = _IsSame<__all_dummy<_Pred...>, __all_dummy<((void) _Pred, true)...>>;
+
+struct __tuple_sfinae_base
+{
+  template <class, class>
+  struct __test_size : false_type
+  {};
+
+  template <class... _Tp, class... _Up>
+  struct __test_size<__tuple_types<_Tp...>, __tuple_types<_Up...>> : _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>
+  {};
+
+  template <template <class, class...> class, class _Tp, class _Up, bool = __test_size<_Tp, _Up>::value>
+  struct __test : false_type
+  {};
+
+  template <template <class, class...> class _Trait, class... _LArgs, class... _RArgs>
+  struct __test<_Trait, __tuple_types<_LArgs...>, __tuple_types<_RArgs...>, true>
+      : __all<_Trait<_LArgs, _RArgs>::value...>
+  {};
+
+  template <class _FromArgs, class _ToArgs>
+  using __constructible = __test<is_constructible, _ToArgs, _FromArgs>;
+  template <class _FromArgs, class _ToArgs>
+  using __convertible = __test<is_convertible, _FromArgs, _ToArgs>;
+  template <class _FromArgs, class _ToArgs>
+  using __assignable = __test<is_assignable, _ToArgs, _FromArgs>;
+};
+
+// __tuple_convertible
+
+template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp>>::value,
+    bool = __tuple_like<_Up>::value>
+struct __tuple_convertible : public false_type
+{};
+
+template <class _Tp, class _Up>
+struct __tuple_convertible<_Tp, _Up, true, true>
+    : public __tuple_sfinae_base::__convertible<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up>>
+{};
+
+// __tuple_constructible
+
+template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp>>::value,
+    bool = __tuple_like<_Up>::value>
+struct __tuple_constructible : public false_type
+{};
+
+template <class _Tp, class _Up>
+struct __tuple_constructible<_Tp, _Up, true, true>
+    : public __tuple_sfinae_base::__constructible<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up>>
+{};
+
+// __tuple_assignable
+
+template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp>>::value,
+    bool = __tuple_like<_Up>::value>
+struct __tuple_assignable : public false_type
+{};
+
+template <class _Tp, class _Up>
+struct __tuple_assignable<_Tp, _Up, true, true>
+    : public __tuple_sfinae_base::__assignable<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up&>>
+{};
+
+template <size_t _Ip, class... _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE __tuple_element_t<_Ip, __tuple_types<_Tp...>> type;
+};
+
+template <bool _IsTuple, class _SizeTrait, size_t _Expected>
+struct __tuple_like_with_size_imp : false_type
+{};
+
+template <class _SizeTrait, size_t _Expected>
+struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected> : integral_constant<bool, _SizeTrait::value == _Expected>
+{};
+
+template <class _Tuple, size_t _ExpectedSize, class _RawTuple = __remove_cvref_t<_Tuple>>
+using __tuple_like_with_size _LIBCUDACXX_NODEBUG_TYPE =
+    __tuple_like_with_size_imp< __tuple_like<_RawTuple>::value, tuple_size<_RawTuple>, _ExpectedSize >;
+
+struct _LIBCUDACXX_TYPE_VIS __check_tuple_constructor_fail
+{
+  template <int&...>
+  using __enable_explicit_default = false_type;
+  template <int&...>
+  using __enable_implicit_default = false_type;
+  template <class...>
+  using __enable_explicit = false_type;
+  template <class...>
+  using __enable_implicit = false_type;
+  template <class...>
+  using __enable_assign = false_type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <bool _CanCopy, bool _CanMove>
+struct __sfinae_ctor_base
+{};
+template <>
+struct __sfinae_ctor_base<false, false>
+{
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = delete;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = delete;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
+};
+template <>
+struct __sfinae_ctor_base<true, false>
+{
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = default;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = delete;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
+};
+template <>
+struct __sfinae_ctor_base<false, true>
+{
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = delete;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
+};
+
+template <bool _CanCopy, bool _CanMove>
+struct __sfinae_assign_base
+{};
+template <>
+struct __sfinae_assign_base<false, false>
+{
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
+  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = delete;
+};
+template <>
+struct __sfinae_assign_base<true, false>
+{
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
+  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = default;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = delete;
+};
+template <>
+struct __sfinae_assign_base<false, true>
+{
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
+  __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = default;
+};
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_SFINAE_HELPERS_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/structured_bindings.h

@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_STRUCTURED_BINDINGS_H
+#define _LIBCUDACXX___TUPLE_STRUCTURED_BINDINGS_H
+
+#ifdef __cuda_std__
+
+#  if defined(_LIBCUDACXX_COMPILER_CLANG)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wmismatched-tags"
+#  endif // _LIBCUDACXX_COMPILER_CLANG
+
+#  if !defined(__CUDACC_RTC__)
+// Fetch utility to get primary template for ::std::tuple_size necessary for the specialization of
+// ::std::tuple_size<cuda::std::tuple> to enable structured bindings.
+// See https://github.com/NVIDIA/libcudacxx/issues/316
+#    include <utility>
+#  endif
+
+#  include "../__fwd/array.h"
+#  include "../__fwd/pair.h"
+#  include "../__fwd/tuple.h"
+#  include "../__tuple_dir/tuple_element.h"
+#  include "../__tuple_dir/tuple_size.h"
+#  include "../__type_traits/integral_constant.h"
+
+// This is a workaround for the fact that structured bindings require that the specializations of
+// `tuple_size` and `tuple_element` reside in namespace std (https://eel.is/c++draft/dcl.struct.bind#4).
+// See https://github.com/NVIDIA/libcudacxx/issues/316 for a short discussion
+#  if _LIBCUDACXX_STD_VER > 14
+namespace std {
+#    if defined(__CUDACC_RTC__)
+template <class... _Tp>
+struct tuple_size;
+
+template <size_t _Ip, class... _Tp>
+struct tuple_element;
+#    endif
+
+template <class _Tp, size_t _Size>
+struct tuple_size<_CUDA_VSTD::array<_Tp, _Size>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <class _Tp, size_t _Size>
+struct tuple_size<const _CUDA_VSTD::array<_Tp, _Size>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <class _Tp, size_t _Size>
+struct tuple_size<volatile _CUDA_VSTD::array<_Tp, _Size>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <class _Tp, size_t _Size>
+struct tuple_size<const volatile _CUDA_VSTD::array<_Tp, _Size>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <size_t _Ip, class _Tp, size_t _Size>
+struct tuple_element<_Ip, _CUDA_VSTD::array<_Tp, _Size>> : _CUDA_VSTD::tuple_element<_Ip, _CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <size_t _Ip, class _Tp, size_t _Size>
+struct tuple_element<_Ip, const _CUDA_VSTD::array<_Tp, _Size>>
+    : _CUDA_VSTD::tuple_element<_Ip, const _CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <size_t _Ip, class _Tp, size_t _Size>
+struct tuple_element<_Ip, volatile _CUDA_VSTD::array<_Tp, _Size>>
+    : _CUDA_VSTD::tuple_element<_Ip, volatile _CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <size_t _Ip, class _Tp, size_t _Size>
+struct tuple_element<_Ip, const volatile _CUDA_VSTD::array<_Tp, _Size>>
+    : _CUDA_VSTD::tuple_element<_Ip, const volatile _CUDA_VSTD::array<_Tp, _Size>>
+{};
+
+template <class _Tp, class _Up>
+struct tuple_size<_CUDA_VSTD::pair<_Tp, _Up>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <class _Tp, class _Up>
+struct tuple_size<const _CUDA_VSTD::pair<_Tp, _Up>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <class _Tp, class _Up>
+struct tuple_size<volatile _CUDA_VSTD::pair<_Tp, _Up>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <class _Tp, class _Up>
+struct tuple_size<const volatile _CUDA_VSTD::pair<_Tp, _Up>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <size_t _Ip, class _Tp, class _Up>
+struct tuple_element<_Ip, _CUDA_VSTD::pair<_Tp, _Up>> : _CUDA_VSTD::tuple_element<_Ip, _CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <size_t _Ip, class _Tp, class _Up>
+struct tuple_element<_Ip, const _CUDA_VSTD::pair<_Tp, _Up>>
+    : _CUDA_VSTD::tuple_element<_Ip, const _CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <size_t _Ip, class _Tp, class _Up>
+struct tuple_element<_Ip, volatile _CUDA_VSTD::pair<_Tp, _Up>>
+    : _CUDA_VSTD::tuple_element<_Ip, volatile _CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <size_t _Ip, class _Tp, class _Up>
+struct tuple_element<_Ip, const volatile _CUDA_VSTD::pair<_Tp, _Up>>
+    : _CUDA_VSTD::tuple_element<_Ip, const volatile _CUDA_VSTD::pair<_Tp, _Up>>
+{};
+
+template <class... _Tp>
+struct tuple_size<_CUDA_VSTD::tuple<_Tp...>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <class... _Tp>
+struct tuple_size<const _CUDA_VSTD::tuple<_Tp...>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <class... _Tp>
+struct tuple_size<volatile _CUDA_VSTD::tuple<_Tp...>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <class... _Tp>
+struct tuple_size<const volatile _CUDA_VSTD::tuple<_Tp...>> : _CUDA_VSTD::tuple_size<_CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <size_t _Ip, class... _Tp>
+struct tuple_element<_Ip, _CUDA_VSTD::tuple<_Tp...>> : _CUDA_VSTD::tuple_element<_Ip, _CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <size_t _Ip, class... _Tp>
+struct tuple_element<_Ip, const _CUDA_VSTD::tuple<_Tp...>>
+    : _CUDA_VSTD::tuple_element<_Ip, const _CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <size_t _Ip, class... _Tp>
+struct tuple_element<_Ip, volatile _CUDA_VSTD::tuple<_Tp...>>
+    : _CUDA_VSTD::tuple_element<_Ip, volatile _CUDA_VSTD::tuple<_Tp...>>
+{};
+
+template <size_t _Ip, class... _Tp>
+struct tuple_element<_Ip, const volatile _CUDA_VSTD::tuple<_Tp...>>
+    : _CUDA_VSTD::tuple_element<_Ip, const volatile _CUDA_VSTD::tuple<_Tp...>>
+{};
+} // namespace std
+#  endif // _LIBCUDACXX_STD_VER > 14
+
+#  if defined(_LIBCUDACXX_COMPILER_CLANG)
+#    pragma clang diagnostic pop
+#  endif // _LIBCUDACXX_COMPILER_CLANG
+
+#endif // __cuda_std__
+
+#endif // _LIBCUDACXX___TUPLE_STRUCTURED_BINDINGS_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_element.h

@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H
+#define _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__tuple_dir/tuple_indices.h"
+#include "../__tuple_dir/tuple_types.h"
+#include "../__type_traits/add_const.h"
+#include "../__type_traits/add_cv.h"
+#include "../__type_traits/add_volatile.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t _Ip, class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element;
+
+template <size_t _Ip, class... _Tp>
+using __tuple_element_t _LIBCUDACXX_NODEBUG_TYPE = typename tuple_element<_Ip, _Tp...>::type;
+
+template <size_t _Ip, class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE typename add_const<__tuple_element_t<_Ip, _Tp>>::type type;
+};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE typename add_volatile<__tuple_element_t<_Ip, _Tp>>::type type;
+};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE typename add_cv<__tuple_element_t<_Ip, _Tp>>::type type;
+};
+
+#ifdef _LIBCUDACXX_COMPILER_MSVC
+
+namespace __indexer_detail {
+
+template <size_t _Idx, class... _Types>
+struct _nth_of;
+
+template <class _Head, class... _Tail>
+struct _nth_of<0, _Head, _Tail...>
+{
+  using type = _Head;
+};
+
+template <size_t _Idx, class _Head, class... _Tail>
+struct _nth_of<_Idx, _Head, _Tail...>
+{
+  using type = typename _nth_of<_Idx - 1, _Tail...>::type;
+};
+
+template <size_t _Idx, class... _Types>
+struct nth_of
+{
+  static_assert(_Idx < sizeof...(_Types), "");
+  using _impl = _nth_of<_Idx, _Types...>;
+  using type  = typename _impl::type;
+};
+
+} // namespace __indexer_detail
+
+template <size_t _Idx, class... _Types>
+using __type_pack_element _LIBCUDACXX_NODEBUG_TYPE = typename __indexer_detail::nth_of<_Idx, _Types...>::type;
+
+#elif !__has_builtin(__type_pack_element)
+
+namespace __indexer_detail {
+
+template <size_t _Idx, class _Tp>
+struct __indexed
+{
+  using type _LIBCUDACXX_NODEBUG_TYPE = _Tp;
+};
+
+template <class _Types, class _Indexes>
+struct __indexer;
+
+template <class... _Types, size_t... _Idx>
+struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>> : __indexed<_Idx, _Types>...
+{};
+
+template <size_t _Idx, class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY __indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
+
+} // namespace __indexer_detail
+
+template <size_t _Idx, class... _Types>
+using __type_pack_element _LIBCUDACXX_NODEBUG_TYPE =
+    typename decltype(__indexer_detail::__at_index<_Idx>(__indexer_detail::__indexer< __tuple_types<_Types...>,
+        __make_tuple_indices_t<sizeof...(_Types)>>{}))::type;
+#endif
+
+template <size_t _Ip, class... _Types>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> >
+{
+  static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
+  typedef _LIBCUDACXX_NODEBUG_TYPE __type_pack_element<_Ip, _Types...> type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <size_t _Ip, class... _Tp>
+using tuple_element_t _LIBCUDACXX_NODEBUG_TYPE = typename tuple_element<_Ip, _Tp...>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_TUPLE_ELEMENT_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_indices.h

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_MAKE_TUPLE_INDICES_H
+#define _LIBCUDACXX___TUPLE_MAKE_TUPLE_INDICES_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/integer_sequence.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t _Ep, size_t _Sp = 0>
+struct __make_tuple_indices
+{
+  static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
+  typedef __make_indices_imp<_Ep, _Sp> type;
+};
+
+template <size_t _Ep, size_t _Sp = 0>
+using __make_tuple_indices_t = typename __make_tuple_indices<_Ep, _Sp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_MAKE_TUPLE_INDICES_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_like.h

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_TUPLE_LIKE_H
+#define _LIBCUDACXX___TUPLE_TUPLE_LIKE_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/array.h"
+#include "../__fwd/pair.h"
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/tuple_types.h"
+#include "../__type_traits/integral_constant.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __tuple_like : false_type
+{};
+
+template <class _Tp>
+struct __tuple_like<const _Tp> : public __tuple_like<_Tp>
+{};
+template <class _Tp>
+struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp>
+{};
+template <class _Tp>
+struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp>
+{};
+
+template <class... _Tp>
+struct __tuple_like<tuple<_Tp...> > : true_type
+{};
+
+template <class _T1, class _T2>
+struct __tuple_like<pair<_T1, _T2> > : true_type
+{};
+
+template <class _Tp, size_t _Size>
+struct __tuple_like<array<_Tp, _Size> > : true_type
+{};
+
+template <class... _Tp>
+struct __tuple_like<__tuple_types<_Tp...> > : true_type
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_TUPLE_LIKE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_size.h

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_TUPLE_SIZE_H
+#define _LIBCUDACXX___TUPLE_TUPLE_SIZE_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/tuple_types.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_const.h"
+#include "../__type_traits/is_volatile.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_size;
+
+template <class _Tp, class...>
+using __enable_if_tuple_size_imp = _Tp;
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< const _Tp,
+    __enable_if_t<!is_volatile<_Tp>::value>, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public integral_constant<size_t, tuple_size<_Tp>::value>
+{};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< volatile _Tp,
+    __enable_if_t<!is_const<_Tp>::value>, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public integral_constant<size_t, tuple_size<_Tp>::value>
+{};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS
+    tuple_size<__enable_if_tuple_size_imp< const volatile _Tp, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public integral_constant<size_t, tuple_size<_Tp>::value>
+{};
+
+template <class... _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)>
+{};
+
+template <class... _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)>
+{};
+
+#if _LIBCUDACXX_STD_VER >= 17
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+#endif // _LIBCUDACXX_STD_VER >= 17
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_TUPLE_SIZE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__tuple_dir/tuple_types.h

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TUPLE_TUPLE_TYPES_H
+#define _LIBCUDACXX___TUPLE_TUPLE_TYPES_H
+
+#ifndef __cuda_std__
+#  include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class... _Tp>
+struct __tuple_types
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TUPLE_TUPLE_TYPES_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_const.h

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS add_const {
+  typedef _LIBCUDACXX_NODEBUG_TYPE const _Tp type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_cv.h

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS add_cv {
+  typedef _LIBCUDACXX_NODEBUG_TYPE const volatile _Tp type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_lvalue_reference.h

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_referenceable.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_ADD_LVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_ADD_LVALUE_REFERENCE_FALLBACK)
+
+template <class _Tp>
+using __add_lvalue_reference_t = _LIBCUDACXX_ADD_LVALUE_REFERENCE(_Tp);
+
+#else
+
+template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
+struct __add_lvalue_reference_impl {
+  typedef _LIBCUDACXX_NODEBUG_TYPE _Tp type;
+};
+template <class _Tp >
+struct __add_lvalue_reference_impl<_Tp, true> {
+  typedef _LIBCUDACXX_NODEBUG_TYPE _Tp& type;
+};
+
+template <class _Tp>
+using __add_lvalue_reference_t = typename __add_lvalue_reference_impl<_Tp>::type;
+
+#endif // defined(_LIBCUDACXX_ADD_LVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_ADD_LVALUE_REFERENCE_FALLBACK)
+
+template <class _Tp>
+struct add_lvalue_reference {
+  using type _LIBCUDACXX_NODEBUG_TYPE = __add_lvalue_reference_t<_Tp>;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_pointer.h

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_referenceable.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/remove_cv.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_ADD_POINTER) && !defined(_LIBCUDACXX_USE_ADD_POINTER_FALLBACK)
+
+template <class _Tp>
+using __add_pointer_t = _LIBCUDACXX_ADD_POINTER(_Tp);
+
+#else
+template <class _Tp,
+          bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
+struct __add_pointer_impl {
+  typedef _LIBCUDACXX_NODEBUG_TYPE __libcpp_remove_reference_t<_Tp>* type;
+};
+template <class _Tp> struct __add_pointer_impl<_Tp, false>
+    {typedef _LIBCUDACXX_NODEBUG_TYPE _Tp type;};
+
+template <class _Tp>
+using __add_pointer_t = typename __add_pointer_impl<_Tp>::type;
+
+#endif // defined(_LIBCUDACXX_ADD_POINTER) && !defined(_LIBCUDACXX_USE_ADD_POINTER_FALLBACK)
+
+template <class _Tp>
+struct add_pointer {
+  using type _LIBCUDACXX_NODEBUG_TYPE = __add_pointer_t<_Tp>;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_rvalue_reference.h

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_referenceable.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_ADD_RVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_ADD_RVALUE_REFERENCE_FALLBACK)
+
+template <class _Tp>
+using __add_rvalue_reference_t = _LIBCUDACXX_ADD_RVALUE_REFERENCE(_Tp);
+
+#else
+
+template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value>
+struct __add_rvalue_reference_impl {
+  typedef _LIBCUDACXX_NODEBUG_TYPE _Tp type;
+};
+template <class _Tp >
+struct __add_rvalue_reference_impl<_Tp, true> {
+  typedef _LIBCUDACXX_NODEBUG_TYPE _Tp&& type;
+};
+
+template <class _Tp>
+using __add_rvalue_reference_t = typename __add_rvalue_reference_impl<_Tp>::type;
+
+#endif // defined(_LIBCUDACXX_ADD_RVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_ADD_RVALUE_REFERENCE_FALLBACK)
+
+template <class _Tp>
+struct add_rvalue_reference {
+  using type = __add_rvalue_reference_t<_Tp>;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp>
+using add_rvalue_reference_t = __add_rvalue_reference_t<_Tp>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/add_volatile.h

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS add_volatile {
+  typedef _LIBCUDACXX_NODEBUG_TYPE volatile _Tp type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/aligned_storage.h

@@ -0,0 +1,141 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/nat.h"
+#include "../__type_traits/type_list.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __align_type
+{
+    static const size_t value = _LIBCUDACXX_PREFERRED_ALIGNOF(_Tp);
+    typedef _Tp type;
+};
+
+struct __struct_double {long double __lx;};
+struct __struct_double4 {double __lx[4];};
+
+typedef
+    __type_list<__align_type<unsigned char>,
+    __type_list<__align_type<unsigned short>,
+    __type_list<__align_type<unsigned int>,
+    __type_list<__align_type<unsigned long>,
+    __type_list<__align_type<unsigned long long>,
+    __type_list<__align_type<double>,
+    __type_list<__align_type<long double>,
+    __type_list<__align_type<__struct_double>,
+    __type_list<__align_type<__struct_double4>,
+    __type_list<__align_type<int*>,
+    __nat
+    > > > > > > > > > > __all_types;
+
+template <size_t _Align>
+struct _ALIGNAS(_Align) __fallback_overaligned {};
+
+template <class _TL, size_t _Align> struct __find_pod;
+
+template <class _Hp, size_t _Align>
+struct __find_pod<__type_list<_Hp, __nat>, _Align>
+{
+    typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, __fallback_overaligned<_Align> > type;
+};
+
+template <class _Hp, class _Tp, size_t _Align>
+struct __find_pod<__type_list<_Hp, _Tp>, _Align>
+{
+    typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, typename __find_pod<_Tp, _Align>::type> type;
+};
+
+template <class _TL, size_t _Len> struct __find_max_align;
+
+template <class _Hp, size_t _Len>
+struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};
+
+template <size_t _Len, size_t _A1, size_t _A2>
+struct __select_align
+{
+private:
+    static const size_t __min = _A2 < _A1 ? _A2 : _A1;
+    static const size_t __max = _A1 < _A2 ? _A2 : _A1;
+public:
+    static const size_t value = _Len < __max ? __min : __max;
+};
+
+template <class _Hp, class _Tp, size_t _Len>
+struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
+    : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
+
+template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
+struct _LIBCUDACXX_TEMPLATE_VIS aligned_storage
+{
+    typedef typename __find_pod<__all_types, _Align>::type _Aligner;
+    union type
+    {
+        _Aligner __align;
+        unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
+    };
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
+    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+#endif
+
+#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
+template <size_t _Len>\
+struct _LIBCUDACXX_TEMPLATE_VIS aligned_storage<_Len, n>\
+{\
+    struct _ALIGNAS(n) type\
+    {\
+        unsigned char __lx[(_Len + n - 1)/n * n];\
+    };\
+}
+
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
+// PE/COFF does not support alignment beyond 8192 (=0x2000)
+#if !defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
+#endif // !defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+
+#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/aligned_union.h

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/aligned_storage.h"
+#include "../__type_traits/integral_constant.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t _I0, size_t ..._In>
+struct __static_max;
+
+template <size_t _I0>
+struct __static_max<_I0>
+{
+    static const size_t value = _I0;
+};
+
+template <size_t _I0, size_t _I1, size_t ..._In>
+struct __static_max<_I0, _I1, _In...>
+{
+    static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
+                                             __static_max<_I1, _In...>::value;
+};
+
+template <size_t _Len, class _Type0, class ..._Types>
+struct aligned_union
+{
+    static const size_t alignment_value = __static_max<_LIBCUDACXX_PREFERRED_ALIGNOF(_Type0),
+                                                       _LIBCUDACXX_PREFERRED_ALIGNOF(_Types)...>::value;
+    static const size_t __len = __static_max<_Len, sizeof(_Type0),
+                                             sizeof(_Types)...>::value;
+    typedef typename aligned_storage<__len, alignment_value>::type type;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/alignment_of.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS alignment_of
+    : public integral_constant<size_t, _LIBCUDACXX_ALIGNOF(_Tp)> {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr size_t alignment_of_v = _LIBCUDACXX_ALIGNOF(_Tp);
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/apply_cv.h

@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_APPLY_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_APPLY_CV_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_const.h"
+#include "../__type_traits/is_volatile.h"
+#include "../__type_traits/remove_reference.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Up, bool = is_const<__libcpp_remove_reference_t<_Tp> >::value,
+                             bool = is_volatile<__libcpp_remove_reference_t<_Tp> >::value>
+struct __apply_cv
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE _Up type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp, _Up, true, false>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE const _Up type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp, _Up, false, true>
+{
+    typedef volatile _Up type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp, _Up, true, true>
+{
+    typedef const volatile _Up type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp&, _Up, false, false>
+{
+    typedef _Up& type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp&, _Up, true, false>
+{
+    typedef const _Up& type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp&, _Up, false, true>
+{
+    typedef volatile _Up& type;
+};
+
+template <class _Tp, class _Up>
+struct __apply_cv<_Tp&, _Up, true, true>
+{
+    typedef const volatile _Up& type;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_APPLY_CV_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/can_extract_key.h

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H
+#define _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/pair.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/remove_const.h"
+#include "../__type_traits/remove_const_ref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// These traits are used in __tree and __hash_table
+struct __extract_key_fail_tag {};
+struct __extract_key_self_tag {};
+struct __extract_key_first_tag {};
+
+template <class _ValTy, class _Key, class _RawValTy = __remove_const_ref_t<_ValTy> >
+struct __can_extract_key
+    : __conditional_t<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag, __extract_key_fail_tag> {};
+
+template <class _Pair, class _Key, class _First, class _Second>
+struct __can_extract_key<_Pair, _Key, pair<_First, _Second> >
+    : __conditional_t<_IsSame<__remove_const_t<_First>, _Key>::value, __extract_key_first_tag, __extract_key_fail_tag> {
+};
+
+// __can_extract_map_key uses true_type/false_type instead of the tags.
+// It returns true if _Key != _ContainerValueTy (the container is a map not a set)
+// and _ValTy == _Key.
+template <class _ValTy, class _Key, class _ContainerValueTy,
+          class _RawValTy = __remove_const_ref_t<_ValTy> >
+struct __can_extract_map_key
+    : integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {};
+
+// This specialization returns __extract_key_fail_tag for non-map containers
+// because _Key == _ContainerValueTy
+template <class _ValTy, class _Key, class _RawValTy>
+struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
+    : false_type {};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/common_reference.h

@@ -0,0 +1,241 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+// SPDX-FileCopyrightText: Copyright (c) Microsoft Corporation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/common_type.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/copy_cv.h"
+#include "../__type_traits/copy_cvref.h"
+#include "../__type_traits/disjunction.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_array.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_scalar.h"
+#include "../__type_traits/remove_reference.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// common_reference
+#if _LIBCUDACXX_STD_VER > 11
+
+// Let COND_RES(X, Y) be:
+#ifdef _LIBCUDACXX_COMPILER_MSVC // Workaround for DevCom-1627396
+template <class _Tp>
+_Tp __returns_exactly() noexcept; // not defined
+
+template <class _Xp, class _Yp>
+using __cond_res_if_right = decltype(false ? __returns_exactly<_Xp>() : __returns_exactly<_Yp>());
+
+template <class _Tp, class _Up, class = void>
+struct __cond_res_workaround {};
+
+template <class _Tp, class _Up>
+struct __cond_res_workaround<_Tp, _Up, void_t<__cond_res_if_right<_Tp, _Up>>> {
+    using _RTp = remove_cvref_t<_Tp>;
+    using type = conditional_t<is_same_v<_RTp, remove_cvref_t<_Up>> &&
+                               (is_scalar_v<_RTp> || is_array_v<_RTp>) &&
+                               ((is_lvalue_reference_v<_Tp> && is_rvalue_reference_v<_Up>) || (is_rvalue_reference_v<_Tp> && is_lvalue_reference_v<_Up>)),
+                 decay_t<__copy_cv_t<remove_reference_t<_Tp>, remove_reference_t<_Up>>>, __cond_res_if_right<_Tp, _Up>>;
+};
+
+template <class _Xp, class _Yp>
+using __cond_res = typename __cond_res_workaround<_Xp, _Yp>::type;
+#else // ^^^ MSVC ^^^ / vvv !MSVC vvv
+template <class _Xp, class _Yp>
+using __cond_res =
+    decltype(false ? _CUDA_VSTD::declval<_Xp(&)()>()() : _CUDA_VSTD::declval<_Yp(&)()>()());
+#endif // !MSVC
+
+// Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
+// with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
+// `U`.
+// [Note: `XREF(A)` is `__xref<A>::template __apply`]
+template <class _Tp>
+struct __xref {
+  template<class _Up>
+  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:
+template<class _Ap, class _Bp, class = void>
+struct __common_ref;
+
+template<class _Xp, class _Yp>
+using __common_ref_t = typename __common_ref<_Xp, _Yp>::__type;
+
+template<class _Xp, class _Yp>
+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.
+template<class _Ap, class _Bp>
+struct __common_ref<_Ap&, _Bp&, enable_if_t<is_reference_v<__cv_cond_res<_Ap, _Bp>>>>
+{
+    using __type = __cv_cond_res<_Ap, _Bp>;
+};
+
+//    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.
+template<class _Ap, class _Bp, class = void>
+struct __common_ref_rr {};
+
+template<class _Ap, class _Bp>
+struct __common_ref_rr<_Ap&&, _Bp&&, enable_if_t<
+                            is_convertible_v<_Ap&&, __common_ref_C<_Ap, _Bp>>
+                         && is_convertible_v<_Bp&&, __common_ref_C<_Ap, _Bp>>>>
+{
+    using __type = __common_ref_C<_Ap, _Bp>;
+};
+
+template<class _Ap, class _Bp>
+struct __common_ref<_Ap&&, _Bp&&> : __common_ref_rr<_Ap&&, _Bp&&> {};
+
+//    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.
+template<class _Ap, class _Bp, class = void>
+struct __common_ref_lr {};
+
+template<class _Ap, class _Bp>
+struct __common_ref_lr<_Ap&&, _Bp&, enable_if_t<is_convertible_v<_Ap&&, __common_ref_D<_Ap, _Bp>>>>
+{
+    using __type = __common_ref_D<_Ap, _Bp>;
+};
+
+template<class _Ap, class _Bp>
+struct __common_ref<_Ap&&, _Bp&> : __common_ref_lr<_Ap&&, _Bp&> {};
+
+//    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>
+struct __common_ref<_Ap&, _Bp&&> : __common_ref_lr<_Bp&&, _Ap&> {};
+
+//    Otherwise, COMMON-REF(A, B) is ill-formed.
+template<class _Ap, class _Bp, class>
+struct __common_ref {};
+
+// Note C: For the common_reference trait applied to a parameter pack [...]
+
+template <class...>
+struct common_reference;
+
+template <class... _Types>
+using common_reference_t = typename common_reference<_Types...>::type;
+
+#if _LIBCUDACXX_STD_VER > 11
+template<class, class, class = void>
+_LIBCUDACXX_INLINE_VAR constexpr bool __has_common_reference = false;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VAR constexpr bool __has_common_reference<_Tp, _Up, void_t<common_reference_t<_Tp, _Up>>> = true;
+#endif  // _LIBCUDACXX_STD_VER > 11
+
+// bullet 1 - sizeof...(T) == 0
+template<>
+struct common_reference<> {};
+
+// bullet 2 - sizeof...(T) == 1
+template <class _Tp>
+struct common_reference<_Tp>
+{
+    using type = _Tp;
+};
+
+// bullet 3 - sizeof...(T) == 2
+template <class _Tp, class _Up, class = void> struct __common_reference_sub_bullet3;
+template <class _Tp, class _Up, class = void> struct __common_reference_sub_bullet2
+    : __common_reference_sub_bullet3<_Tp, _Up> {};
+template <class _Tp, class _Up, class = void> 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.
+template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet1<_Tp, _Up, void_t<__common_ref_t<_Tp, _Up>,
+    enable_if_t<is_reference_v<_Tp> && is_reference_v<_Up>>>>
+{
+    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.
+template <class, class, template <class> class, template <class> class> struct basic_common_reference {};
+
+template <class _Tp, class _Up>
+using __basic_common_reference_t = typename basic_common_reference<
+    remove_cvref_t<_Tp>, remove_cvref_t<_Up>,
+    __xref<_Tp>::template __apply, __xref<_Up>::template __apply>::type;
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet2<_Tp, _Up, void_t<__basic_common_reference_t<_Tp, _Up>>>
+{
+    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.
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet3<_Tp, _Up, void_t<__cond_res<_Tp, _Up>>>
+{
+    using type = __cond_res<_Tp, _Up>;
+};
+
+
+// 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, class> 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...>`.
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct common_reference<_Tp, _Up, _Vp, void_t<common_reference_t<_Tp, _Up>>, _Rest...>
+    : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
+{};
+
+// bullet 5 - Otherwise, there shall be no member `type`.
+template <class...> struct common_reference {};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/common_type.h

@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H
+#define _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/decay.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class... _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS common_type;
+
+template <class ..._Tp>
+using __common_type_t = typename common_type<_Tp...>::type;
+
+// Let COND_RES(X, Y) be:
+template <class _Tp, class _Up>
+using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>());
+
+#if _LIBCUDACXX_STD_VER > 17
+template <class _Tp, class _Up, class = void>
+struct __common_type3 {};
+
+// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
+template <class _Tp, class _Up>
+struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
+{
+    using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
+};
+
+template <class _Tp, class _Up, class = void>
+struct __common_type2_imp : __common_type3<_Tp, _Up> {};
+#else
+template <class _Tp, class _Up, class = void>
+struct __common_type2_imp {};
+#endif
+
+// sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
+template <class _Tp, class _Up>
+struct __common_type2_imp<_Tp, _Up, __void_t<__cond_type<_Tp, _Up>>>
+{
+  typedef _LIBCUDACXX_NODEBUG_TYPE __decay_t<__cond_type<_Tp, _Up>> type;
+};
+
+template <class, class = void>
+struct __common_type_impl {};
+
+template <class... _Tp>
+struct __common_types;
+
+template <class _Tp, class _Up>
+struct __common_type_impl<
+    __common_types<_Tp, _Up>, __void_t<__common_type_t<_Tp, _Up>> >
+{
+  typedef __common_type_t<_Tp, _Up> type;
+};
+
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...>, __void_t<__common_type_t<_Tp, _Up>> >
+    : __common_type_impl<__common_types<__common_type_t<_Tp, _Up>, _Vp, _Rest...>> {};
+
+// bullet 1 - sizeof...(Tp) == 0
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS common_type<> {};
+
+// bullet 2 - sizeof...(Tp) == 1
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS common_type<_Tp>
+    : public common_type<_Tp, _Tp> {};
+
+// bullet 3 - sizeof...(Tp) == 2
+
+// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
+template <class _Tp, class _Up, class _D1 = __decay_t<_Tp>, class _D2 = __decay_t<_Up>>
+struct __common_type2 : common_type<_D1, _D2> {};
+
+template <class _Tp, class _Up>
+struct __common_type2<_Tp, _Up, _Tp, _Up> : __common_type2_imp<_Tp, _Up> {};
+
+template <class _Tp, class _Up>
+struct _LIBCUDACXX_TEMPLATE_VIS common_type<_Tp, _Up>
+    : __common_type2<_Tp, _Up> {};
+
+// bullet 4 - sizeof...(Tp) > 2
+
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct _LIBCUDACXX_TEMPLATE_VIS common_type<_Tp, _Up, _Vp, _Rest...>
+    : __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...> > {};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
+
+template<class, class, class = void>
+_LIBCUDACXX_INLINE_VAR constexpr bool __has_common_type = false;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VAR constexpr bool __has_common_type<_Tp, _Up, void_t<common_type_t<_Tp, _Up>>> = true;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/conditional.h

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H
+#define _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool>
+struct _IfImpl;
+
+template <>
+struct _IfImpl<true> {
+  template <class _IfRes, class _ElseRes>
+  using _Select _LIBCUDACXX_NODEBUG_TYPE = _IfRes;
+};
+
+template <>
+struct _IfImpl<false> {
+  template <class _IfRes, class _ElseRes>
+  using _Select _LIBCUDACXX_NODEBUG_TYPE = _ElseRes;
+};
+
+template <bool _Cond, class _IfRes, class _ElseRes>
+using _If _LIBCUDACXX_NODEBUG_TYPE = typename _IfImpl<_Cond>::template _Select<_IfRes, _ElseRes>;
+
+template <bool _Bp, class _If, class _Then>
+    struct _LIBCUDACXX_TEMPLATE_VIS conditional {typedef _If type;};
+template <class _If, class _Then>
+    struct _LIBCUDACXX_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <bool _Bp, class _IfRes, class _ElseRes>
+using conditional_t = typename conditional<_Bp, _IfRes, _ElseRes>::type;
+#endif
+
+// Helper so we can use "conditional_t" in all language versions.
+template <bool _Bp, class _If, class _Then> using __conditional_t = typename conditional<_Bp, _If, _Then>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/conjunction.h

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H
+#define _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class...>
+using __expand_to_true = true_type;
+
+template <class... _Pred>
+_LIBCUDACXX_INLINE_VISIBILITY __expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int);
+
+template <class...>
+_LIBCUDACXX_INLINE_VISIBILITY false_type __and_helper(...);
+
+// _And always performs lazy evaluation of its arguments.
+//
+// However, `_And<_Pred...>` itself will evaluate its result immediately (without having to
+// be instantiated) since it is an alias, unlike `conjunction<_Pred...>`, which is a struct.
+// If you want to defer the evaluation of `_And<_Pred...>` itself, use `_Lazy<_And, _Pred...>`.
+template <class... _Pred>
+using _And _LIBCUDACXX_NODEBUG_TYPE = decltype(__and_helper<_Pred...>(0));
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class...>
+struct conjunction : true_type {};
+
+template <class _Arg>
+struct conjunction<_Arg> : _Arg {};
+
+template <class _Arg, class... _Args>
+struct conjunction<_Arg, _Args...> : conditional_t<!bool(_Arg::value), _Arg, conjunction<_Args...>> {};
+
+template <class... _Args>
+_LIBCUDACXX_INLINE_VAR constexpr bool conjunction_v = conjunction<_Args...>::value;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/copy_cv.h

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/add_const.h"
+#include "../__type_traits/add_cv.h"
+#include "../__type_traits/add_volatile.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// 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
+{
+    using type = _To;
+};
+
+template <class _From, class _To>
+struct __copy_cv<const _From, _To>
+{
+    using type = typename add_const<_To>::type;
+};
+
+template <class _From, class _To>
+struct __copy_cv<volatile _From, _To>
+{
+    using type = typename add_volatile<_To>::type;
+};
+
+template <class _From, class _To>
+struct __copy_cv<const volatile _From, _To>
+{
+    using type = typename add_cv<_To>::type;
+};
+
+template <class _From, class _To>
+using __copy_cv_t = typename __copy_cv<_From, _To>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/copy_cvref.h

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/add_lvalue_reference.h"
+#include "../__type_traits/add_rvalue_reference.h"
+#include "../__type_traits/copy_cv.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _From, class _To>
+struct __copy_cvref
+{
+    using type = __copy_cv_t<_From, _To>;
+};
+
+template <class _From, class _To>
+struct __copy_cvref<_From&, _To>
+{
+    using type = __add_lvalue_reference_t<__copy_cv_t<_From, _To> >;
+};
+
+template <class _From, class _To>
+struct __copy_cvref<_From&&, _To>
+{
+    using type = __add_rvalue_reference_t<__copy_cv_t<_From, _To> >;
+};
+
+template <class _From, class _To>
+using __copy_cvref_t = typename __copy_cvref<_From, _To>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/decay.h

@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DECAY_H
+#define _LIBCUDACXX___TYPE_TRAITS_DECAY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/add_pointer.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/is_array.h"
+#include "../__type_traits/is_function.h"
+#include "../__type_traits/is_referenceable.h"
+#include "../__type_traits/remove_cv.h"
+#include "../__type_traits/remove_extent.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_DECAY) && !defined(_LIBCUDACXX_USE_DECAY_FALLBACK)
+template <class _Tp>
+struct decay {
+  using type _LIBCUDACXX_NODEBUG_TYPE = _LIBCUDACXX_DECAY(_Tp);
+};
+
+#else
+
+template <class _Up, bool>
+struct __decay_impl {
+    typedef _LIBCUDACXX_NODEBUG_TYPE __remove_cv_t<_Up> type;
+};
+
+template <class _Up>
+struct __decay_impl<_Up, true> {
+public:
+    typedef _LIBCUDACXX_NODEBUG_TYPE __conditional_t
+                     <
+                         is_array<_Up>::value,
+                         __remove_extent_t<_Up>*,
+                         __conditional_t
+                         <
+                              is_function<_Up>::value,
+                              __add_pointer_t<_Up>,
+                              __remove_cv_t<_Up>
+                         >
+                     > type;
+};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS decay
+{
+private:
+    typedef _LIBCUDACXX_NODEBUG_TYPE __libcpp_remove_reference_t<_Tp> _Up;
+public:
+  typedef _LIBCUDACXX_NODEBUG_TYPE typename __decay_impl<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
+};
+#endif // defined(_LIBCUDACXX_DECAY) && !defined(_LIBCUDACXX_USE_DECAY_FALLBACK)
+
+template <class _Tp> using __decay_t = typename decay<_Tp>::type;
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using decay_t = typename decay<_Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DECAY_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/dependent_type.h

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H
+#define _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, bool>
+struct _LIBCUDACXX_TEMPLATE_VIS __dependent_type : public _Tp {};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/disjunction.h

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H
+#define _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool>
+struct _OrImpl;
+
+template <>
+struct _OrImpl<true> {
+  template <class _Res, class _First, class... _Rest>
+  using _Result _LIBCUDACXX_NODEBUG_TYPE =
+      typename _OrImpl<!bool(_First::value) && sizeof...(_Rest) != 0>::template _Result<_First, _Rest...>;
+};
+
+template <>
+struct _OrImpl<false> {
+  template <class _Res, class...>
+  using _Result = _Res;
+};
+
+// _Or always performs lazy evaluation of its arguments.
+//
+// However, `_Or<_Pred...>` itself will evaluate its result immediately (without having to
+// be instantiated) since it is an alias, unlike `disjunction<_Pred...>`, which is a struct.
+// If you want to defer the evaluation of `_Or<_Pred...>` itself, use `_Lazy<_Or, _Pred...>`
+// or `disjunction<_Pred...>` directly.
+template <class... _Args>
+using _Or _LIBCUDACXX_NODEBUG_TYPE = typename _OrImpl<sizeof...(_Args) != 0>::template _Result<false_type, _Args...>;
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#ifdef _LIBCUDACXX_COMPILER_MSVC
+template <class... _Args>
+struct disjunction : false_type {};
+
+template <class _First, class... _Rest>
+struct disjunction<_First, _Rest...> : _OrImpl<true>::template _Result<false_type, _First, _Rest...> {};
+#else
+template <class... _Args>
+struct disjunction : _Or<_Args...> {};
+#endif // !MSVC
+
+template <class... _Args>
+_LIBCUDACXX_INLINE_VAR constexpr bool disjunction_v = _Or<_Args...>::value;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/enable_if.h

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H
+#define _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool, class _Tp = void> struct _LIBCUDACXX_TEMPLATE_VIS enable_if {};
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
+
+template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCUDACXX_NODEBUG_TYPE = typename enable_if<_Bp, _Tp>::type;
+
+#if _LIBCUDACXX_STD_VER > 11
+template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/extent.h

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_EXTENT_H
+#define _LIBCUDACXX___TYPE_TRAITS_EXTENT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_ARRAY_EXTENT) && !defined(_LIBCUDACXX_USE_ARRAY_EXTENT_FALLBACK)
+
+template<class _Tp, size_t _Dim = 0>
+struct _LIBCUDACXX_TEMPLATE_VIS extent
+    : integral_constant<size_t, _LIBCUDACXX_ARRAY_EXTENT(_Tp, _Dim)> { };
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp, unsigned _Ip = 0>
+_LIBCUDACXX_INLINE_VAR constexpr size_t extent_v = _LIBCUDACXX_ARRAY_EXTENT(_Tp, _Ip);
+#endif
+
+#else
+
+template <class _Tp, unsigned _Ip = 0> struct _LIBCUDACXX_TEMPLATE_VIS extent
+    : public integral_constant<size_t, 0> {};
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS extent<_Tp[], 0>
+    : public integral_constant<size_t, 0> {};
+template <class _Tp, unsigned _Ip> struct _LIBCUDACXX_TEMPLATE_VIS extent<_Tp[], _Ip>
+    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
+template <class _Tp, size_t _Np> struct _LIBCUDACXX_TEMPLATE_VIS extent<_Tp[_Np], 0>
+    : public integral_constant<size_t, _Np> {};
+template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCUDACXX_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
+    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp, unsigned _Ip = 0>
+_LIBCUDACXX_INLINE_VAR constexpr size_t extent_v = extent<_Tp, _Ip>::value;
+#endif
+
+#endif // defined(_LIBCUDACXX_ARRAY_EXTENT) && !defined(_LIBCUDACXX_USE_ARRAY_EXTENT_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_EXTENT_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/has_unique_object_representation.h

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H
+#define _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/remove_all_extents.h"
+#include "../__type_traits/remove_cv.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11 && defined(_LIBCUDACXX_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS has_unique_object_representations
+    : public integral_constant<bool,
+       __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};
+
+#if !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
+#endif
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/has_virtual_destructor.h

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H
+#define _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_HAS_VIRTUAL_DESTRUCTOR) && !defined(_LIBCUDACXX_USE_HAS_VIRTUAL_DESTRUCTOR_FALLBACK)
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS has_virtual_destructor
+    : public integral_constant<bool, _LIBCUDACXX_HAS_VIRTUAL_DESTRUCTOR(_Tp)> {};
+
+#else
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS has_virtual_destructor
+    : public false_type {};
+
+#endif // defined(_LIBCUDACXX_HAS_VIRTUAL_DESTRUCTOR) && !defined(_LIBCUDACXX_USE_HAS_VIRTUAL_DESTRUCTOR_FALLBACK)
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool has_virtual_destructor_v
+    = has_virtual_destructor<_Tp>::value;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/integral_constant.h

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H
+#define _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, _Tp __v>
+struct _LIBCUDACXX_TEMPLATE_VIS integral_constant
+{
+  static constexpr const _Tp      value = __v;
+  typedef _Tp               value_type;
+  typedef integral_constant type;
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr operator value_type() const noexcept {return value;}
+#if _LIBCUDACXX_STD_VER > 11
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr value_type operator ()() const noexcept {return value;}
+#endif
+};
+
+template <class _Tp, _Tp __v>
+constexpr const _Tp integral_constant<_Tp, __v>::value;
+
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+
+template <bool _Val>
+using _BoolConstant _LIBCUDACXX_NODEBUG_TYPE = integral_constant<bool, _Val>;
+
+#if _LIBCUDACXX_STD_VER > 11
+template <bool __b>
+using bool_constant = integral_constant<bool, __b>;
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+#define _LIBCUDACXX_BOOL_CONSTANT(__b) bool_constant<(__b)>
+#else
+#define _LIBCUDACXX_BOOL_CONSTANT(__b) integral_constant<bool,(__b)>
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_abstract.h

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)> {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_abstract_v = __is_abstract(_Tp);
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_aggregate.h

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11 && defined(_LIBCUDACXX_IS_AGGREGATE)
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS
+is_aggregate : public integral_constant<bool, _LIBCUDACXX_IS_AGGREGATE(_Tp)> {};
+
+#if !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_aggregate_v = _LIBCUDACXX_IS_AGGREGATE(_Tp);
+#endif
+
+#endif // _LIBCUDACXX_STD_VER > 11 && defined(_LIBCUDACXX_IS_AGGREGATE)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_allocator.h

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_IS_ALLOCATOR_H
+#define _LIBCUDACXX___TYPE_IS_ALLOCATOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template<typename _Alloc, typename = void, typename = void>
+struct __is_allocator : false_type {};
+
+template<typename _Alloc>
+struct __is_allocator<_Alloc,
+       __void_t<typename _Alloc::value_type>,
+       __void_t<decltype(_CUDA_VSTD::declval<_Alloc&>().allocate(size_t(0)))>
+     >
+   : true_type {};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_IS_ALLOCATOR_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_arithmetic.h

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_floating_point.h"
+#include "../__type_traits/is_integral.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS is_arithmetic
+    : public integral_constant<bool, is_integral<_Tp>::value      ||
+                                     is_floating_point<_Tp>::value> {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_array.h

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// TODO: Clang incorrectly reports that __is_array is true for T[0].
+//       Re-enable the branch once https://llvm.org/PR54705 is fixed.
+#if defined(_LIBCUDACXX_IS_ARRAY) && !defined(_LIBCUDACXX_USE_IS_ARRAY_FALLBACK)
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS is_array
+    : public integral_constant<bool, _LIBCUDACXX_IS_ARRAY(_Tp)>
+    {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_array_v = _LIBCUDACXX_IS_ARRAY(_Tp);
+#endif
+
+#else
+
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS is_array
+    : public false_type {};
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS is_array<_Tp[]>
+    : public true_type {};
+template <class _Tp, size_t _Np> struct _LIBCUDACXX_TEMPLATE_VIS is_array<_Tp[_Np]>
+    : public true_type {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_array_v = is_array<_Tp>::value;
+#endif
+
+#endif // defined(_LIBCUDACXX_IS_ARRAY) && !defined(_LIBCUDACXX_USE_IS_ARRAY_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H

miniCUDA124/include/cuda/std/detail/libcxx/include/__type_traits/is_assignable.h

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_void.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template<typename, typename _Tp> struct __select_2nd { typedef _LIBCUDACXX_NODEBUG_TYPE _Tp type; };
+
+#if defined(_LIBCUDACXX_IS_ASSIGNABLE) && !defined(_LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK)
+
+template <class _T1, class _T2> struct _LIBCUDACXX_TEMPLATE_VIS is_assignable
+    : public integral_constant<bool, _LIBCUDACXX_IS_ASSIGNABLE(_T1, _T2)>
+    {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _T1, class _T2>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_assignable_v = _LIBCUDACXX_IS_ASSIGNABLE(_T1, _T2);
+#endif
+
+#else
+
+template <class _Tp, class _Arg>
+_LIBCUDACXX_INLINE_VISIBILITY
+typename __select_2nd<decltype((_CUDA_VSTD::declval<_Tp>() = _CUDA_VSTD::declval<_Arg>())), true_type>::type
+__is_assignable_test(int);
+
+template <class, class>
+_LIBCUDACXX_INLINE_VISIBILITY
+false_type __is_assignable_test(...);
+
+template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
+struct __is_assignable_imp
+    : public decltype((_CUDA_VSTD::__is_assignable_test<_Tp, _Arg>(0))) {};
+
+template <class _Tp, class _Arg>
+struct __is_assignable_imp<_Tp, _Arg, true>
+    : public false_type
+{
+};
+
+template <class _Tp, class _Arg>
+struct is_assignable
+    : public __is_assignable_imp<_Tp, _Arg> {};
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp, class _Arg>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_assignable_v = is_assignable<_Tp, _Arg>::value;
+#endif
+
+#endif // defined(_LIBCUDACXX_IS_ASSIGNABLE) && !defined(_LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H