diff --git a/.gitattributes b/.gitattributes
index 54ceef1f14c8b6c4229ac0fc215e72a244e27f24..0113b536332f708c3c7541cfe7173a0e7f26b52b 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -92,3 +92,4 @@ 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/ptxas.exe filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvprof.exe filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/bin/npps64_12.dll filter=lfs diff=lfs merge=lfs -text
diff --git a/miniCUDA124/bin/npps64_12.dll b/miniCUDA124/bin/npps64_12.dll
new file mode 100644
index 0000000000000000000000000000000000000000..549e0e6d5da11e87ffa266f9a981a1da78b1efda
--- /dev/null
+++ b/miniCUDA124/bin/npps64_12.dll
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adca8a91eb74badd854caa136d4dc9d8a6da486ec251c9f6c698132722aa3a18
+size 12743168
diff --git a/miniCUDA124/include/thrust/detail/allocator/allocator_traits.h b/miniCUDA124/include/thrust/detail/allocator/allocator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..28ea728057da04b77f5ed7ede4201472dea1ef5a
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/allocator_traits.h
@@ -0,0 +1,450 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// allocator_traits::rebind_alloc and allocator::rebind_traits are from libc++,
+// dual licensed under the MIT and the University of Illinois Open Source
+// Licenses.
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+#include <thrust/detail/type_traits.h>
+
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// forward declaration for has_member_system
+template<typename Alloc> struct allocator_system;
+
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_value_type, value_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_pointer, pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_pointer, const_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_reference, reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_reference, const_reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_void_pointer, void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_void_pointer, const_void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_difference_type, difference_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_size_type, size_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_move_assignment, propagate_on_container_move_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_swap, propagate_on_container_swap)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_system_type, system_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_is_always_equal, is_always_equal)
+__THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system)
+
+template<typename Alloc, typename U>
+  struct has_rebind
+{
+  typedef char yes_type;
+  typedef int  no_type;
+
+  template<typename S>
+  static yes_type test(typename S::template rebind<U>::other*);
+  template<typename S>
+  static no_type  test(...);
+
+  static bool const value = sizeof(test<U>(0)) == sizeof(yes_type);
+
+  typedef thrust::detail::integral_constant<bool, value> type;
+};
+
+// The following fields of std::allocator have been deprecated (since C++17).
+// There's no way to detect it other than explicit specialization.
+#if THRUST_CPP_DIALECT >= 2017
+#define THRUST_SPECIALIZE_DEPRECATED(trait_name)                               \
+template <typename T>                                                          \
+struct trait_name<std::allocator<T>> : false_type {};
+
+THRUST_SPECIALIZE_DEPRECATED(has_is_always_equal)
+THRUST_SPECIALIZE_DEPRECATED(has_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_const_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_reference)
+THRUST_SPECIALIZE_DEPRECATED(has_const_reference)
+
+#undef THRUST_SPECIALIZE_DEPRECATED
+
+template<typename T, typename U>
+struct has_rebind<std::allocator<T>, U> : false_type {};
+#endif
+
+template<typename T>
+  struct nested_pointer
+{
+  typedef typename T::pointer type;
+};
+
+template<typename T>
+  struct nested_const_pointer
+{
+  typedef typename T::const_pointer type;
+};
+
+template<typename T>
+  struct nested_reference
+{
+  typedef typename T::reference type;
+};
+
+template<typename T>
+  struct nested_const_reference
+{
+  typedef typename T::const_reference type;
+};
+
+template<typename T>
+  struct nested_void_pointer
+{
+  typedef typename T::void_pointer type;
+};
+
+template<typename T>
+  struct nested_const_void_pointer
+{
+  typedef typename T::const_void_pointer type;
+};
+
+template<typename T>
+  struct nested_difference_type
+{
+  typedef typename T::difference_type type;
+};
+
+template<typename T>
+  struct nested_size_type
+{
+  typedef typename T::size_type type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_copy_assignment
+{
+  typedef typename T::propagate_on_container_copy_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_move_assignment
+{
+  typedef typename T::propagate_on_container_move_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_swap
+{
+  typedef typename T::propagate_on_container_swap type;
+};
+
+template<typename T>
+  struct nested_is_always_equal
+{
+  typedef typename T::is_always_equal type;
+};
+
+template<typename T>
+  struct nested_system_type
+{
+  typedef typename T::system_type type;
+};
+
+template<typename Alloc>
+  struct has_member_system
+{
+  typedef typename allocator_system<Alloc>::type system_type;
+
+  typedef typename has_member_system_impl<Alloc, system_type&(void)>::type type;
+  static const bool value = type::value;
+};
+
+template<class Alloc, class U, bool = has_rebind<Alloc, U>::value>
+  struct rebind_alloc
+{
+    typedef typename Alloc::template rebind<U>::other type;
+};
+
+#if THRUST_CPP_DIALECT >= 2011
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, true>
+{
+    typedef typename Alloc<T, Args...>::template rebind<U>::other type;
+};
+
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, false>
+{
+    typedef Alloc<U, Args...> type;
+};
+#else // C++03
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, true>
+{
+    typedef typename Alloc<T>::template rebind<U>::other type;
+};
+
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, false>
+{
+    typedef Alloc<U> type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, true>
+{
+    typedef typename Alloc<T, A0>::template rebind<U>::other type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, false>
+{
+    typedef Alloc<U, A0> type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, true>
+{
+    typedef typename Alloc<T, A0, A1>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, false>
+{
+    typedef Alloc<U, A0, A1> type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, true>
+{
+    typedef typename Alloc<T, A0, A1, A2>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, false>
+{
+    typedef Alloc<U, A0, A1, A2> type;
+};
+#endif
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+  struct allocator_traits
+{
+  typedef Alloc allocator_type;
+
+  typedef typename allocator_type::value_type value_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_pointer<allocator_type>,
+    identity_<value_type*>
+  >::type pointer;
+
+  private:
+    template<typename T>
+      struct rebind_pointer
+    {
+      typedef typename pointer_traits<pointer>::template rebind<T>::other type;
+    };
+
+  public:
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_pointer<allocator_type>,
+    rebind_pointer<const value_type>
+  >::type const_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_void_pointer<allocator_type>,
+    rebind_pointer<void>
+  >::type void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_void_pointer<allocator_type>,
+    rebind_pointer<const void>
+  >::type const_void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_difference_type<allocator_type>::value,
+    allocator_traits_detail::nested_difference_type<allocator_type>,
+    pointer_difference<pointer>
+  >::type difference_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_size_type<allocator_type>::value,
+    allocator_traits_detail::nested_size_type<allocator_type>,
+    make_unsigned<difference_type>
+  >::type size_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_copy_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_copy_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_copy_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_move_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_move_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_move_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_swap<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_swap<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_swap;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+    allocator_traits_detail::nested_is_always_equal<allocator_type>,
+    is_empty<allocator_type>
+  >::type is_always_equal;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<allocator_type>::value,
+    allocator_traits_detail::nested_system_type<allocator_type>,
+    thrust::iterator_system<pointer>
+  >::type system_type;
+
+  // XXX rebind and rebind_traits are alias templates
+  //     and so are omitted while c++11 is unavailable
+
+#if THRUST_CPP_DIALECT >= 2011
+  template <typename U>
+  using rebind_alloc =
+    typename allocator_traits_detail::rebind_alloc<allocator_type, U>::type;
+
+  template <typename U>
+  using rebind_traits = allocator_traits<rebind_alloc<U>>;
+
+  // We define this nested type alias for compatibility with the C++03-style
+  // rebind_* mechanisms.
+  using other = allocator_traits;
+#else
+  template <typename U>
+  struct rebind_alloc
+  {
+    typedef typename
+      allocator_traits_detail::rebind_alloc<allocator_type, U>::type other;
+  };
+  template <typename U>
+  struct rebind_traits
+  {
+    typedef allocator_traits<typename rebind_alloc<U>::other> other;
+  };
+#endif
+
+  // Deprecated std::allocator typedefs that we need:
+  typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+  typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n);
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint);
+
+  inline __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n);
+
+  // XXX should probably change T* to pointer below and then relax later
+
+  template<typename T>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p);
+
+  template<typename T, typename Arg1>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, const Arg1 &arg1);
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename... Args>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, Args&&... args);
+#endif
+
+  template<typename T>
+  inline __host__ __device__ static void destroy(allocator_type &a, T *p);
+
+  inline __host__ __device__
+  static size_type max_size(const allocator_type &a);
+}; // end allocator_traits
+
+
+// we consider a type an allocator if T::value_type exists
+// it doesn't make much sense (containers, which are not allocators, will fulfill this requirement),
+// but allocator_traits is specified to work for any type with that nested typedef
+template<typename T>
+  struct is_allocator
+    : allocator_traits_detail::has_value_type<T>
+{};
+
+
+// XXX consider moving this non-standard functionality inside allocator_traits
+template<typename Alloc>
+  struct allocator_system
+{
+  // the type of the allocator's system
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<Alloc>::value,
+    allocator_traits_detail::nested_system_type<Alloc>,
+    thrust::iterator_system<
+      typename allocator_traits<Alloc>::pointer
+    >
+  >::type type;
+
+  // the type that get returns
+  typedef typename eval_if<
+    allocator_traits_detail::has_member_system<Alloc>::value, // if Alloc.system() exists
+    add_reference<type>,                                      // then get() needs to return a reference
+    identity_<type>                                           // else get() needs to return a value
+  >::type get_result_type;
+
+  __host__ __device__
+  inline static get_result_type get(Alloc &a);
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/allocator_traits.inl>
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/allocator_traits.inl b/miniCUDA124/include/thrust/detail/allocator/allocator_traits.inl
new file mode 100644
index 0000000000000000000000000000000000000000..aed3a68f0497266052c9ed9301aa26d75a481406
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/allocator_traits.inl
@@ -0,0 +1,473 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/is_call_possible.h>
+#include <thrust/detail/integer_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <thrust/detail/type_deduction.h>
+#endif
+
+#include <thrust/detail/memory_wrapper.h>
+#include <new>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+#if THRUST_CPP_DIALECT >= 2011
+
+// std::allocator's member functions are deprecated in C++17 and removed in
+// C++20, so we can't just use the generic implementation for allocator_traits
+// that calls the allocator's member functions.
+// Instead, specialize allocator_traits for std::allocator and defer to
+// std::allocator_traits<std::allocator> and let the STL do whatever it needs
+// to for the current c++ version. Manually forward the calls to suppress
+// host/device warnings.
+template <typename T>
+struct allocator_traits<std::allocator<T>>
+  : public std::allocator_traits<std::allocator<T>>
+{
+private:
+  using superclass = std::allocator_traits<std::allocator<T>>;
+
+public:
+  using allocator_type = typename superclass::allocator_type;
+  using value_type = typename superclass::value_type;
+  using pointer = typename superclass::pointer;
+  using const_pointer = typename superclass::const_pointer;
+  using void_pointer = typename superclass::void_pointer;
+  using const_void_pointer = typename superclass::const_void_pointer;
+  using difference_type = typename superclass::difference_type;
+  using size_type = typename superclass::size_type;
+  using propagate_on_container_swap = typename superclass::propagate_on_container_swap;
+  using propagate_on_container_copy_assignment =
+    typename superclass::propagate_on_container_copy_assignment;
+  using propagate_on_container_move_assignment =
+    typename superclass::propagate_on_container_move_assignment;
+
+  // std::allocator_traits added this in C++17, but thrust::allocator_traits defines
+  // it unconditionally.
+  using is_always_equal = typename eval_if<
+      allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+      allocator_traits_detail::nested_is_always_equal<allocator_type>,
+      is_empty<allocator_type>
+    >::type;
+
+  // std::allocator_traits doesn't provide these, but
+  // thrust::detail::allocator_traits does. These used to be part of the
+  // std::allocator API but were deprecated in C++17.
+  using reference = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  template <typename U>
+  using rebind_alloc = std::allocator<U>;
+  template <typename U>
+  using rebind_traits = allocator_traits<std::allocator<U>>;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n)
+  {
+    return superclass::allocate(a, n);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint)
+  {
+    return superclass::allocate(a, n, hint);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n)
+  {
+    superclass::deallocate(a, p, n);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U, typename ...Args>
+  __host__ __device__
+  static void construct(allocator_type &a, U *p, Args&&... args)
+  {
+    superclass::construct(a, p, THRUST_FWD(args)...);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U>
+  __host__ __device__
+  static void destroy(allocator_type &a, U *p)
+  {
+    superclass::destroy(a, p);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static size_type max_size(const allocator_type &a)
+  {
+    return superclass::max_size(a);
+  }
+};
+
+#endif //  C++11
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate)
+
+template<typename Alloc>
+  class has_member_allocate_with_hint
+{
+  typedef typename allocator_traits<Alloc>::pointer            pointer;
+  typedef typename allocator_traits<Alloc>::size_type          size_type;
+  typedef typename allocator_traits<Alloc>::const_void_pointer const_void_pointer;
+
+  public:
+    typedef typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type,const_void_pointer)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return a.allocate(n,hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer)
+{
+  return a.allocate(n);
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct)
+
+template<typename Alloc, typename T>
+  struct has_member_construct1
+    : has_member_construct1_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &a, T *p)
+{
+  a.construct(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &, T *p)
+{
+  ::new(static_cast<void*>(p)) T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct)
+
+template<typename Alloc, typename T, typename Arg1>
+  struct has_member_construct2
+    : has_member_construct2_impl<Alloc, void(T*,const Arg1 &)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &a, T *p, const Arg1 &arg1)
+{
+  a.construct(p,arg1);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &, T *p, const Arg1 &arg1)
+{
+  ::new(static_cast<void*>(p)) T(arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_constructN_impl, construct)
+
+template<typename Alloc, typename T, typename... Args>
+  struct has_member_constructN
+    : has_member_constructN_impl<Alloc, void(T*, Args...)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &a, T* p, Args&&... args)
+{
+  a.construct(p, THRUST_FWD(args)...);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &, T* p, Args&&... args)
+{
+  ::new(static_cast<void*>(p)) T(THRUST_FWD(args)...);
+}
+
+#endif
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy)
+
+template<typename Alloc, typename T>
+  struct has_member_destroy
+    : has_member_destroy_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &a, T *p)
+{
+  a.destroy(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &, T *p)
+{
+  p->~T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size)
+
+template<typename Alloc>
+  class has_member_max_size
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+
+  public:
+    typedef typename has_member_max_size_impl<Alloc, size_type(void)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &a)
+{
+  return a.max_size();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &)
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+  return thrust::detail::integer_traits<size_type>::const_max;
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type &
+  >::type
+    system(Alloc &a)
+{
+  // return the allocator's system
+  return a.system();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type
+  >::type
+    system(Alloc &)
+{
+  // return a copy of a value-initialized system
+  return typename allocator_system<Alloc>::type();
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    typename allocator_traits<Alloc>::pointer
+      allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.allocate(n);
+    }
+  };
+
+  return workaround_warnings::allocate(a, n);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return allocator_traits_detail::allocate(a, n, hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  void allocator_traits<Alloc>
+    ::deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    void deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.deallocate(p,n);
+    }
+  };
+
+  return workaround_warnings::deallocate(a,p,n);
+}
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::construct(a,p);
+}
+
+template<typename Alloc>
+  template<typename T, typename Arg1>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, const Arg1 &arg1)
+{
+  return allocator_traits_detail::construct(a,p,arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename Alloc>
+  template<typename T, typename... Args>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, Args&&... args)
+{
+  return allocator_traits_detail::construct(a, p, THRUST_FWD(args)...);
+}
+
+#endif
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::destroy(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::destroy(a,p);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::size_type
+    allocator_traits<Alloc>
+      ::max_size(const allocator_type &a)
+{
+  return allocator_traits_detail::max_size(a);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_system<Alloc>::get_result_type
+    allocator_system<Alloc>
+      ::get(Alloc &a)
+{
+  return allocator_traits_detail::system(a);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.h b/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..034896c466b4fd10ac0b65186f10002b4c3dfcce
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result);
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.inl b/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ed07f115803f63c9e4cf4a1759df64b7f1097e26
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/copy_construct_range.inl
@@ -0,0 +1,318 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/tuple.h>
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator, typename InputType, typename OutputType>
+  struct copy_construct_with_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  copy_construct_with_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename Tuple>
+  inline __host__ __device__
+  void operator()(Tuple t)
+  {
+    const InputType &in = thrust::get<0>(t);
+    OutputType &out = thrust::get<1>(t);
+
+    allocator_traits<Allocator>::construct(a, &out, in);
+  }
+};
+
+
+// we need to use allocator_traits<Allocator>::construct() to
+// copy construct a T if either:
+// 1. Allocator has a 2-argument construct() member or
+// 2. T has a non-trivial copy constructor
+template<typename Allocator, typename T>
+  struct needs_copy_construct_via_allocator
+    : integral_constant<
+        bool,
+        (has_member_construct2<Allocator,T,T>::value || !has_trivial_copy_constructor<T>::value)
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// copy constructor, so we needn't consider or use its construct() member for copy construction
+template<typename U, typename T>
+  struct needs_copy_construct_via_allocator<std::allocator<U>, T>
+    : integral_constant<
+        bool,
+        !has_trivial_copy_constructor<T>::value
+      >
+{};
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy
+//     perhaps generic::uninitialized_copy could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &a,
+                                      const thrust::execution_policy<FromSystem> &,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+  ZipIterator end = begin;
+
+  // get a zip_iterator pointing to the end
+  const typename thrust::iterator_difference<InputIterator>::type n = thrust::distance(first,last);
+  thrust::advance(end,n);
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each
+  // note we use to_system to dispatch the for_each
+  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy_n
+//     perhaps generic::uninitialized_copy_n could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &a,
+                                        const thrust::execution_policy<FromSystem> &,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each_n
+  // note we use to_system to dispatch the for_each_n
+  ZipIterator end = thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &,
+                                      const thrust::execution_policy<FromSystem> &from_system,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy and hope for the best
+  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
+} // end uninitialized_copy_with_allocator()
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &,
+                                        const thrust::execution_policy<FromSystem> &from_system,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy_n and hope for the best
+  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
+} // end uninitialized_copy_with_allocator_n()
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  // just call two_system_copy
+  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  // just call two_system_copy_n
+  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
+}
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/default_construct_range.h b/miniCUDA124/include/thrust/detail/allocator/default_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..42f5629db78e979cce71f3cb65bcabfe23ef26be
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/default_construct_range.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+inline void default_construct_range(Allocator &a, Pointer p, Size n);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/default_construct_range.inl>
+
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/default_construct_range.inl b/miniCUDA124/include/thrust/detail/allocator/default_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..08272e1b278e9ae4521d272b15cdddc90dc3326e
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/default_construct_range.inl
@@ -0,0 +1,120 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator>
+  struct construct1_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  construct1_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::construct(a, &x);
+  }
+};
+
+
+// we need to construct T via the allocator if...
+template<typename Allocator, typename T>
+  struct needs_default_construct_via_allocator
+    : thrust::detail::or_<
+        has_member_construct1<Allocator,T>,               // if the Allocator does something interesting
+        thrust::detail::not_<has_trivial_constructor<T> > // or if T's default constructor does something interesting
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// default constructor, so we needn't use it for default construction
+// unless T's constructor does something interesting
+template<typename U, typename T>
+  struct needs_default_construct_via_allocator<std::allocator<U>, T>
+    : thrust::detail::not_<has_trivial_constructor<T> >
+{};
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct1_via_allocator<Allocator>(a));
+}
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename disable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::default_construct_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/destroy_range.h b/miniCUDA124/include/thrust/detail/allocator/destroy_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbc3056693501247642b3865d64e7792a3efd3d0
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/destroy_range.h
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  inline void destroy_range(Allocator &a, Pointer p, Size n);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/destroy_range.inl>
+
diff --git a/miniCUDA124/include/thrust/detail/allocator/destroy_range.inl b/miniCUDA124/include/thrust/detail/allocator/destroy_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..26af50495cfc96584f5bb531292f92c147003800
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/allocator/destroy_range.inl
@@ -0,0 +1,175 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+// destroy_range has three cases:
+// if Allocator has an effectful member function destroy:
+//   1. destroy via the allocator
+// else
+//   2. if T has a non-trivial destructor, destroy the range without using the allocator
+//   3. if T has a trivial destructor, do a no-op
+
+template<typename Allocator, typename T>
+  struct has_effectful_member_destroy
+    : has_member_destroy<Allocator,T>
+{};
+
+// std::allocator::destroy's only effect is to invoke its argument's destructor
+template<typename U, typename T>
+  struct has_effectful_member_destroy<std::allocator<U>, T>
+    : thrust::detail::false_type
+{};
+
+// case 1: Allocator has an effectful 1-argument member function "destroy"
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case1
+    : thrust::detail::enable_if<
+        has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case2
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        !has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 3: Allocator has no member function "destroy", and T has a trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case3
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+
+
+template<typename Allocator>
+  struct destroy_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  destroy_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+
+// destroy_range case 1: destroy via allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case1<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+
+// we must prepare for His coming
+struct gozer
+{
+  __thrust_exec_check_disable__
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case2<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
+}
+
+
+// destroy_range case 3: no-op
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case3<Allocator,Pointer>::type
+    destroy_range(Allocator &, Pointer, Size)
+{
+  // no op
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void destroy_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::destroy_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/complex/c99math.h b/miniCUDA124/include/thrust/detail/complex/c99math.h
new file mode 100644
index 0000000000000000000000000000000000000000..16233e1b2f663d56d2bf192d0e40d09e05c1e13c
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/c99math.h
@@ -0,0 +1,205 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <math.h>
+#include <cmath>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+// Define basic arithmetic functions so we can use them without explicit scope
+// keeping the code as close as possible to FreeBSDs for ease of maintenance.
+// It also provides an easy way to support compilers with missing C99 functions.
+// When possible, just use the names in the global scope.
+// Some platforms define these as macros, others as free functions.
+// Avoid using the std:: form of these as nvcc may treat std::foo() as __host__ functions.
+
+using ::log;
+using ::acos;
+using ::asin;
+using ::sqrt;
+using ::sinh;
+using ::tan;
+using ::cos;
+using ::sin;
+using ::exp;
+using ::cosh;
+using ::atan;
+
+template <typename T>
+inline __host__ __device__ T infinity();
+
+template <>
+inline __host__ __device__ float infinity<float>()
+{
+  float res;
+  set_float_word(res, 0x7f800000);
+  return res;
+}
+
+
+template <>
+inline __host__ __device__ double infinity<double>()
+{
+  double res;
+  insert_words(res, 0x7ff00000,0);
+  return res;
+}
+
+#if defined _MSC_VER
+__host__ __device__ inline int isinf(float x){
+  return std::abs(x) == infinity<float>();
+}
+
+__host__ __device__ inline int isinf(double x){
+  return std::abs(x) == infinity<double>();
+}
+
+__host__ __device__ inline int isnan(float x){
+  return x != x;
+}
+
+__host__ __device__ inline int isnan(double x){
+  return x != x;
+}
+
+__host__ __device__ inline int signbit(float x){
+  return ((*((uint32_t *)&x)) & 0x80000000) != 0 ? 1 : 0;
+}
+
+__host__ __device__ inline int signbit(double x){
+  return ((*((uint64_t *)&x)) & 0x8000000000000000) != 0ull ? 1 : 0;
+}
+
+__host__ __device__ inline int isfinite(float x){
+  return !isnan(x) && !isinf(x);
+}
+
+__host__ __device__ inline int isfinite(double x){
+  return !isnan(x) && !isinf(x);
+}
+
+#else
+
+#  if defined(__CUDACC__) && !(defined(__CUDA__) && defined(__clang__)) && !defined(_NVHPC_CUDA)
+// NVCC implements at least some signature of these as functions not macros.
+using ::isinf;
+using ::isnan;
+using ::signbit;
+using ::isfinite;
+#  else
+// Some compilers do not provide these in the global scope, because they are
+// supposed to be macros. The versions in `std` are supposed to be functions.
+// Since we're not compiling with nvcc, it's safe to use the functions in std::
+using std::isinf;
+using std::isnan;
+using std::signbit;
+using std::isfinite;
+#  endif // __CUDACC__
+#endif // _MSC_VER
+
+using ::atanh;
+
+#if defined _MSC_VER
+
+__host__ __device__ inline double copysign(double x, double y){
+  uint32_t hx,hy;
+  get_high_word(hx,x);
+  get_high_word(hy,y);
+  set_high_word(x,(hx&0x7fffffff)|(hy&0x80000000));
+  return x;
+}
+
+__host__ __device__ inline float copysignf(float x, float y){
+  uint32_t ix,iy;
+  get_float_word(ix,x);
+  get_float_word(iy,y);
+  set_float_word(x,(ix&0x7fffffff)|(iy&0x80000000));
+  return x;
+}
+
+
+
+#if !defined(__CUDACC__) && !defined(_NVHPC_CUDA)
+
+// Simple approximation to log1p as Visual Studio is lacking one
+inline double log1p(double x){
+  double u = 1.0+x;
+  if(u == 1.0){
+    return x;
+  }else{
+    if(u > 2.0){
+      // Use normal log for large arguments
+      return log(u);
+    }else{
+      return log(u)*(x/(u-1.0));
+    }
+  }
+}
+
+inline float log1pf(float x){
+  float u = 1.0f+x;
+  if(u == 1.0f){
+    return x;
+  }else{
+    if(u > 2.0f){
+      // Use normal log for large arguments
+      return logf(u);
+    }else{
+      return logf(u)*(x/(u-1.0f));
+    }
+  }
+}
+
+#if _MSV_VER <= 1500
+#include <complex>
+
+inline float hypotf(float x, float y){
+	return abs(std::complex<float>(x,y));
+}
+
+inline double hypot(double x, double y){
+	return _hypot(x,y);
+}
+
+#endif // _MSC_VER <= 1500
+
+#endif // __CUDACC__
+
+#endif // _MSC_VER
+
+} // namespace complex
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/complex/catrig.h b/miniCUDA124/include/thrust/detail/complex/catrig.h
new file mode 100644
index 0000000000000000000000000000000000000000..b841ddb266d356ef1fdf8e6814979c067c88c211
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/catrig.h
@@ -0,0 +1,794 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/catrig.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__
+inline void raise_inexact(){
+  const volatile float tiny = 7.888609052210118054117286e-31; /* 0x1p-100; */
+  // needs the volatile to prevent compiler from ignoring it
+  volatile float junk = 1 + tiny;
+  (void)junk;
+}
+
+__host__ __device__ inline complex<double> clog_for_large_values(complex<double> z);
+
+/*
+ * Testing indicates that all these functions are accurate up to 4 ULP.
+ * The functions casin(h) and cacos(h) are about 2.5 times slower than asinh.
+ * The functions catan(h) are a little under 2 times slower than atanh.
+ *
+ * The code for casinh, casin, cacos, and cacosh comes first.  The code is
+ * rather complicated, and the four functions are highly interdependent.
+ *
+ * The code for catanh and catan comes at the end.  It is much simpler than
+ * the other functions, and the code for these can be disconnected from the
+ * rest of the code.
+ */
+
+/*
+ *			================================
+ *			| casinh, casin, cacos, cacosh |
+ *			================================
+ */
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * Throughout we use the convention z = x + I*y.
+ *
+ * casinh(z) = sign(x)*log(A+sqrt(A*A-1)) + I*asin(B)
+ * where
+ * A = (|z+I| + |z-I|) / 2
+ * B = (|z+I| - |z-I|) / 2 = y/A
+ *
+ * These formulas become numerically unstable:
+ *   (a) for Re(casinh(z)) when z is close to the line segment [-I, I] (that
+ *       is, Re(casinh(z)) is close to 0);
+ *   (b) for Im(casinh(z)) when z is close to either of the intervals
+ *       [I, I*infinity) or (-I*infinity, -I] (that is, |Im(casinh(z))| is
+ *       close to PI/2).
+ *
+ * These numerical problems are overcome by defining
+ * f(a, b) = (hypot(a, b) - b) / 2 = a*a / (hypot(a, b) + b) / 2
+ * Then if A < A_crossover, we use
+ *   log(A + sqrt(A*A-1)) = log1p((A-1) + sqrt((A-1)*(A+1)))
+ *   A-1 = f(x, 1+y) + f(x, 1-y)
+ * and if B > B_crossover, we use
+ *   asin(B) = atan2(y, sqrt(A*A - y*y)) = atan2(y, sqrt((A+y)*(A-y)))
+ *   A-y = f(x, y+1) + f(x, y-1)
+ * where without loss of generality we have assumed that x and y are
+ * non-negative.
+ *
+ * Much of the difficulty comes because the intermediate computations may
+ * produce overflows or underflows.  This is dealt with in the paper by Hull
+ * et al by using exception handling.  We do this by detecting when
+ * computations risk underflow or overflow.  The hardest part is handling the
+ * underflows when computing f(a, b).
+ *
+ * Note that the function f(a, b) does not appear explicitly in the paper by
+ * Hull et al, but the idea may be found on pages 308 and 309.  Introducing the
+ * function f(a, b) allows us to concentrate many of the clever tricks in this
+ * paper into one function.
+ */
+
+/*
+ * Function f(a, b, hypot_a_b) = (hypot(a, b) - b) / 2.
+ * Pass hypot(a, b) as the third argument.
+ */
+__host__ __device__
+inline double
+f(double a, double b, double hypot_a_b)
+{
+  if (b < 0)
+    return ((hypot_a_b - b) / 2);
+  if (b == 0)
+    return (a / 2);
+  return (a * a / (hypot_a_b + b) / 2);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__
+inline void
+do_hard_work(double x, double y, double *rx, int *B_is_usable, double *B,
+			double *sqrt_A2my2, double *new_y)
+{
+  double R, S, A; /* A, B, R, and S are as in Hull et al. */
+  double Am1, Amy; /* A-1, A-y. */
+  const double A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const double FOUR_SQRT_MIN = 5.966672584960165394632772e-154; /* =0x1p-509; >= 4 * sqrt(DBL_MIN) */
+  const double B_crossover = 0.6417; /* suggested by Hull et al */
+
+  R = hypot(x, y + 1);		/* |z+I| */
+  S = hypot(x, y - 1);		/* |z-I| */
+
+  /* A = (|z+I| + |z-I|) / 2 */
+  A = (R + S) / 2;
+  /*
+   * Mathematically A >= 1.  There is a small chance that this will not
+   * be so because of rounding errors.  So we will make certain it is
+   * so.
+   */
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    /*
+     * Am1 = fp + fm, where fp = f(x, 1+y), and fm = f(x, 1-y).
+     * rx = log1p(Am1 + sqrt(Am1*(A+1)))
+     */
+    if (y == 1 && x < DBL_EPSILON * DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *rx = sqrt(x);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON^2/128 >= FOUR_SQRT_MIN
+       */
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1p(Am1 + sqrt(Am1 * (A + 1)));
+    } else if (y < 1) {
+      /*
+       * fp = x*x/(1+y)/4, fm = x*x/(1-y)/4, and
+       * A = 1 (inexactly).
+       */
+      *rx = x / sqrt((1 - y) * (1 + y));
+    } else {		/* if (y > 1) */
+      /*
+       * A-1 = y-1 (inexactly).
+       */
+      *rx = log1p((y - 1) + sqrt((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = log(A + sqrt(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    /*
+     * Avoid a possible underflow caused by y/A.  For casinh this
+     * would be legitimate, but will be picked up by invoking atan2
+     * later on.  For cacos this would not be legitimate.
+     */
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / DBL_EPSILON);
+    *new_y = y * (2 / DBL_EPSILON);
+    return;
+  }
+
+  /* B = (|z+I| - |z-I|) / 2 = y/A */
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    /*
+     * Amy = fp + fm, where fp = f(x, y+1), and fm = f(x, y-1).
+     * sqrt_A2my2 = sqrt(Amy*(A+y))
+     */
+    if (y == 1 && x < DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt(x) * sqrt((A + y) / 2);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON/128 >= FOUR_SQRT_MIN
+       * and
+       * x >= DBL_EPSILON^2 >= FOUR_SQRT_MIN
+       */
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrt(Amy * (A + y));
+    } else if (y > 1) {
+      /*
+       * fp = x*x/(y+1)/4, fm = x*x/(y-1)/4, and
+       * A = y (inexactly).
+       *
+       * y < RECIP_EPSILON.  So the following
+       * scaling should avoid any underflow problems.
+       */
+      *sqrt_A2my2 = x * (4 / DBL_EPSILON / DBL_EPSILON) * y /
+	sqrt((y + 1) * (y - 1));
+      *new_y = y * (4 / DBL_EPSILON / DBL_EPSILON);
+    } else {		/* if (y < 1) */
+      /*
+       * fm = 1-y >= DBL_EPSILON, fp is of order x^2, and
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt((1 - y) * (1 + y));
+    }
+  }
+}
+
+/*
+ * casinh(z) = z + O(z^3)   as z -> 0
+ *
+ * casinh(z) = sign(x)*clog(sign(x)*z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the imaginary part as well, because
+ * Im(casinh(z)) = sign(x)*atan2(sign(x)*y, fabs(x)) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> casinh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<double> w;
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
+    if (isinf(x))
+      return (complex<double>(x, y + y));
+    /* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
+    if (isinf(y))
+      return (complex<double>(y, x + x));
+    /* casinh(NaN + I*0) = NaN + I*0 */
+    if (y == 0)
+      return (complex<double>(x + x, y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0.0), x + 0.0 + (y + 0.0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<double>(copysign(w.real(), x), copysign(w.imag(), y)));
+  }
+
+  /* Avoid spuriously raising inexact for z = 0. */
+  if (x == 0 && y == 0)
+    return (z);
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asin(B);
+  else
+    ry = atan2(new_y, sqrt_A2my2);
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * casin(z) = reverse(casinh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double> casin(complex<double> z)
+{
+  complex<double> w = casinh(complex<double>(z.imag(), z.real()));
+
+  return (complex<double>(w.imag(), w.real()));
+}
+
+/*
+ * cacos(z) = PI/2 - casin(z)
+ * but do the computation carefully so cacos(z) is accurate when z is
+ * close to 1.
+ *
+ * cacos(z) = PI/2 - z + O(z^3)   as z -> 0
+ *
+ * cacos(z) = -sign(y)*I*clog(z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(cacos(z)) = atan2(fabs(y), x) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> cacos(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<double> w;
+  const double pio2_hi = 1.5707963267948966e0; /*  0x1921fb54442d18.0p-52 */
+  const volatile double pio2_lo = 6.1232339957367659e-17;	/*  0x11a62633145c07.0p-106 */
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
+    if (isinf(x))
+      return (complex<double>(y + y, -infinity<double>()));
+    /* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
+    if (isinf(y))
+      return (complex<double>(x + x, -y));
+    /* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
+    if (x == 0)
+      return (complex<double>(pio2_hi + pio2_lo, y + y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    w = clog_for_large_values(z);
+    rx = fabs(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<double>(rx, ry));
+  }
+
+  /* Avoid spuriously raising inexact for z = 1. */
+  if (x == 1.0 && y == 0.0)
+    return (complex<double>(0, -y));
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<double>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acos(B);
+    else
+      rx = acos(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2(sqrt_A2mx2, new_x);
+    else
+      rx = atan2(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<double>(rx, ry));
+}
+
+/*
+ * cacosh(z) = I*cacos(z) or -I*cacos(z)
+ * where the sign is chosen so Re(cacosh(z)) >= 0.
+ */
+__host__ __device__ inline
+complex<double> cacosh(complex<double> z)
+{
+  complex<double> w;
+  double rx, ry;
+
+  w = cacos(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<double>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<double>(fabs(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<double>(ry, ry));
+  return (complex<double>(fabs(ry), copysign(rx, z.imag())));
+}
+
+/*
+ * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+ */
+__host__ __device__ inline
+complex<double> clog_for_large_values(complex<double> z)
+{
+  double x, y;
+  double ax, ay, t;
+  const double m_e = 2.7182818284590452e0; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * Avoid overflow in hypot() when x and y are both very large.
+   * Divide x and y by E, and then add 1 to the logarithm.  This depends
+   * on E being larger than sqrt(2).
+   * Dividing by E causes an insignificant loss of accuracy; however
+   * this method is still poor since it is uneccessarily slow.
+   */
+  if (ax > DBL_MAX / 2)
+    return (complex<double>(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
+
+  /*
+   * Avoid overflow when x or y is large.  Avoid underflow when x or
+   * y is small.
+   */
+  const double QUARTER_SQRT_MAX = 5.966672584960165394632772e-154; /* = 0x1p509; <= sqrt(DBL_MAX) / 4 */
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<double>(log(hypot(x, y)), atan2(y, x)));
+
+  return (complex<double>(log(ax * ax + ay * ay) / 2, atan2(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+   * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+   * Assumes x*x and y*y will not overflow.
+   * Assumes x and y are finite.
+   * Assumes y is non-negative.
+   * Assumes fabs(x) >= DBL_EPSILON.
+   */
+__host__ __device__
+inline double sum_squares(double x, double y)
+{
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+/*
+ * real_part_reciprocal(x, y) = Re(1/(x+I*y)) = x/(x*x + y*y).
+ * Assumes x and y are not NaN, and one of x and y is larger than
+ * RECIP_EPSILON.  We avoid unwarranted underflow.  It is important to not use
+ * the code creal(1/z), because the imaginary part may produce an unwanted
+ * underflow.
+ * This is only called in a context where inexact is always raised before
+ * the call, so no effort is made to avoid or force inexact.
+ */
+__host__ __device__
+inline double real_part_reciprocal(double x, double y)
+{
+  double scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  /*
+   * This code is inspired by the C99 document n1124.pdf, Section G.5.1,
+   * example 2.
+   */
+  get_high_word(hx, x);
+  ix = hx & 0x7ff00000;
+  get_high_word(hy, y);
+  iy = hy & 0x7ff00000;
+  //#define	BIAS	(DBL_MAX_EXP - 1)
+  const int BIAS = DBL_MAX_EXP - 1;
+  /* XXX more guard digits are useful iff there is extra precision. */
+  //#define	CUTOFF	(DBL_MANT_DIG / 2 + 1)	/* just half or 1 guard digit */
+  const int CUTOFF = (DBL_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 20 || isinf(x))
+    return (1 / x);		/* +-Inf -> +-0 is special */
+  if (iy - ix >= CUTOFF << 20)
+    return (x / y / y);	/* should avoid double div, but hard */
+  if (ix <= (BIAS + DBL_MAX_EXP / 2 - CUTOFF) << 20)
+    return (x / (x * x + y * y));
+  scale = 1;
+  set_high_word(scale, 0x7ff00000 - ix);	/* 2**(1-ilogb(x)) */
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+
+/*
+ * catanh(z) = log((1+z)/(1-z)) / 2
+ *           = log1p(4*x / |z-1|^2) / 4
+ *             + I * atan2(2*y, (1-x)*(1+x)-y*y) / 2
+ *
+ * catanh(z) = z + O(z^3)   as z -> 0
+ *
+ * catanh(z) = 1/z + sign(y)*I*PI/2 + O(1/z^3)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(catanh(z)) = x/|z|^2 + O(x/z^4)
+ *    as z -> infinity, uniformly in x
+ */
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<double> catanh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry;
+  const volatile double pio2_lo = 6.1232339957367659e-17; /*  0x11a62633145c07.0p-106 */
+  const double pio2_hi = 1.5707963267948966e0;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  /* This helps handle many cases. */
+  if (y == 0 && ax <= 1)
+    return (complex<double>(atanh(x), y));
+
+  /* To ensure the same accuracy as atan(), and to filter out z = 0. */
+  if (x == 0)
+    return (complex<double>(x, atan(y)));
+
+  if (isnan(x) || isnan(y)) {
+    /* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
+    if (isinf(x))
+      return (complex<double>(copysign(0.0, x), y + y));
+    /* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
+    if (isinf(y))
+      return (complex<double>(copysign(0.0, x),
+			      copysign(pio2_hi + pio2_lo, y)));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<double>(real_part_reciprocal(x, y),
+			    copysign(pio2_hi + pio2_lo, y)));
+
+  const double SQRT_3_EPSILON = 2.5809568279517849e-8; /*  0x1bb67ae8584caa.0p-78 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    /*
+     * z = 0 was filtered out above.  All other cases must raise
+     * inexact, but this is the only only that needs to do it
+     * explicitly.
+     */
+    raise_inexact();
+    return (z);
+  }
+
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  if (ax == 1 && ay < DBL_EPSILON)
+    rx = (m_ln2 - log(ay)) / 2;
+  else
+    rx = log1p(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2(2.0, -ay) / 2;
+  else if (ay < DBL_EPSILON)
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * catan(z) = reverse(catanh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double>catan(complex<double> z)
+{
+  complex<double> w = catanh(complex<double>(z.imag(), z.real()));
+  return (complex<double>(w.imag(), w.real()));
+}
+
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acos(const complex<ValueType>& z){
+  const complex<ValueType> ret = thrust::asin(z);
+  const ValueType pi = ValueType(3.14159265358979323846);
+  return complex<ValueType>(pi/2 - ret.real(),-ret.imag());
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asin(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*asinh(i*z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atan(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*thrust::atanh(i*z);
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acosh(const complex<ValueType>& z){
+  thrust::complex<ValueType> ret((z.real() - z.imag()) * (z.real() + z.imag()) - ValueType(1.0),
+				 ValueType(2.0) * z.real() * z.imag());
+  ret = thrust::sqrt(ret);
+  if (z.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  ret += z;
+  ret = thrust::log(ret);
+  if (ret.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  return ret;
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asinh(const complex<ValueType>& z){
+  return thrust::log(thrust::sqrt(z*z+ValueType(1))+z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atanh(const complex<ValueType>& z){
+  ValueType imag2 = z.imag() *  z.imag();
+  ValueType n = ValueType(1.0) + z.real();
+  n = imag2 + n * n;
+
+  ValueType d = ValueType(1.0) - z.real();
+  d = imag2 + d * d;
+  complex<ValueType> ret(ValueType(0.25) * (std::log(n) - std::log(d)),0);
+
+  d = ValueType(1.0) -  z.real() * z.real() - imag2;
+
+  ret.imag(ValueType(0.5) * std::atan2(ValueType(2.0) * z.imag(), d));
+  return ret;
+}
+
+template <>
+__host__ __device__
+inline complex<double> acos(const complex<double>& z){
+  return detail::complex::cacos(z);
+}
+
+template <>
+__host__ __device__
+inline complex<double> asin(const complex<double>& z){
+  return detail::complex::casin(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atan(const complex<double>& z){
+  return detail::complex::catan(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<double> acosh(const complex<double>& z){
+  return detail::complex::cacosh(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<double> asinh(const complex<double>& z){
+  return detail::complex::casinh(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atanh(const complex<double>& z){
+  return detail::complex::catanh(z);
+}
+#endif
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/catrigf.h b/miniCUDA124/include/thrust/detail/complex/catrigf.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e4166bb0e42b88e26cb6943eab7349693ccb2b1
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/catrigf.h
@@ -0,0 +1,509 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/catrig.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__ inline
+      complex<float> clog_for_large_values(complex<float> z);
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * See catrig.c for complete comments.
+ *
+ * XXX comments were removed automatically, and even short ones on the right
+ * of statements were removed (all of them), contrary to normal style.  Only
+ * a few comments on the right of declarations remain.
+ */
+
+__host__ __device__
+inline float
+f(float a, float b, float hypot_a_b)
+{
+  if (b < 0.0f)
+    return ((hypot_a_b - b) / 2.0f);
+  if (b == 0.0f)
+    return (a / 2.0f);
+  return (a * a / (hypot_a_b + b) / 2.0f);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__
+inline void
+do_hard_work(float x, float y, float *rx, int *B_is_usable, float *B,
+	     float *sqrt_A2my2, float *new_y)
+{
+  float R, S, A; /* A, B, R, and S are as in Hull et al. */
+  float Am1, Amy; /* A-1, A-y. */
+  const float A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const float FOUR_SQRT_MIN = 4.336808689942017736029811e-19f;; /* =0x1p-61; >= 4 * sqrt(FLT_MIN) */
+  const float B_crossover = 0.6417f; /* suggested by Hull et al */
+  R = hypotf(x, y + 1);
+  S = hypotf(x, y - 1);
+
+  A = (R + S) / 2;
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    if (y == 1 && x < FLT_EPSILON * FLT_EPSILON / 128) {
+      *rx = sqrtf(x);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1pf(Am1 + sqrtf(Am1 * (A + 1)));
+    } else if (y < 1) {
+      *rx = x / sqrtf((1 - y) * (1 + y));
+    } else {
+      *rx = log1pf((y - 1) + sqrtf((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = logf(A + sqrtf(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / FLT_EPSILON);
+    *new_y = y * (2 / FLT_EPSILON);
+    return;
+  }
+
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    if (y == 1 && x < FLT_EPSILON / 128) {
+      *sqrt_A2my2 = sqrtf(x) * sqrtf((A + y) / 2);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrtf(Amy * (A + y));
+    } else if (y > 1) {
+      *sqrt_A2my2 = x * (4 / FLT_EPSILON / FLT_EPSILON) * y /
+	sqrtf((y + 1) * (y - 1));
+      *new_y = y * (4 / FLT_EPSILON / FLT_EPSILON);
+    } else {
+      *sqrt_A2my2 = sqrtf((1 - y) * (1 + y));
+    }
+  }
+
+}
+
+__host__ __device__ inline
+complex<float>
+casinhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<float> w;
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(x, y + y));
+    if (isinf(y))
+      return (complex<float>(y, x + x));
+    if (y == 0)
+      return (complex<float>(x + x, y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<float>(copysignf(w.real(), x),
+			   copysignf(w.imag(), y)));
+  }
+
+  if (x == 0 && y == 0)
+    return (z);
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asinf(B);
+  else
+    ry = atan2f(new_y, sqrt_A2my2);
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float> casinf(complex<float> z)
+{
+  complex<float> w = casinhf(complex<float>(z.imag(), z.real()));
+
+  return (complex<float>(w.imag(), w.real()));
+}
+
+__host__ __device__ inline
+complex<float> cacosf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<float> w;
+  const float pio2_hi = 1.5707963267948966e0f; /*  0x1921fb54442d18.0p-52 */
+  const volatile float pio2_lo = 6.1232339957367659e-17f;	/*  0x11a62633145c07.0p-106 */
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(y + y, -infinity<float>()));
+    if (isinf(y))
+      return (complex<float>(x + x, -y));
+    if (x == 0)
+      return (complex<float>(pio2_hi + pio2_lo, y + y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    w = clog_for_large_values(z);
+    rx = fabsf(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<float>(rx, ry));
+  }
+
+  if (x == 1 && y == 0)
+    return (complex<float>(0, -y));
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<float>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acosf(B);
+    else
+      rx = acosf(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2f(sqrt_A2mx2, new_x);
+    else
+      rx = atan2f(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<float>(rx, ry));
+}
+
+__host__ __device__ inline
+complex<float> cacoshf(complex<float> z)
+{
+  complex<float> w;
+  float rx, ry;
+
+  w = cacosf(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<float>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<float>(fabsf(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<float>(ry, ry));
+  return (complex<float>(fabsf(ry), copysignf(rx, z.imag())));
+}
+
+  /*
+   * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+   */
+__host__ __device__ inline
+complex<float> clog_for_large_values(complex<float> z)
+{
+  float x, y;
+  float ax, ay, t;
+  const float m_e = 2.7182818284590452e0f; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  if (ax > FLT_MAX / 2)
+    return (complex<float>(logf(hypotf(x / m_e, y / m_e)) + 1,
+			   atan2f(y, x)));
+
+  const float QUARTER_SQRT_MAX = 2.3058430092136939520000000e+18f; /* = 0x1p61; <= sqrt(FLT_MAX) / 4 */
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<float>(logf(hypotf(x, y)), atan2f(y, x)));
+
+  return (complex<float>(logf(ax * ax + ay * ay) / 2, atan2f(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+ * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+ * Assumes x*x and y*y will not overflow.
+ * Assumes x and y are finite.
+ * Assumes y is non-negative.
+ * Assumes fabsf(x) >= FLT_EPSILON.
+ */
+__host__ __device__
+inline float sum_squares(float x, float y)
+{
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+__host__ __device__
+inline float real_part_reciprocal(float x, float y)
+{
+  float scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  get_float_word(hx, x);
+  ix = hx & 0x7f800000;
+  get_float_word(hy, y);
+  iy = hy & 0x7f800000;
+  //#define	BIAS	(FLT_MAX_EXP - 1)
+  const int BIAS = FLT_MAX_EXP - 1;
+  //#define	CUTOFF	(FLT_MANT_DIG / 2 + 1)
+  const int CUTOFF = (FLT_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 23 || isinf(x))
+    return (1 / x);
+  if (iy - ix >= CUTOFF << 23)
+    return (x / y / y);
+  if (ix <= (BIAS + FLT_MAX_EXP / 2 - CUTOFF) << 23)
+    return (x / (x * x + y * y));
+  set_float_word(scale, 0x7f800000 - ix);
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<float> catanhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry;
+  const volatile float pio2_lo = 6.1232339957367659e-17f; /*  0x11a62633145c07.0p-106 */
+  const float pio2_hi = 1.5707963267948966e0f;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+
+  if (y == 0 && ax <= 1)
+    return (complex<float>(atanhf(x), y));
+
+  if (x == 0)
+    return (complex<float>(x, atanf(y)));
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(copysignf(0, x), y + y));
+    if (isinf(y))
+      return (complex<float>(copysignf(0, x),
+			     copysignf(pio2_hi + pio2_lo, y)));
+    return (complex<float>(x + 0.0f + (y + 0.0f), x + 0.0f + (y + 0.0f)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<float>(real_part_reciprocal(x, y),
+			   copysignf(pio2_hi + pio2_lo, y)));
+
+  const float SQRT_3_EPSILON = 5.9801995673e-4f; /*  0x9cc471.0p-34 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    raise_inexact();
+    return (z);
+  }
+
+  const float m_ln2 = 6.9314718056e-1f; /*  0xb17218.0p-24 */
+  if (ax == 1 && ay < FLT_EPSILON)
+    rx = (m_ln2 - logf(ay)) / 2;
+  else
+    rx = log1pf(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2f(2, -ay) / 2;
+  else if (ay < FLT_EPSILON)
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float>catanf(complex<float> z){
+  complex<float> w = catanhf(complex<float>(z.imag(), z.real()));
+  return (complex<float>(w.imag(), w.real()));
+}
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <>
+__host__ __device__
+inline complex<float> acos(const complex<float>& z){
+  return detail::complex::cacosf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> asin(const complex<float>& z){
+  return detail::complex::casinf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atan(const complex<float>& z){
+  return detail::complex::catanf(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<float> acosh(const complex<float>& z){
+  return detail::complex::cacoshf(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<float> asinh(const complex<float>& z){
+  return detail::complex::casinhf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atanh(const complex<float>& z){
+  return detail::complex::catanhf(z);
+}
+#endif
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/ccosh.h b/miniCUDA124/include/thrust/detail/complex/ccosh.h
new file mode 100644
index 0000000000000000000000000000000000000000..24467ac073b207919d1cf2e93ff9fe534731f39a
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/ccosh.h
@@ -0,0 +1,223 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * 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 unmodified, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccosh.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+/*
+ * Hyperbolic cosine of a complex argument z = x + i y.
+ *
+ * cosh(z) = cosh(x+iy)
+ *         = cosh(x) cos(y) + i sinh(x) sin(y).
+ *
+ * Exceptional values are noted in the comments within the source code.
+ * These values and the return value were taken from n1124.pdf.
+ */
+
+__host__ __device__ inline
+thrust::complex<double> ccosh(const thrust::complex<double>& z){
+
+
+  const double huge = 8.98846567431157953864652595395e+307; // 0x1p1023
+  double x, y, h;
+  uint32_t hx, hy, ix, iy, lx, ly;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  extract_words(hy, ly, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+
+  /* Handle the nearly-non-exceptional cases where x and y are finite. */
+  if (ix < 0x7ff00000 && iy < 0x7ff00000) {
+    if ((iy | ly) == 0)
+      return (thrust::complex<double>(::cosh(x), x * y));
+    if (ix < 0x40360000)	/* small x: normal case */
+      return (thrust::complex<double>(::cosh(x) * ::cos(y), ::sinh(x) * ::sin(y)));
+
+    /* |x| >= 22, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x40862e42) {
+      /* x < 710: exp(|x|) won't overflow */
+      h = ::exp(::fabs(x)) * 0.5;
+      return (thrust::complex<double>(h * cos(y), copysign(h, x) * sin(y)));
+    } else if (ix < 0x4096bbaa) {
+      /* x < 1455: scale to avoid overflow */
+      thrust::complex<double> z_;
+      z_ = ldexp_cexp(thrust::complex<double>(fabs(x), y), -1);
+      return (thrust::complex<double>(z_.real(), z_.imag() * copysign(1.0, x)));
+    } else {
+      /* x >= 1455: the result always overflows */
+      h = huge * x;
+      return (thrust::complex<double>(h * h * cos(y), h * sin(y)));
+    }
+  }
+
+  /*
+   * cosh(+-0 +- I Inf) = dNaN + I sign(d(+-0, dNaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as dNaN.  Raise the invalid floating-point exception.
+   *
+   * cosh(+-0 +- I NaN) = d(NaN) + I sign(d(+-0, NaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   */
+  if ((ix | lx) == 0 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, copysign(0.0, x * (y - y))));
+
+  /*
+   * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0.
+   *
+   * cosh(NaN +- I 0)   = d(NaN) + I sign(d(NaN, +-0))0.
+   * The sign of 0 in the result is unspecified.
+   */
+  if ((iy | ly) == 0 && ix >= 0x7ff00000) {
+    if (((hx & 0xfffff) | lx) == 0)
+      return (thrust::complex<double>(x * x, copysign(0.0, x) * y));
+    return (thrust::complex<double>(x * x, copysign(0.0, (x + x) * y)));
+  }
+
+  /*
+   * cosh(x +- I Inf) = dNaN + I dNaN.
+   * Raise the invalid floating-point exception for finite nonzero x.
+   *
+   * cosh(x + I NaN) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero x.  Choice = don't raise (except for signaling NaNs).
+   */
+  if (ix < 0x7ff00000 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, x * (y - y)));
+
+  /*
+   * cosh(+-Inf + I NaN)  = +Inf + I d(NaN).
+   *
+   * cosh(+-Inf +- I Inf) = +Inf + I dNaN.
+   * The sign of Inf in the result is unspecified.  Choice = always +.
+   * Raise the invalid floating-point exception.
+   *
+   * cosh(+-Inf + I y)   = +Inf cos(y) +- I Inf sin(y)
+   */
+  if (ix >= 0x7ff00000 && ((hx & 0xfffff) | lx) == 0) {
+    if (iy >= 0x7ff00000)
+      return (thrust::complex<double>(x * x, x * (y - y)));
+    return (thrust::complex<double>((x * x) * cos(y), x * sin(y)));
+  }
+
+  /*
+   * cosh(NaN + I NaN)  = d(NaN) + I d(NaN).
+   *
+   * cosh(NaN +- I Inf) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception.
+   * Choice = raise.
+   *
+   * cosh(NaN + I y)    = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero y.  Choice = don't raise (except for signaling NaNs).
+   */
+  return (thrust::complex<double>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+
+__host__ __device__ inline
+thrust::complex<double> ccos(const thrust::complex<double>& z){
+  /* ccos(z) = ccosh(I * z) */
+  return (ccosh(thrust::complex<double>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cos(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cos(re) * std::cosh(im),
+			    -std::sin(re) * std::sinh(im));
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cosh(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cosh(re) * std::cos(im),
+			    std::sinh(re) * std::sin(im));
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cos(const thrust::complex<double>& z){
+  return detail::complex::ccos(z);
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cosh(const thrust::complex<double>& z){
+  return detail::complex::ccosh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/ccoshf.h b/miniCUDA124/include/thrust/detail/complex/ccoshf.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c91c26a21bd8c7d732963383912c7837fb061a9
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/ccoshf.h
@@ -0,0 +1,151 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * 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 unmodified, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccoshf.c
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__ inline
+complex<float> ccoshf(const complex<float>& z){
+  float x, y, h;
+  uint32_t hx, hy, ix, iy;
+  const float huge = 1.70141183460469231731687303716e+38; //0x1p127;
+
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hx, x);
+  get_float_word(hy, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+  if (ix < 0x7f800000 && iy < 0x7f800000) {
+    if (iy == 0){
+      return (complex<float>(coshf(x), x * y));
+    }
+    if (ix < 0x41100000){	/* small x: normal case */
+      return (complex<float>(coshf(x) * cosf(y), sinhf(x) * sinf(y)));
+    }
+    /* |x| >= 9, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x42b17218) {
+      /* x < 88.7: expf(|x|) won't overflow */
+      h = expf(fabsf(x)) * 0.5f;
+      return (complex<float>(h * cosf(y), copysignf(h, x) * sinf(y)));
+    } else if (ix < 0x4340b1e7) {
+      /* x < 192.7: scale to avoid overflow */
+      thrust::complex<float> z_;
+      z_ = ldexp_cexpf(complex<float>(fabsf(x), y), -1);
+      return (complex<float>(z_.real(), z_.imag() * copysignf(1.0f, x)));
+    } else {
+      /* x >= 192.7: the result always overflows */
+      h = huge * x;
+      return (complex<float>(h * h * cosf(y), h * sinf(y)));
+    }
+  }
+
+  if (ix == 0 && iy >= 0x7f800000){
+    return (complex<float>(y - y, copysignf(0.0f, x * (y - y))));
+  }
+  if (iy == 0 && ix >= 0x7f800000) {
+    if ((hx & 0x7fffff) == 0)
+      return (complex<float>(x * x, copysignf(0.0f, x) * y));
+    return (complex<float>(x * x, copysignf(0.0f, (x + x) * y)));
+  }
+
+  if (ix < 0x7f800000 && iy >= 0x7f800000){
+    return (complex<float>(y - y, x * (y - y)));
+  }
+
+  if (ix >= 0x7f800000 && (hx & 0x7fffff) == 0) {
+    if (iy >= 0x7f800000)
+      return (complex<float>(x * x, x * (y - y)));
+    return (complex<float>((x * x) * cosf(y), x * sinf(y)));
+  }
+  return (complex<float>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+__host__ __device__ inline
+complex<float> ccosf(const complex<float>& z){
+  return (ccoshf(complex<float>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> cos(const complex<float>& z){
+  return detail::complex::ccosf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> cosh(const complex<float>& z){
+  return detail::complex::ccoshf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/cexp.h b/miniCUDA124/include/thrust/detail/complex/cexp.h
new file mode 100644
index 0000000000000000000000000000000000000000..3377d083fc4ece6832408e3ee145298b08db496f
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/cexp.h
@@ -0,0 +1,193 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexp.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+/*
+ * Compute exp(x), scaled to avoid spurious overflow.  An exponent is
+ * returned separately in 'expt'.
+ *
+ * Input:  ln(DBL_MAX) <= x < ln(2 * DBL_MAX / DBL_MIN_DENORM) ~= 1454.91
+ * Output: 2**1023 <= y < 2**1024
+ */
+__host__ __device__ inline
+	double frexp_exp(double x, int *expt){
+  const uint32_t k = 1799;		/* constant for reduction */
+  const double kln2 =  1246.97177782734161156;	/* k * ln2 */
+
+  double exp_x;
+  uint32_t hx;
+
+  /*
+   * We use exp(x) = exp(x - kln2) * 2**k, carefully chosen to
+   * minimize |exp(kln2) - 2**k|.  We also scale the exponent of
+   * exp_x to MAX_EXP so that the result can be multiplied by
+   * a tiny number without losing accuracy due to denormalization.
+   */
+  exp_x = exp(x - kln2);
+  get_high_word(hx, exp_x);
+  *expt = (hx >> 20) - (0x3ff + 1023) + k;
+  set_high_word(exp_x, (hx & 0xfffff) | ((0x3ff + 1023) << 20));
+  return (exp_x);
+}
+
+
+__host__ __device__ inline
+complex<double>	ldexp_cexp(complex<double> z, int expt){
+  double x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_exp(x, &ex_expt);
+  expt += ex_expt;
+
+  /*
+   * Arrange so that scale1 * scale2 == 2**expt.  We use this to
+   * compensate for scalbn being horrendously slow.
+   */
+  half_expt = expt / 2;
+  insert_words(scale1, (0x3ff + half_expt) << 20, 0);
+  half_expt = expt - half_expt;
+  insert_words(scale2, (0x3ff + half_expt) << 20, 0);
+
+  return (complex<double>(cos(y) * exp_x * scale1 * scale2,
+			  sin(y) * exp_x * scale1 * scale2));
+}
+
+
+__host__ __device__ inline
+complex<double> cexp(const complex<double>& z){
+  double x, y, exp_x;
+  uint32_t hx, hy, lx, ly;
+
+  const uint32_t
+    exp_ovfl  = 0x40862e42,			/* high bits of MAX_EXP * ln2 ~= 710 */
+    cexp_ovfl = 0x4096b8e4;			/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hy, ly, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if ((hy | ly) == 0)
+    return (complex<double>(exp(x), y));
+  extract_words(hx, lx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if (((hx & 0x7fffffff) | lx) == 0)
+    return (complex<double>(cos(y), sin(y)));
+
+  if (hy >= 0x7ff00000) {
+    if (lx != 0 || (hx & 0x7fffffff) != 0x7ff00000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<double>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<double>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<double>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 709.7 and 1454.3, so we must scale to avoid
+     * overflow in exp(x).
+     */
+    return (ldexp_cexp(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<double>(exp_x * cos(y), exp_x * sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> exp(const complex<ValueType>& z){
+  return polar(std::exp(z.real()),z.imag());
+}
+
+template <>
+__host__ __device__
+inline complex<double> exp(const complex<double>& z){
+  return detail::complex::cexp(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/cexpf.h b/miniCUDA124/include/thrust/detail/complex/cexpf.h
new file mode 100644
index 0000000000000000000000000000000000000000..a666de6134093dd05ded64543f19cd44c5495e41
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/cexpf.h
@@ -0,0 +1,171 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexpf.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+__host__ __device__ inline
+float frexp_expf(float x, int *expt){
+  const uint32_t k = 235;                 /* constant for reduction */
+  const float kln2 =  162.88958740F;       /* k * ln2 */
+
+  // should this be a double instead?
+  float exp_x;
+  uint32_t hx;
+
+  exp_x = expf(x - kln2);
+  get_float_word(hx, exp_x);
+  *expt = (hx >> 23) - (0x7f + 127) + k;
+  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
+  return (exp_x);
+}
+
+__host__ __device__ inline
+complex<float>
+ldexp_cexpf(complex<float> z, int expt)
+{
+  float x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_expf(x, &ex_expt);
+  expt += ex_expt;
+
+  half_expt = expt / 2;
+  set_float_word(scale1, (0x7f + half_expt) << 23);
+  half_expt = expt - half_expt;
+  set_float_word(scale2, (0x7f + half_expt) << 23);
+
+  return (complex<float>(std::cos(y) * exp_x * scale1 * scale2,
+			 std::sin(y) * exp_x * scale1 * scale2));
+}
+
+__host__ __device__ inline
+complex<float> cexpf(const complex<float>& z){
+  float x, y, exp_x;
+  uint32_t hx, hy;
+
+  const uint32_t
+    exp_ovfl  = 0x42b17218,		/* MAX_EXP * ln2 ~= 88.722839355 */
+    cexp_ovfl = 0x43400074;		/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hy, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if (hy == 0)
+    return (complex<float>(std::exp(x), y));
+  get_float_word(hx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if ((hx & 0x7fffffff) == 0){
+    return (complex<float>(std::cos(y), std::sin(y)));
+  }
+  if (hy >= 0x7f800000) {
+    if ((hx & 0x7fffffff) != 0x7f800000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<float>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<float>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<float>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 88.7 and 192, so we must scale to avoid
+     * overflow in expf(x).
+     */
+    return (ldexp_cexpf(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<float>(exp_x * std::cos(y), exp_x * std::sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> exp(const complex<float>& z){
+  return detail::complex::cexpf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniCUDA124/include/thrust/detail/complex/clog.h b/miniCUDA124/include/thrust/detail/complex/clog.h
new file mode 100644
index 0000000000000000000000000000000000000000..b74419fe404ee732516afd4089a1f561178dcde4
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/complex/clog.h
@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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.
+ */
+
+/* adapted from FreeBSDs msun:*/
+
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+/* round down to 18 = 54/3 bits */
+__host__ __device__ inline
+double trim(double x){
+  uint32_t hi;
+  get_high_word(hi, x);
+  insert_words(x, hi &0xfffffff8, 0);
+  return x;
+}
+
+
+__host__ __device__ inline
+complex<double> clog(const complex<double>& z){
+
+  // Adapted from FreeBSDs msun
+  double x, y;
+  double ax, ay;
+  double x0, y0, x1, y1, x2, y2, t, hm1;
+  double val[12];
+  int i, sorted;
+  const double e = 2.7182818284590452354;
+
+  x = z.real();
+  y = z.imag();
+
+  /* Handle NaNs using the general formula to mix them right. */
+  if (x != x || y != y){
+    return (complex<double>(std::log(norm(z)), std::atan2(y, x)));
+  }
+
+  ax = std::abs(x);
+  ay = std::abs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * To avoid unnecessary overflow, if x and y are very large, divide x
+   * and y by M_E, and then add 1 to the logarithm.  This depends on
+   * M_E being larger than sqrt(2).
+   * There is a potential loss of accuracy caused by dividing by M_E,
+   * but this case should happen extremely rarely.
+   */
+  //    if (ay > 5e307){
+  // For high values of ay -> hypotf(DBL_MAX,ay) = inf
+  // We expect that for values at or below ay = 5e307 this should not happen
+  if (ay > 5e307){
+    return (complex<double>(std::log(hypot(x / e, y / e)) + 1.0, std::atan2(y, x)));
+  }
+  if (ax == 1.) {
+    if (ay < 1e-150){
+      return (complex<double>((ay * 0.5) * ay, std::atan2(y, x)));
+    }
+    return (complex<double>(log1p(ay * ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Because atan2 and hypot conform to C99, this also covers all the
+   * edge cases when x or y are 0 or infinite.
+   */
+  if (ax < 1e-50 || ay < 1e-50 || ax > 1e50 || ay > 1e50){
+    return (complex<double>(std::log(hypot(x, y)), std::atan2(y, x)));
+  }
+
+  /*
+   * From this point on, we don't need to worry about underflow or
+   * overflow in calculating ax*ax or ay*ay.
+   */
+
+  /* Some easy cases. */
+
+  if (ax >= 1.0){
+    return (complex<double>(log1p((ax-1)*(ax+1) + ay*ay) * 0.5, atan2(y, x)));
+  }
+
+  if (ax*ax + ay*ay <= 0.7){
+    return (complex<double>(std::log(ax*ax + ay*ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Take extra care so that ULP of real part is small if hypot(x,y) is
+   * moderately close to 1.
+   */
+
+
+  x0 = trim(ax);
+  ax = ax-x0;
+  x1 = trim(ax);
+  x2 = ax-x1;
+  y0 = trim(ay);
+  ay = ay-y0;
+  y1 = trim(ay);
+  y2 = ay-y1;
+
+  val[0] = x0*x0;
+  val[1] = y0*y0;
+  val[2] = 2*x0*x1;
+  val[3] = 2*y0*y1;
+  val[4] = x1*x1;
+  val[5] = y1*y1;
+  val[6] = 2*x0*x2;
+  val[7] = 2*y0*y2;
+  val[8] = 2*x1*x2;
+  val[9] = 2*y1*y2;
+  val[10] = x2*x2;
+  val[11] = y2*y2;
+
+  /* Bubble sort. */
+
+  do {
+    sorted = 1;
+    for (i=0;i<11;i++) {
+      if (val[i] < val[i+1]) {
+	sorted = 0;
+	t = val[i];
+	val[i] = val[i+1];
+	val[i+1] = t;
+      }
+    }
+  } while (!sorted);
+
+  hm1 = -1;
+  for (i=0;i<12;i++){
+    hm1 += val[i];
+  }
+  return (complex<double>(0.5 * log1p(hm1), atan2(y, x)));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log(const complex<ValueType>& z){
+  return complex<ValueType>(std::log(thrust::abs(z)),thrust::arg(z));
+}
+
+template <>
+__host__ __device__
+inline complex<double> log(const complex<double>& z){
+  return detail::complex::clog(z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log10(const complex<ValueType>& z){
+  // Using the explicit literal prevents compile time warnings in
+  // devices that don't support doubles
+  return thrust::log(z)/ValueType(2.30258509299404568402);
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/transform_scan.inl b/miniCUDA124/include/thrust/detail/transform_scan.inl
new file mode 100644
index 0000000000000000000000000000000000000000..513b28f90913038fe2cf00ac9350b2a997656b77
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/transform_scan.inl
@@ -0,0 +1,125 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/scan.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform_scan.h>
+#include <thrust/system/detail/adl/transform_scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_inclusive_scan;
+  return transform_inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_exclusive_scan;
+  return transform_exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename BinaryFunction>
+  OutputIterator transform_inclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_inclusive_scan(select_system(system1,system2), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+  OutputIterator transform_exclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_exclusive_scan(select_system(system1,system2), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/trivial_sequence.h b/miniCUDA124/include/thrust/detail/trivial_sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..e23bac7a6fdf9423eecb7de918021c9e02aa16a5
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/trivial_sequence.h
@@ -0,0 +1,104 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file trivial_sequence.h
+ *  \brief Container-like class for wrapping sequences.  The wrapped
+ *         sequence always has trivial iterators, even when the input
+ *         sequence does not.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// never instantiated
+template<typename Iterator, typename DerivedPolicy, typename is_trivial> struct _trivial_sequence { };
+
+// trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::true_type>
+{
+    typedef Iterator iterator_type;
+    Iterator first, last;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &, Iterator _first, Iterator _last) : first(_first), last(_last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return first; }
+
+    __host__ __device__
+    iterator_type end()   { return last; }
+};
+
+// non-trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::false_type>
+{
+    typedef typename thrust::iterator_value<Iterator>::type iterator_value;
+    typedef typename thrust::detail::temporary_array<iterator_value, DerivedPolicy>::iterator iterator_type;
+
+    thrust::detail::temporary_array<iterator_value, DerivedPolicy> buffer;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last)
+      : buffer(exec, first, last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return buffer.begin(); }
+
+    __host__ __device__
+    iterator_type end()   { return buffer.end(); }
+};
+
+template <typename Iterator, typename DerivedPolicy>
+struct trivial_sequence
+  : detail::_trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type>
+{
+    typedef _trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type> super_t;
+
+    __host__ __device__
+    trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last) : super_t(exec, first, last) { }
+};
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/tuple_algorithms.h b/miniCUDA124/include/thrust/detail/tuple_algorithms.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdaabfbbd3f243386c5e45d7d33286bb329a2b8a
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/tuple_algorithms.h
@@ -0,0 +1,118 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+#include <tuple>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Tuple, std::size_t... Is>
+auto tuple_subset(Tuple&& t, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(std::get<Is>(THRUST_FWD(t))...));
+
+namespace detail
+{
+
+template <typename Tuple, typename F, std::size_t... Is>
+void tuple_for_each_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+{
+  auto l = { (f(std::get<Is>(t)), 0)... };
+  THRUST_UNUSED_VAR(l);
+}
+
+template <typename Tuple, typename F, std::size_t... Is>
+auto tuple_transform_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(f(std::get<Is>(t))...));
+
+} // namespace detail
+
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/detail/tuple_meta_transform.h b/miniCUDA124/include/thrust/detail/tuple_meta_transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..2343c6b8510bec2efe9ba49e97f4d4c952a1da0a
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/tuple_meta_transform.h
@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/tuple.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// introduce an intermediate type tuple_meta_transform_WAR_NVCC
+// rather than directly specializing tuple_meta_transform with
+// default argument IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>
+// to workaround nvcc 11.0 compiler bug
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename IndexSequence>
+  struct tuple_meta_transform_WAR_NVCC;
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         size_t... Is>
+  struct tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::index_sequence<Is...>>
+{
+  typedef thrust::tuple<
+    typename UnaryMetaFunction<typename thrust::tuple_element<Is,Tuple>::type>::type...
+  > type;
+};
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction>
+  struct tuple_meta_transform
+{
+  typedef typename tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>::type type;
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/tuple_transform.h b/miniCUDA124/include/thrust/detail/tuple_transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..723ea1861c3239df69e99d18ef13d395e5790ada
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/tuple_transform.h
@@ -0,0 +1,92 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         typename IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>
+  struct tuple_transform_functor;
+
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         size_t... Is>
+  struct tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction,thrust::index_sequence<Is...>>
+{
+  static __host__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+
+  static __host__ __device__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host_or_device(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+};
+
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+tuple_host_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host(t,f);
+}
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+__host__ __device__
+tuple_host_device_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host_or_device(t,f);
+}
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/type_deduction.h b/miniCUDA124/include/thrust/detail/type_deduction.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca9507de225bbd2c66d96ea0c0fbd626b082d5f4
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/type_deduction.h
@@ -0,0 +1,98 @@
+// Copyright (c)      2018 NVIDIA Corporation
+//                         (Bryce Adelstein Lelbach <brycelelbach@gmail.com>)
+// Copyright (c) 2013-2018 Eric Niebler (`THRUST_RETURNS`, etc)
+// Copyright (c) 2016-2018 Casey Carter (`THRUST_RETURNS`, etc)
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/preprocessor.h>
+
+#include <utility>
+#include <type_traits>
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_FWD(x)
+/// \brief Performs universal forwarding of a universal reference.
+///
+#define THRUST_FWD(x) ::std::forward<decltype(x)>(x)
+
+/// \def THRUST_MVCAP(x)
+/// \brief Capture `x` into a lambda by moving.
+///
+#define THRUST_MVCAP(x) x = ::std::move(x)
+
+/// \def THRUST_RETOF(invocable, ...)
+/// \brief Expands to the type returned by invoking an instance of the invocable
+///        type \a invocable with parameters of type \c __VA_ARGS__. Must
+///        be called with 1 or fewer parameters to the invocable.
+///
+#define THRUST_RETOF(...)   THRUST_PP_DISPATCH(THRUST_RETOF, __VA_ARGS__)
+#define THRUST_RETOF1(C)    decltype(::std::declval<C>()())
+#define THRUST_RETOF2(C, V) decltype(::std::declval<C>()(::std::declval<V>()))
+
+/// \def THRUST_RETURNS(...)
+/// \brief Expands to a function definition that returns the expression
+///        \c __VA_ARGS__.
+///
+#define THRUST_RETURNS(...)                                                   \
+  noexcept(noexcept(__VA_ARGS__))                                             \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+
+/// \def THRUST_DECLTYPE_RETURNS(...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> decltype(__VA_ARGS__)                                                  \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+/// \def THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__. It shall only
+///        participate in overload resolution if \c condition is \c true.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)       \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> typename std::enable_if<condition, decltype(__VA_ARGS__)>::type        \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/detail/type_traits.h b/miniCUDA124/include/thrust/detail/type_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..31598bc479c2d3a13ef0ea9ac79bb6eb8dbbe42c
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/type_traits.h
@@ -0,0 +1,701 @@
+/*
+ *  Copyright 2008-2022 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file type_traits.h
+ *  \brief Temporarily define some type traits
+ *         until nvcc can compile tr1::type_traits.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <cuda/std/type_traits>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of device_reference
+template<typename T> class device_reference;
+
+namespace detail
+{
+ /// helper classes [4.3].
+template<typename T, T v>
+using integral_constant = ::cuda::std::integral_constant<T, v>;
+using true_type  = ::cuda::std::true_type;
+using false_type = ::cuda::std::false_type;
+
+//template<typename T> struct is_integral : public std::tr1::is_integral<T> {};
+template<typename T> struct is_integral                           : public false_type {};
+template<>           struct is_integral<bool>                     : public true_type {};
+template<>           struct is_integral<char>                     : public true_type {};
+template<>           struct is_integral<signed char>              : public true_type {};
+template<>           struct is_integral<unsigned char>            : public true_type {};
+template<>           struct is_integral<short>                    : public true_type {};
+template<>           struct is_integral<unsigned short>           : public true_type {};
+template<>           struct is_integral<int>                      : public true_type {};
+template<>           struct is_integral<unsigned int>             : public true_type {};
+template<>           struct is_integral<long>                     : public true_type {};
+template<>           struct is_integral<unsigned long>            : public true_type {};
+template<>           struct is_integral<long long>                : public true_type {};
+template<>           struct is_integral<unsigned long long>       : public true_type {};
+template<>           struct is_integral<const bool>               : public true_type {};
+template<>           struct is_integral<const char>               : public true_type {};
+template<>           struct is_integral<const unsigned char>      : public true_type {};
+template<>           struct is_integral<const short>              : public true_type {};
+template<>           struct is_integral<const unsigned short>     : public true_type {};
+template<>           struct is_integral<const int>                : public true_type {};
+template<>           struct is_integral<const unsigned int>       : public true_type {};
+template<>           struct is_integral<const long>               : public true_type {};
+template<>           struct is_integral<const unsigned long>      : public true_type {};
+template<>           struct is_integral<const long long>          : public true_type {};
+template<>           struct is_integral<const unsigned long long> : public true_type {};
+
+template<typename T> struct is_floating_point              : public false_type {};
+template<>           struct is_floating_point<float>       : public true_type {};
+template<>           struct is_floating_point<double>      : public true_type {};
+template<>           struct is_floating_point<long double> : public true_type {};
+
+template<typename T> struct is_arithmetic               : public is_integral<T> {};
+template<>           struct is_arithmetic<float>        : public true_type {};
+template<>           struct is_arithmetic<double>       : public true_type {};
+template<>           struct is_arithmetic<const float>  : public true_type {};
+template<>           struct is_arithmetic<const double> : public true_type {};
+
+template<typename T> struct is_pointer      : public false_type {};
+template<typename T> struct is_pointer<T *> : public true_type  {};
+
+template<typename T> struct is_device_ptr  : public false_type {};
+
+template<typename T> struct is_void             : public false_type {};
+template<>           struct is_void<void>       : public true_type {};
+template<>           struct is_void<const void> : public true_type {};
+
+template<typename T> struct is_non_bool_integral       : public is_integral<T> {};
+template<>           struct is_non_bool_integral<bool> : public false_type {};
+
+template<typename T> struct is_non_bool_arithmetic       : public is_arithmetic<T> {};
+template<>           struct is_non_bool_arithmetic<bool> : public false_type {};
+
+template<typename T> struct is_pod
+   : public integral_constant<
+       bool,
+       is_void<T>::value || is_pointer<T>::value || is_arithmetic<T>::value
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC || \
+    THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+// use intrinsic type traits
+       || __is_pod(T)
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+// only use the intrinsic for >= 4.3
+#if (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+       || __is_pod(T)
+#endif // GCC VERSION
+#endif // THRUST_HOST_COMPILER
+     >
+ {};
+
+
+template <typename T>
+struct has_trivial_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_constructible<T>::value>
+{};
+
+template<typename T>
+struct has_trivial_copy_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_copyable<T>::value>
+{};
+
+template<typename T> struct has_trivial_destructor : public is_pod<T> {};
+
+template<typename T> struct is_const          : public false_type {};
+template<typename T> struct is_const<const T> : public true_type {};
+
+template<typename T> struct is_volatile             : public false_type {};
+template<typename T> struct is_volatile<volatile T> : public true_type {};
+
+template<typename T>
+  struct add_const
+{
+  typedef T const type;
+}; // end add_const
+
+template<typename T>
+  struct remove_const
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct remove_const<const T>
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct add_volatile
+{
+  typedef volatile T type;
+}; // end add_volatile
+
+template<typename T>
+  struct remove_volatile
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct remove_volatile<volatile T>
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct add_cv
+{
+  typedef const volatile T type;
+}; // end add_cv
+
+template<typename T>
+  struct remove_cv
+{
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+}; // end remove_cv
+
+
+template<typename T> struct is_reference     : public false_type {};
+template<typename T> struct is_reference<T&> : public true_type {};
+
+template<typename T> struct is_proxy_reference  : public false_type {};
+
+template<typename T> struct is_device_reference                                : public false_type {};
+template<typename T> struct is_device_reference< thrust::device_reference<T> > : public true_type {};
+
+
+// NB: Careful with reference to void.
+template<typename _Tp, bool = (is_void<_Tp>::value || is_reference<_Tp>::value)>
+  struct __add_reference_helper
+  { typedef _Tp&    type; };
+
+template<typename _Tp>
+  struct __add_reference_helper<_Tp, true>
+  { typedef _Tp     type; };
+
+template<typename _Tp>
+  struct add_reference
+    : public __add_reference_helper<_Tp>{};
+
+template<typename T>
+  struct remove_reference
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T>
+  struct remove_reference<T&>
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T1, typename T2>
+  struct is_same
+    : public false_type
+{
+}; // end is_same
+
+template<typename T>
+  struct is_same<T,T>
+    : public true_type
+{
+}; // end is_same
+
+template<typename T1, typename T2>
+  struct lazy_is_same
+    : is_same<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_same
+
+template<typename T1, typename T2>
+  struct is_different
+    : public true_type
+{
+}; // end is_different
+
+template<typename T>
+  struct is_different<T,T>
+    : public false_type
+{
+}; // end is_different
+
+template<typename T1, typename T2>
+  struct lazy_is_different
+    : is_different<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_different
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<class From, class To>
+using is_convertible = ::cuda::std::is_convertible<From, To>;
+
+#else
+
+namespace tt_detail
+{
+
+template<typename T>
+  struct is_int_or_cref
+{
+  typedef typename remove_reference<T>::type type_sans_ref;
+  static const bool value = (is_integral<T>::value
+                             || (is_integral<type_sans_ref>::value
+                                 && is_const<type_sans_ref>::value
+                                 && !is_volatile<type_sans_ref>::value));
+}; // end is_int_or_cref
+
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN
+
+template<typename From, typename To>
+  struct is_convertible_sfinae
+{
+  private:
+    typedef char                          yes;
+    typedef struct { char two_chars[2]; } no;
+
+    static inline yes   test(To) { return yes(); }
+    static inline no    test(...) { return no(); }
+    static inline typename remove_reference<From>::type& from() { typename remove_reference<From>::type* ptr = 0; return *ptr; }
+
+  public:
+    static const bool value = sizeof(test(from())) == sizeof(yes);
+}; // end is_convertible_sfinae
+
+
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+
+
+template<typename From, typename To>
+  struct is_convertible_needs_simple_test
+{
+  static const bool from_is_void      = is_void<From>::value;
+  static const bool to_is_void        = is_void<To>::value;
+  static const bool from_is_float     = is_floating_point<typename remove_reference<From>::type>::value;
+  static const bool to_is_int_or_cref = is_int_or_cref<To>::value;
+
+  static const bool value = (from_is_void || to_is_void || (from_is_float && to_is_int_or_cref));
+}; // end is_convertible_needs_simple_test
+
+
+template<typename From, typename To,
+         bool = is_convertible_needs_simple_test<From,To>::value>
+  struct is_convertible
+{
+  static const bool value = (is_void<To>::value
+                             || (is_int_or_cref<To>::value
+                                 && !is_void<From>::value));
+}; // end is_convertible
+
+
+template<typename From, typename To>
+  struct is_convertible<From, To, false>
+{
+  static const bool value = (is_convertible_sfinae<typename
+                             add_reference<From>::type, To>::value);
+}; // end is_convertible
+
+
+} // end tt_detail
+
+template<typename From, typename To>
+  struct is_convertible
+    : public integral_constant<bool, tt_detail::is_convertible<From, To>::value>
+{
+}; // end is_convertible
+
+#endif
+
+template<typename T1, typename T2>
+  struct is_one_convertible_to_the_other
+    : public integral_constant<
+        bool,
+        is_convertible<T1,T2>::value || is_convertible<T2,T1>::value
+      >
+{};
+
+
+// mpl stuff
+template<typename... Conditions>
+  struct or_;
+
+template <>
+  struct or_<>
+    : public integral_constant<
+        bool,
+        false_type::value  // identity for or_
+      >
+{
+}; // end or_
+
+template <typename Condition, typename... Conditions>
+  struct or_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value || or_<Conditions...>::value
+      >
+{
+}; // end or_
+
+template <typename... Conditions>
+  struct and_;
+
+template<>
+  struct and_<>
+    : public integral_constant<
+        bool,
+        true_type::value // identity for and_
+      >
+{
+}; // end and_
+
+template <typename Condition, typename... Conditions>
+  struct and_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value && and_<Conditions...>::value>
+{
+}; // end and_
+
+template <typename Boolean>
+  struct not_
+    : public integral_constant<bool, !Boolean::value>
+{
+}; // end not_
+
+template<bool B, class T, class F>
+struct conditional { typedef T type; };
+
+template<class T, class F>
+struct conditional<false, T, F> { typedef F type; };
+
+template <bool, typename Then, typename Else>
+  struct eval_if
+{
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<true, Then, Else>
+{
+  typedef typename Then::type type;
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<false, Then, Else>
+{
+  typedef typename Else::type type;
+}; // end eval_if
+
+template<typename T>
+//  struct identity
+//  XXX WAR nvcc's confusion with thrust::identity
+  struct identity_
+{
+  typedef T type;
+}; // end identity
+
+template<bool, typename T = void> struct enable_if {};
+template<typename T>              struct enable_if<true, T> {typedef T type;};
+
+template<bool, typename T> struct lazy_enable_if {};
+template<typename T>       struct lazy_enable_if<true, T> {typedef typename T::type type;};
+
+template<bool condition, typename T = void> struct disable_if : enable_if<!condition, T> {};
+template<bool condition, typename T>        struct lazy_disable_if : lazy_enable_if<!condition, T> {};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct enable_if_convertible
+    : enable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct disable_if_convertible
+    : disable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename Result = void>
+  struct enable_if_different
+    : enable_if<is_different<T1,T2>::value, Result>
+{};
+
+
+template<typename T>
+  struct is_numeric
+    : and_<
+        is_convertible<int,T>,
+        is_convertible<T,int>
+      >
+{
+}; // end is_numeric
+
+
+template<typename> struct is_reference_to_const             : false_type {};
+template<typename T> struct is_reference_to_const<const T&> : true_type {};
+
+
+// make_unsigned follows
+
+namespace tt_detail
+{
+
+template<typename T> struct make_unsigned_simple;
+
+template<> struct make_unsigned_simple<char>                   { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<signed char>            { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<unsigned char>          { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<short>                  { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<unsigned short>         { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<int>                    { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<unsigned int>           { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<long int>               { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<unsigned long int>      { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<long long int>          { typedef unsigned long long int type; };
+template<> struct make_unsigned_simple<unsigned long long int> { typedef unsigned long long int type; };
+
+template<typename T>
+  struct make_unsigned_base
+{
+  // remove cv
+  typedef typename remove_cv<T>::type remove_cv_t;
+
+  // get the simple unsigned type
+  typedef typename make_unsigned_simple<remove_cv_t>::type unsigned_remove_cv_t;
+
+  // add back const, volatile, both, or neither to the simple result
+  typedef typename eval_if<
+    is_const<T>::value && is_volatile<T>::value,
+    // add cv back
+    add_cv<unsigned_remove_cv_t>,
+    // check const & volatile individually
+    eval_if<
+      is_const<T>::value,
+      // add c back
+      add_const<unsigned_remove_cv_t>,
+      eval_if<
+        is_volatile<T>::value,
+        // add v back
+        add_volatile<unsigned_remove_cv_t>,
+        // original type was neither cv, return the simple unsigned result
+        identity_<unsigned_remove_cv_t>
+      >
+    >
+  >::type type;
+};
+
+} // end tt_detail
+
+template<typename T>
+  struct make_unsigned
+    : tt_detail::make_unsigned_base<T>
+{};
+
+struct largest_available_float
+{
+  typedef double type;
+};
+
+// T1 wins if they are both the same size
+template<typename T1, typename T2>
+  struct larger_type
+    : thrust::detail::eval_if<
+        (sizeof(T2) > sizeof(T1)),
+        thrust::detail::identity_<T2>,
+        thrust::detail::identity_<T1>
+      >
+{};
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<class Base, class Derived>
+using is_base_of = ::cuda::std::is_base_of<Base, Derived>;
+
+#else
+
+namespace is_base_of_ns
+{
+
+typedef char                          yes;
+typedef struct { char two_chars[2]; } no;
+
+template<typename Base, typename Derived>
+  struct host
+{
+  operator Base*() const;
+  operator Derived*();
+}; // end host
+
+template<typename Base, typename Derived>
+  struct impl
+{
+  template<typename T> static yes check(Derived *, T);
+  static no check(Base*, int);
+
+  static const bool value = sizeof(check(host<Base,Derived>(), int())) == sizeof(yes);
+}; // end impl
+
+} // end is_base_of_ns
+
+
+template<typename Base, typename Derived>
+  struct is_base_of
+    : integral_constant<
+        bool,
+        is_base_of_ns::impl<Base,Derived>::value
+      >
+{};
+
+#endif
+
+template<typename Base, typename Derived, typename Result = void>
+  struct enable_if_base_of
+    : enable_if<
+        is_base_of<Base,Derived>::value,
+        Result
+      >
+{};
+
+
+namespace is_assignable_ns
+{
+
+template<typename T1, typename T2>
+  class is_assignable
+{
+  typedef char                      yes_type;
+  typedef struct { char array[2]; } no_type;
+
+  template<typename T> static typename add_reference<T>::type declval();
+
+  template<size_t> struct helper { typedef void * type; };
+
+  template<typename U1, typename U2> static yes_type test(typename helper<sizeof(declval<U1>() = declval<U2>())>::type);
+
+  template<typename,typename> static no_type test(...);
+
+  public:
+    static const bool value = sizeof(test<T1,T2>(0)) == 1;
+}; // end is_assignable
+
+} // end is_assignable_ns
+
+
+template<typename T1, typename T2>
+  struct is_assignable
+    : integral_constant<
+        bool,
+        is_assignable_ns::is_assignable<T1,T2>::value
+      >
+{};
+
+
+template<typename T>
+  struct is_copy_assignable
+    : is_assignable<
+        typename add_reference<T>::type,
+        typename add_reference<typename add_const<T>::type>::type
+      >
+{};
+
+
+template<typename T1, typename T2, typename Enable = void> struct promoted_numerical_type;
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type, typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef typename larger_type<T1,T2>::type type;
+  };
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_integral<T1>::type, typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef T2 type;
+  };
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type, typename is_integral<T2>::type>
+  ::value>::type>
+  {
+  typedef T1 type;
+  };
+
+template<typename T>
+  struct is_empty_helper : public T
+  {
+  };
+
+struct is_empty_helper_base
+{
+};
+
+template<typename T>
+  struct is_empty : integral_constant<bool,
+    sizeof(is_empty_helper_base) == sizeof(is_empty_helper<T>)
+  >
+  {
+  };
+
+template <typename Invokable, typename... Args>
+using invoke_result_t =
+#if THRUST_CPP_DIALECT < 2017
+  typename ::cuda::std::result_of<Invokable(Args...)>::type;
+#else // 2017+
+  ::cuda::std::invoke_result_t<Invokable, Args...>;
+#endif
+
+template <class F, class... Us>
+struct invoke_result
+{
+  using type = invoke_result_t<F, Us...>;
+};
+
+} // end detail
+
+using detail::integral_constant;
+using detail::true_type;
+using detail::false_type;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/type_traits/has_trivial_assign.h>
diff --git a/miniCUDA124/include/thrust/detail/uninitialized_copy.inl b/miniCUDA124/include/thrust/detail/uninitialized_copy.inl
new file mode 100644
index 0000000000000000000000000000000000000000..70522e85a640fc1d483d80648eb00791b32bf465
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/uninitialized_copy.inl
@@ -0,0 +1,103 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/uninitialized_copy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_copy.h>
+#include <thrust/system/detail/adl/uninitialized_copy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                     InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy;
+  return uninitialized_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end uninitialized_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy_n;
+  return uninitialized_copy_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, result);
+} // end uninitialized_copy_n()
+
+
+template<typename InputIterator,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy(InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy(select_system(system1,system2), first, last, result);
+} // end uninitialized_copy()
+
+
+template<typename InputIterator,
+         typename Size,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy_n(InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy_n(select_system(system1,system2), first, n, result);
+} // end uninitialized_copy_n()
+
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniCUDA124/include/thrust/detail/uninitialized_fill.inl b/miniCUDA124/include/thrust/detail/uninitialized_fill.inl
new file mode 100644
index 0000000000000000000000000000000000000000..3b0167a848d360d55112558b79994583b2d94a86
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/uninitialized_fill.inl
@@ -0,0 +1,98 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/uninitialized_fill.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_fill.h>
+#include <thrust/system/detail/adl/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void uninitialized_fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill;
+  return uninitialized_fill(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, x);
+} // end uninitialized_fill()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Size, typename T>
+__host__ __device__
+  ForwardIterator uninitialized_fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill_n;
+  return uninitialized_fill_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, x);
+} // end uninitialized_fill_n()
+
+
+template<typename ForwardIterator,
+         typename T>
+  void uninitialized_fill(ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  thrust::uninitialized_fill(select_system(system), first, last, x);
+} // end uninitialized_fill()
+
+
+template<typename ForwardIterator,
+         typename Size,
+         typename T>
+  ForwardIterator uninitialized_fill_n(ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::uninitialized_fill_n(select_system(system), first, n, x);
+} // end uninitialized_fill_n()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/detail/unique.inl b/miniCUDA124/include/thrust/detail/unique.inl
new file mode 100644
index 0000000000000000000000000000000000000000..5ab9a91416789b903ada48bc02996ecb4c59cdcf
--- /dev/null
+++ b/miniCUDA124/include/thrust/detail/unique.inl
@@ -0,0 +1,401 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/unique.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/unique.h>
+#include <thrust/system/detail/generic/unique_by_key.h>
+#include <thrust/system/detail/adl/unique.h>
+#include <thrust/system/detail/adl/unique_by_key.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output,
+                           BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first,
+                BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output,
+                     BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+
+template<typename ForwardIterator>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last);
+} // end unique()
+
+
+template<typename ForwardIterator,
+         typename BinaryPredicate>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last,
+                         BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last, binary_pred);
+} // end unique()
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output);
+} // end unique_copy()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output,
+                             BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first,
+                  BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last);
+} // end unique_count()
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/constant_iterator.h b/miniCUDA124/include/thrust/iterator/constant_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d460f83d45a10801714fd3034020ac5fd56decb
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/constant_iterator.h
@@ -0,0 +1,258 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/constant_iterator.h
+ *  \brief An iterator which returns a constant value when
+ *         dereferenced
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/constant_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p constant_iterator is an iterator which represents a pointer into a range
+ *  of constant values. This iterator is useful for creating a range filled with the same
+ *  value without explicitly storing it in memory. Using \p constant_iterator saves both
+ *  memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p constant_iterator whose
+ *  \c value_type is \c int and whose value is \c 10.
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *
+ *  thrust::constant_iterator<int> iter(10);
+ *
+ *  *iter;    // returns 10
+ *  iter[0];  // returns 10
+ *  iter[1];  // returns 10
+ *  iter[13]; // returns 10
+ *
+ *  // and so on...
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p constant_iterator with the
+ *  \p thrust::transform function to increment all elements of a sequence by the
+ *  same value. We will create a temporary \p constant_iterator with the function
+ *  \p make_constant_iterator function in order to avoid explicitly specifying
+ *  its type:
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> data(4);
+ *    data[0] = 3;
+ *    data[1] = 7;
+ *    data[2] = 2;
+ *    data[3] = 5;
+ *
+ *    // add 10 to all values in data
+ *    thrust::transform(data.begin(), data.end(),
+ *                      thrust::make_constant_iterator(10),
+ *                      data.begin(),
+ *                      thrust::plus<int>());
+ *
+ *    // data is now [13, 17, 12, 15]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_constant_iterator
+ */
+template<typename Value,
+         typename Incrementable = use_default,
+         typename System = use_default>
+  class constant_iterator
+    : public detail::constant_iterator_base<Value, Incrementable, System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::type          super_t;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::incrementable incrementable;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Null constructor initializes this \p constant_iterator's constant using its
+     *  null constructor.
+     */
+    __host__ __device__
+    constant_iterator()
+      : super_t(), m_value() {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator into this
+     *  \p constant_iterator.
+     *
+     *  \p rhs The constant_iterator to copy.
+     */
+    __host__ __device__
+    constant_iterator(constant_iterator const &rhs)
+      : super_t(rhs.base()), m_value(rhs.m_value) {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator with related
+     *  System type.
+     *
+     *  \param rhs The \p constant_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    constant_iterator(constant_iterator<Value,Incrementable,OtherSystem> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<constant_iterator<Value,Incrementable,OtherSystem> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()), m_value(rhs.value()) {}
+
+    /*! This constructor receives a value to use as the constant value of this
+     *  \p constant_iterator and an index specifying the location of this
+     *  \p constant_iterator in a sequence.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    constant_iterator(value_type const& v, incrementable const &i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This constructor is templated to allow construction from a value type and
+     *  incrementable type related this this \p constant_iterator's respective types.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    template<typename OtherValue, typename OtherIncrementable>
+    __host__ __device__
+    constant_iterator(OtherValue const& v, OtherIncrementable const& i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This method returns the value of this \p constant_iterator's constant value.
+     *  \return A \c const reference to this \p constant_iterator's constant value.
+     */
+    __host__ __device__
+    Value const& value() const
+    { return m_value; }
+
+    /*! \cond
+     */
+
+  protected:
+    __host__ __device__
+    Value const& value_reference() const
+    { return m_value; }
+
+    __host__ __device__
+    Value & value_reference()
+    { return m_value; }
+
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_value;
+    }
+
+  private:
+    Value m_value;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  from values given for both value and index. The type of \p constant_iterator
+ *  may be inferred by the compiler from the types of its parameters.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \param i The index of the returned \p constant_iterator within a sequence.
+ *           The type of this parameter defaults to \c int. In the default case,
+ *           the value of this parameter is \c 0.
+ *
+ *  \return A new \p constant_iterator with constant value & index as given
+ *          by \p x & \p i.
+ *
+ *  \see constant_iterator
+ */
+template<typename ValueT, typename IndexT>
+inline __host__ __device__
+constant_iterator<ValueT, IndexT> make_constant_iterator(ValueT x, IndexT i = int())
+{
+  return constant_iterator<ValueT, IndexT>(x, i);
+} // end make_constant_iterator()
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  using only a parameter for the desired constant value. The value of the
+ *  returned \p constant_iterator's index is set to \c 0.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \return A new \p constant_iterator with constant value equal to \p x and
+ *          index equal to \c 0.
+ *  \see constant_iterator
+ */
+template<typename V>
+inline __host__ __device__
+constant_iterator<V> make_constant_iterator(V x)
+{
+  return constant_iterator<V>(x, 0);
+} // end make_constant_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/counting_iterator.h b/miniCUDA124/include/thrust/iterator/counting_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c42045c3ab84e4274fafb25b323ef8a676f74a0
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/counting_iterator.h
@@ -0,0 +1,254 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/counting_iterator.h
+ *  \brief An iterator which returns an increasing incrementable value
+ *         when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+
+// #include the details first
+#include <thrust/iterator/detail/counting_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p counting_iterator is an iterator which represents a pointer into a range
+ *  of sequentially changing values. This iterator is useful for creating a range
+ *  filled with a sequence without explicitly storing it in memory. Using
+ *  \p counting_iterator saves memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p counting_iterator whose
+ *  \c value_type is \c int and which sequentially increments by \c 1.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  ...
+ *  // create iterators
+ *  thrust::counting_iterator<int> first(10);
+ *  thrust::counting_iterator<int> last = first + 3;
+ *
+ *  first[0]   // returns 10
+ *  first[1]   // returns 11
+ *  first[100] // returns 110
+ *
+ *  // sum of [first, last)
+ *  thrust::reduce(first, last);   // returns 33 (i.e. 10 + 11 + 12)
+ *
+ *  // initialize vector to [0,1,2,..]
+ *  thrust::counting_iterator<int> iter(0);
+ *  thrust::device_vector<int> vec(500);
+ *  thrust::copy(iter, iter + vec.size(), vec.begin());
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p counting_iterator with the
+ *  \p thrust::copy_if function to compute the indices of the non-zero elements
+ *  of a \p device_vector. In this example, we use the \p make_counting_iterator
+ *  function to avoid specifying the type of the \p counting_iterator.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  #include <thrust/copy.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *   // this example computes indices for all the nonzero values in a sequence
+ *
+ *   // sequence of zero and nonzero values
+ *   thrust::device_vector<int> stencil(8);
+ *   stencil[0] = 0;
+ *   stencil[1] = 1;
+ *   stencil[2] = 1;
+ *   stencil[3] = 0;
+ *   stencil[4] = 0;
+ *   stencil[5] = 1;
+ *   stencil[6] = 0;
+ *   stencil[7] = 1;
+ *
+ *   // storage for the nonzero indices
+ *   thrust::device_vector<int> indices(8);
+ *
+ *   // compute indices of nonzero elements
+ *   typedef thrust::device_vector<int>::iterator IndexIterator;
+ *
+ *   // use make_counting_iterator to define the sequence [0, 8)
+ *   IndexIterator indices_end = thrust::copy_if(thrust::make_counting_iterator(0),
+ *                                               thrust::make_counting_iterator(8),
+ *                                               stencil.begin(),
+ *                                               indices.begin(),
+ *                                               thrust::identity<int>());
+ *   // indices now contains [1,2,5,7]
+ *
+ *   return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_counting_iterator
+ */
+template<typename Incrementable,
+         typename System = use_default,
+         typename Traversal = use_default,
+         typename Difference = use_default>
+  class counting_iterator
+    : public detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type
+{
+    /*! \cond
+     */
+    typedef typename detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+  public:
+    typedef typename super_t::reference       reference;
+    typedef typename super_t::difference_type difference_type;
+
+    /*! \endcond
+     */
+
+    /*! Default constructor initializes this \p counting_iterator's counter to
+     * `Incrementable{}`.
+     */
+    __host__ __device__
+    counting_iterator() : super_t(Incrementable{}) {}
+
+    /*! Copy constructor copies the value of another \p counting_iterator into a
+     *  new \p counting_iterator.
+     *
+     *  \p rhs The \p counting_iterator to copy.
+     */
+    __host__ __device__
+    counting_iterator(counting_iterator const &rhs):super_t(rhs.base()){}
+
+    /*! Copy constructor copies the value of another counting_iterator
+     *  with related System type.
+     *
+     *  \param rhs The \p counting_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    counting_iterator(counting_iterator<Incrementable, OtherSystem, Traversal, Difference> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<counting_iterator<Incrementable,OtherSystem,Traversal,Difference> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()){}
+
+    /*! This \c explicit constructor copies the value of an \c Incrementable
+     *  into a new \p counting_iterator's \c Incrementable counter.
+     *
+     *  \param x The initial value of the new \p counting_iterator's \c Incrementable
+     *         counter.
+     */
+    __host__ __device__
+    explicit counting_iterator(Incrementable x):super_t(x){}
+
+#if THRUST_CPP_DIALECT >= 2011
+    counting_iterator & operator=(const counting_iterator &) = default;
+#endif
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    reference dereference() const
+    {
+      return this->base_reference();
+    }
+
+    // note that we implement equal specially for floating point counting_iterator
+    template <typename OtherIncrementable, typename OtherSystem, typename OtherTraversal, typename OtherDifference>
+    __host__ __device__
+    bool equal(counting_iterator<OtherIncrementable, OtherSystem, OtherTraversal, OtherDifference> const& y) const
+    {
+      typedef thrust::detail::counting_iterator_equal<difference_type,Incrementable,OtherIncrementable> e;
+      return e::equal(this->base(), y.base());
+    }
+
+    template <class OtherIncrementable>
+    __host__ __device__
+    difference_type
+    distance_to(counting_iterator<OtherIncrementable, System, Traversal, Difference> const& y) const
+    {
+      typedef typename
+      thrust::detail::eval_if<
+        thrust::detail::is_numeric<Incrementable>::value,
+        thrust::detail::identity_<thrust::detail::number_distance<difference_type, Incrementable, OtherIncrementable> >,
+        thrust::detail::identity_<thrust::detail::iterator_distance<difference_type, Incrementable, OtherIncrementable> >
+      >::type d;
+
+      return d::distance(this->base(), y.base());
+    }
+
+    /*! \endcond
+     */
+}; // end counting_iterator
+
+
+/*! \p make_counting_iterator creates a \p counting_iterator
+ *  using an initial value for its \c Incrementable counter.
+ *
+ *  \param x The initial value of the new \p counting_iterator's counter.
+ *  \return A new \p counting_iterator whose counter has been initialized to \p x.
+ */
+template <typename Incrementable>
+inline __host__ __device__
+counting_iterator<Incrementable> make_counting_iterator(Incrementable x)
+{
+  return counting_iterator<Incrementable>(x);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/discard_iterator.h b/miniCUDA124/include/thrust/iterator/discard_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..90c31e82e4434c2dcc018c1b3898af7595ab3057
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/discard_iterator.h
@@ -0,0 +1,182 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/discard_iterator.h
+ *  \brief An iterator which "discards" (ignores) values assigned to it upon dereference
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/discard_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p discard_iterator is an iterator which represents a special kind of pointer that
+ *  ignores values written to it upon dereference. This iterator is useful for ignoring
+ *  the output of certain algorithms without wasting memory capacity or bandwidth.
+ *  \p discard_iterator may also be used to count the size of an algorithm's output which
+ *  may not be known a priori.
+ *
+ *  The following code snippet demonstrates how to use \p discard_iterator to ignore
+ *  ignore one of the output ranges of reduce_by_key
+ *
+ *  \code
+ *  #include <thrust/iterator/discard_iterator.h>
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> keys(7), values(7);
+ *
+ *    keys[0] = 1;
+ *    keys[1] = 3;
+ *    keys[2] = 3;
+ *    keys[3] = 3;
+ *    keys[4] = 2;
+ *    keys[5] = 2;
+ *    keys[6] = 1;
+ *
+ *    values[0] = 9;
+ *    values[1] = 8;
+ *    values[2] = 7;
+ *    values[3] = 6;
+ *    values[4] = 5;
+ *    values[5] = 4;
+ *    values[6] = 3;
+ *
+ *    thrust::device_vector<int> result(4);
+ *
+ *    // we are only interested in the reduced values
+ *    // use discard_iterator to ignore the output keys
+ *    thrust::reduce_by_key(keys.begin(), keys.end(),
+ *                          values.begin(),
+ *                          thrust::make_discard_iterator(),
+ *                          result.begin());
+ *
+ *    // result is now [9, 21, 9, 3]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_discard_iterator
+ */
+template<typename System = use_default>
+  class discard_iterator
+    : public detail::discard_iterator_base<System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::discard_iterator_base<System>::type          super_t;
+    typedef typename detail::discard_iterator_base<System>::incrementable incrementable;
+    typedef typename detail::discard_iterator_base<System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Copy constructor copies from a source discard_iterator.
+     *
+     *  \p rhs The discard_iterator to copy.
+     */
+    __host__ __device__
+    discard_iterator(discard_iterator const &rhs)
+      : super_t(rhs.base()) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    discard_iterator & operator=(const discard_iterator &) = default;
+#endif
+
+    /*! This constructor receives an optional index specifying the position of this
+     *  \p discard_iterator in a range.
+     *
+     *  \p i The index of this \p discard_iterator in a range. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    discard_iterator(incrementable const &i = incrementable())
+      : super_t(base_iterator(i)) {}
+
+    /*! \cond
+     */
+
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_element;
+    }
+
+    mutable value_type m_element;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! \p make_discard_iterator creates a \p discard_iterator from an optional index parameter.
+ *
+ *  \param i The index of the returned \p discard_iterator within a range.
+ *           In the default case, the value of this parameter is \c 0.
+ *
+ *  \return A new \p discard_iterator with index as given by \p i.
+ *
+ *  \see constant_iterator
+ */
+inline __host__ __device__
+discard_iterator<> make_discard_iterator(discard_iterator<>::difference_type i = discard_iterator<>::difference_type(0))
+{
+  return discard_iterator<>(i);
+} // end make_discard_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+
diff --git a/miniCUDA124/include/thrust/iterator/iterator_adaptor.h b/miniCUDA124/include/thrust/iterator/iterator_adaptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca5475fede9441115aa4146c30d56799c8371cd1
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/iterator_adaptor.h
@@ -0,0 +1,249 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_adaptor.h
+ *  \brief An iterator which adapts a base iterator
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/iterator/detail/iterator_adaptor_base.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p iterator_adaptor is an iterator which adapts an existing type of iterator to create a new type of
+ *  iterator. Most of Thrust's fancy iterators are defined via inheritance from \p iterator_adaptor.
+ *  While composition of these existing Thrust iterators is often sufficient for expressing the desired
+ *  functionality, it is occasionally more straightforward to derive from \p iterator_adaptor directly.
+ *
+ *  To see how to use \p iterator_adaptor to create a novel iterator type, let's examine how to use it to
+ *  define \p repeat_iterator, a fancy iterator which repeats elements from another range a given number of time:
+ *
+ *  \code
+ *  #include <thrust/iterator/iterator_adaptor.h>
+ *
+ *  // derive repeat_iterator from iterator_adaptor
+ *  template<typename Iterator>
+ *    class repeat_iterator
+ *      : public thrust::iterator_adaptor<
+ *          repeat_iterator<Iterator>, // the first template parameter is the name of the iterator we're creating
+ *          Iterator                   // the second template parameter is the name of the iterator we're adapting
+ *                                     // we can use the default for the additional template parameters
+ *        >
+ *  {
+ *    public:
+ *      // shorthand for the name of the iterator_adaptor we're deriving from
+ *      typedef thrust::iterator_adaptor<
+ *        repeat_iterator<Iterator>,
+ *        Iterator
+ *      > super_t;
+ *
+ *      __host__ __device__
+ *      repeat_iterator(const Iterator &x, int n) : super_t(x), begin(x), n(n) {}
+ *
+ *      // befriend thrust::iterator_core_access to allow it access to the private interface below
+ *      friend class thrust::iterator_core_access;
+ *
+ *    private:
+ *      // repeat each element of the adapted range n times
+ *      unsigned int n;
+ *
+ *      // used to keep track of where we began
+ *      const Iterator begin;
+ *
+ *      // it is private because only thrust::iterator_core_access needs access to it
+ *      __host__ __device__
+ *      typename super_t::reference dereference() const
+ *      {
+ *        return *(begin + (this->base() - begin) / n);
+ *      }
+ *  };
+ *  \endcode
+ *
+ *  Except for the first two, \p iterator_adaptor's template parameters are optional. When omitted, or when the
+ *  user specifies \p thrust::use_default in its place, \p iterator_adaptor will use a default type inferred from \p Base.
+ *
+ *  \p iterator_adaptor's functionality is derived from and generally equivalent to \p boost::iterator_adaptor.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems.
+ *
+ *  \p iterator_adaptor is a powerful tool for creating custom iterators directly. However, the large set of iterator semantics which must be satisfied
+ *  for algorithm compatibility can make \p iterator_adaptor difficult to use correctly. Unless you require the full expressivity of \p iterator_adaptor,
+ *  consider building a custom iterator through composition of existing higher-level fancy iterators instead.
+ *
+ *  Interested users may refer to <tt>boost::iterator_adaptor</tt>'s documentation for further usage examples.
+ */
+template<typename Derived,
+         typename Base,
+         typename Value      = use_default,
+         typename System     = use_default,
+         typename Traversal  = use_default,
+         typename Reference  = use_default,
+         typename Difference = use_default>
+  class iterator_adaptor:
+    public detail::iterator_adaptor_base<
+      Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type
+{
+  /*! \cond
+   */
+
+    friend class thrust::iterator_core_access;
+
+  protected:
+    typedef typename detail::iterator_adaptor_base<
+        Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type super_t;
+
+  /*! \endcond
+   */
+
+  public:
+    /*! \p iterator_adaptor's default constructor does nothing.
+     */
+    iterator_adaptor() = default;
+
+    /*! This constructor copies from a given instance of the \p Base iterator.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit iterator_adaptor(Base const& iter)
+      : m_iterator(iter)
+    {}
+
+    /*! The type of iterator this \p iterator_adaptor's \p adapts.
+     */
+    typedef Base       base_type;
+
+    /*! \cond
+     */
+    typedef typename super_t::reference reference;
+
+    typedef typename super_t::difference_type difference_type;
+    /*! \endcond
+     */
+
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base() const
+    { return m_iterator; }
+
+  protected:
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base_reference() const
+    { return m_iterator; }
+
+    /*! \return A mutable reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base& base_reference()
+    { return m_iterator; }
+
+    /*! \cond
+     */
+  private: // Core iterator interface for iterator_facade
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename iterator_adaptor::reference dereference() const
+    { return *m_iterator; }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& x) const
+    { return m_iterator == x.base(); }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void advance(typename iterator_adaptor::difference_type n)
+    {
+      // XXX statically assert on random_access_traversal_tag
+
+      // counting_iterator will pick eg. diff_t=int64 when base=int32.
+      // Explicitly cast to avoid static conversion warnings.
+      m_iterator = static_cast<base_type>(m_iterator + n);
+    }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void increment()
+    { ++m_iterator; }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void decrement()
+    {
+      // XXX statically assert on bidirectional_traversal_tag
+      --m_iterator;
+    }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    typename iterator_adaptor::difference_type distance_to(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& y) const
+    { return y.base() - m_iterator; }
+
+  private:
+    Base m_iterator;
+
+    /*! \endcond
+     */
+}; // end iterator_adaptor
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/iterator_categories.h b/miniCUDA124/include/thrust/iterator/iterator_categories.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f418c28e5fac732e93be1a02f47dd835f5f0a36
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/iterator_categories.h
@@ -0,0 +1,231 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_categories.h
+ *  \brief Types for reasoning about the categories of iterators
+ */
+
+/*
+ * (C) Copyright Jeremy Siek 2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+
+// #include this for stl's iterator tags
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \addtogroup iterator_tags Iterator Tags
+ *  \ingroup iterators
+ *  \addtogroup iterator_tag_classes Iterator Tag Classes
+ *  \ingroup iterator_tags
+ *  \{
+ */
+
+/*! \p input_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  output_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct input_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::input_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p output_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct output_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::output_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p forward_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, output_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct forward_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::forward_iterator_tag,
+      thrust::device_system_tag,
+      thrust::forward_traversal_tag
+    >
+{};
+
+/*! \p bidirectional_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Bidirectional Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct bidirectional_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::bidirectional_iterator_tag,
+      thrust::device_system_tag,
+      thrust::bidirectional_traversal_tag
+    >
+{};
+
+/*! \p random_access_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Random Access Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct random_access_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::random_access_iterator_tag,
+      thrust::device_system_tag,
+      thrust::random_access_traversal_tag
+    >
+{};
+
+/*! \p input_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::input_iterator_tag input_host_iterator_tag;
+
+/*! \p output_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::output_iterator_tag output_host_iterator_tag;
+
+/*! \p forward_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::forward_iterator_tag forward_host_iterator_tag;
+
+/*! \p bidirectional_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::bidirectional_iterator_tag bidirectional_host_iterator_tag;
+
+/*! \p random_access_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, bidirectional_host_iterator_tag
+ */
+typedef std::random_access_iterator_tag random_access_host_iterator_tag;
+
+/*! \} // end iterator_tag_classes
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/universal_categories.h>
+
diff --git a/miniCUDA124/include/thrust/iterator/iterator_facade.h b/miniCUDA124/include/thrust/iterator/iterator_facade.h
new file mode 100644
index 0000000000000000000000000000000000000000..08a1e11027211655619c75d7c09e2f2a2804e518
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/iterator_facade.h
@@ -0,0 +1,550 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/iterator_facade.h
+ *  \brief A class which exposes a public interface for iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/iterator_facade_category.h>
+#include <thrust/iterator/detail/distance_from_result.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+
+// This forward declaration is required for the friend declaration
+// in iterator_core_access
+template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> class iterator_facade;
+
+
+/*! \p iterator_core_access is the class which user iterator types derived from \p thrust::iterator_adaptor
+ *  or \p thrust::iterator_facade must befriend to allow it to access their private interface.
+ */
+class iterator_core_access
+{
+    /*! \cond
+     */
+
+    // declare our friends
+    template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> friend class iterator_facade;
+
+    // iterator comparisons are our friends
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    // iterator difference is our friend
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend
+      typename thrust::detail::distance_from_result<
+        iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+        iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+      >::type
+    operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+              iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template<typename Facade>
+    __host__ __device__
+    static typename Facade::reference dereference(Facade const& f)
+    {
+      return f.dereference();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void increment(Facade& f)
+    {
+      f.increment();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void decrement(Facade& f)
+    {
+      f.decrement();
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static bool equal(Facade1 const& f1, Facade2 const& f2)
+    {
+      return f1.equal(f2);
+    }
+
+    // XXX TODO: Investigate whether we need both of these cases
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+    //{
+    //  return f1.equal(f2);
+    //}
+
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+    //{
+    //  return f2.equal(f1);
+    //}
+
+    template <class Facade>
+    __host__ __device__
+    static void advance(Facade& f, typename Facade::difference_type n)
+    {
+      f.advance(n);
+    }
+
+    // Facade2 is convertible to Facade1,
+    // so return Facade1's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade1::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::true_type)
+    {
+      return -f1.distance_to(f2);
+    }
+
+    // Facade2 is not convertible to Facade1,
+    // so return Facade2's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade2::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::false_type)
+    {
+      return f2.distance_to(f1);
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename thrust::detail::distance_from_result<Facade1,Facade2>::type
+      distance_from(Facade1 const& f1, Facade2 const& f2)
+    {
+      // dispatch the implementation of this method upon whether or not
+      // Facade2 is convertible to Facade1
+      return distance_from(f1, f2,
+        typename thrust::detail::is_convertible<Facade2,Facade1>::type());
+    }
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference>& facade)
+    {
+      return *static_cast<Derived*>(&facade);
+    }
+
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived const& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& facade)
+    {
+      return *static_cast<Derived const*>(&facade);
+    }
+
+    /*! \endcond
+     */
+}; // end iterator_core_access
+
+
+/*! \p iterator_facade is a template which allows the programmer to define a novel iterator with a standards-conforming interface
+ *  which Thrust can use to reason about algorithm acceleration opportunities.
+ *
+ *  Because most of a standard iterator's interface is defined in terms of a small set of core primitives, \p iterator_facade
+ *  defines the non-primitive portion mechanically. In principle a novel iterator could explicitly provide the entire interface in
+ *  an ad hoc fashion but doing so might be tedious and prone to subtle errors.
+ *
+ *  Often \p iterator_facade is too primitive a tool to use for defining novel iterators. In these cases, \p iterator_adaptor
+ *  or a specific fancy iterator should be used instead.
+ *
+ *  \p iterator_facade's functionality is derived from and generally equivalent to \p boost::iterator_facade.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems. An additional exception is Thrust's omission
+ *  of the \c operator-> member function.
+ *
+ *  Interested users may refer to <tt>boost::iterator_facade</tt>'s documentation for usage examples.
+ *
+ *  \note \p iterator_facade's arithmetic operator free functions exist with the usual meanings but are omitted here for brevity.
+ */
+template<typename Derived,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference = std::ptrdiff_t>
+  class iterator_facade
+{
+  private:
+    /*! \cond
+     */
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    __host__ __device__
+    Derived& derived()
+    {
+      return *static_cast<Derived*>(this);
+    }
+
+    __host__ __device__
+    Derived const& derived() const
+    {
+      return *static_cast<Derived const*>(this);
+    }
+    /*! \endcond
+     */
+
+  public:
+    /*! The type of element pointed to by \p iterator_facade.
+     */
+    typedef typename thrust::detail::remove_const<Value>::type value_type;
+
+    /*! The return type of \p iterator_facade::operator*().
+     */
+    typedef Reference                                          reference;
+
+    /*! The return type of \p iterator_facade's non-existent \c operator->()
+     *  member function. Unlike \c boost::iterator_facade, \p iterator_facade
+     *  disallows access to the \p value_type's members through expressions of the
+     *  form <tt>iter->member</tt>. \p pointer is defined to \c void to indicate
+     *  that these expressions are not allowed. This limitation may be relaxed in a
+     *  future version of Thrust.
+     */
+    typedef void                                               pointer;
+
+    /*! The type of expressions of the form <tt>x - y</tt> where <tt>x</tt> and <tt>y</tt>
+     *  are of type \p iterator_facade.
+     */
+    typedef Difference                                         difference_type;
+
+    /*! The type of iterator category of \p iterator_facade.
+     */
+    typedef typename thrust::detail::iterator_facade_category<
+      System, Traversal, Value, Reference
+    >::type                                                    iterator_category;
+
+    /*! \p operator*() dereferences this \p iterator_facade.
+     *  \return A reference to the element pointed to by this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator*() const
+    {
+      return iterator_core_access::dereference(this->derived());
+    }
+
+    // XXX unimplemented for now, consider implementing it later
+    //pointer operator->() const
+    //{
+    //  return;
+    //}
+
+    // XXX investigate whether or not we need to go to the lengths
+    //     boost does to determine the return type
+
+    /*! \p operator[] performs indexed dereference.
+     *  \return A reference to the element \p n distance away from this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator[](difference_type n) const
+    {
+      return *(this->derived() + n);
+    }
+
+    /*! \p operator++ pre-increments this \p iterator_facade to refer to the element in the next position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator++()
+    {
+      iterator_core_access::increment(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator++ post-increments this \p iterator_facade and returns a new \p iterator_facade referring to the element in the next position.
+     *  \return A copy of <tt>*this</tt> before increment.
+     */
+    __host__ __device__
+    Derived  operator++(int)
+    {
+      Derived tmp(this->derived());
+      ++*this;
+      return tmp;
+    }
+
+    /*! \p operator-- pre-decrements this \p iterator_facade to refer to the element in the previous position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator--()
+    {
+      iterator_core_access::decrement(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator-- post-decrements this \p iterator_facade and returns a new \p iterator_facade referring to the element in the previous position.
+     *  \return A copy of <tt>*this</tt> before decrement.
+     */
+    __host__ __device__
+    Derived  operator--(int)
+    {
+      Derived tmp(this->derived());
+      --*this;
+      return tmp;
+    }
+
+    /*! \p operator+= increments this \p iterator_facade to refer to an element a given distance after its current position.
+     *  \param n The quantity to increment.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator+=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), n);
+      return this->derived();
+    }
+
+    /*! \p operator-= decrements this \p iterator_facade to refer to an element a given distance before its current postition.
+     *  \param n The quantity to decrement.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator-=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), -n);
+      return this->derived();
+    }
+
+    /*! \p operator- subtracts a given quantity from this \p iterator_facade and returns a new \p iterator_facade referring to the element at the given position before this \p iterator_facade.
+     *  \param n The quantity to decrement
+     *  \return An \p iterator_facade pointing \p n elements before this \p iterator_facade.
+     */
+    __host__ __device__
+    Derived  operator-(difference_type n) const
+    {
+      Derived result(this->derived());
+      return result -= n;
+    }
+}; // end iterator_facade
+
+/*! \cond
+ */
+
+// Comparison operators
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return !iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 > iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 < iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 >= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 <= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator difference
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+
+// divine the type this operator returns
+typename thrust::detail::distance_from_result<
+  iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+  iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+>::type
+
+operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+          iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator addition
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i,
+                   typename Derived::difference_type n)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+/*! \endcond
+ */
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/iterator_traits.h b/miniCUDA124/include/thrust/iterator/iterator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca0e0146cb9a5e0c74b9d5a68a4e92a869d635a9
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/iterator_traits.h
@@ -0,0 +1,73 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_traits.h
+ *  \brief Traits and metafunctions for reasoning about the traits of iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/type_traits/void_t.h>
+
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \p iterator_traits is a type trait class that provides a uniform
+ *  interface for querying the properties of iterators at compile-time.
+ */
+template <typename T>
+struct iterator_traits : std::iterator_traits<T> {};
+
+template<typename Iterator> struct iterator_value;
+
+template<typename Iterator> struct iterator_pointer;
+
+template<typename Iterator> struct iterator_reference;
+
+template<typename Iterator> struct iterator_difference;
+
+template<typename Iterator> struct iterator_traversal;
+
+template<typename Iterator> struct iterator_system;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/host_system_tag.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/iterator/detail/iterator_traits.inl>
+
diff --git a/miniCUDA124/include/thrust/iterator/permutation_iterator.h b/miniCUDA124/include/thrust/iterator/permutation_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..28aa82686c75abdef716915eb1a19df96d6cace6
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/permutation_iterator.h
@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/permutation_iterator.h
+ *  \brief An iterator which performs a gather or scatter operation when dereferenced
+ */
+
+/*
+ * (C) Copyright Toon Knapen    2001.
+ * (C) Copyright David Abrahams 2003.
+ * (C) Copyright Roland Richter 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/permutation_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p permutation_iterator is an iterator which represents a pointer into a
+ *  reordered view of a given range. \p permutation_iterator is an imprecise name;
+ *  the reordered view need not be a strict permutation. This iterator is useful
+ *  for fusing a scatter or gather operation with other algorithms.
+ *
+ *  This iterator takes two arguments:
+ *
+ *    - an iterator to the range \c V on which the "permutation" will be applied
+ *    - the reindexing scheme that defines how the elements of \c V will be permuted.
+ *
+ *  Note that \p permutation_iterator is not limited to strict permutations of the
+ *  given range \c V. The distance between begin and end of the reindexing iterators
+ *  is allowed to be smaller compared to the size of the range \c V, in which case
+ *  the \p permutation_iterator only provides a "permutation" of a subrange of \c V.
+ *  The indices neither need to be unique. In this same context, it must be noted
+ *  that the past-the-end \p permutation_iterator is completely defined by means of
+ *  the past-the-end iterator to the indices.
+ *
+ *  The following code snippet demonstrates how to create a \p permutation_iterator
+ *  which represents a reordering of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/permutation_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> values(8);
+ *  values[0] = 10.0f;
+ *  values[1] = 20.0f;
+ *  values[2] = 30.0f;
+ *  values[3] = 40.0f;
+ *  values[4] = 50.0f;
+ *  values[5] = 60.0f;
+ *  values[6] = 70.0f;
+ *  values[7] = 80.0f;
+ *
+ *  thrust::device_vector<int> indices(4);
+ *  indices[0] = 2;
+ *  indices[1] = 6;
+ *  indices[2] = 1;
+ *  indices[3] = 3;
+ *
+ *  typedef thrust::device_vector<float>::iterator ElementIterator;
+ *  typedef thrust::device_vector<int>::iterator   IndexIterator;
+ *
+ *  thrust::permutation_iterator<ElementIterator,IndexIterator> iter(values.begin(), indices.begin());
+ *
+ *  *iter;   // returns 30.0f;
+ *  iter[0]; // returns 30.0f;
+ *  iter[1]; // returns 70.0f;
+ *  iter[2]; // returns 20.0f;
+ *  iter[3]; // returns 40.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  *iter   = -1.0f; // sets values[2] to -1.0f;
+ *  iter[0] = -1.0f; // sets values[2] to -1.0f;
+ *  iter[1] = -1.0f; // sets values[6] to -1.0f;
+ *  iter[2] = -1.0f; // sets values[1] to -1.0f;
+ *  iter[3] = -1.0f; // sets values[3] to -1.0f;
+ *
+ *  // values is now {10, -1, -1, -1, 50, 60, -1, 80}
+ *  \endcode
+ *
+ *  \see make_permutation_iterator
+ */
+template <typename ElementIterator,
+          typename IndexIterator>
+  class permutation_iterator
+    : public thrust::detail::permutation_iterator_base<
+        ElementIterator,
+        IndexIterator
+      >::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename detail::permutation_iterator_base<ElementIterator,IndexIterator>::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor calls the null constructor of this \p permutation_iterator's
+     *  element iterator.
+     */
+    permutation_iterator() = default;
+
+    /*! Constructor accepts an \c ElementIterator into a range of values and an
+     *  \c IndexIterator into a range of indices defining the indexing scheme on the
+     *  values.
+     *
+     *  \param x An \c ElementIterator pointing this \p permutation_iterator's range of values.
+     *  \param y An \c IndexIterator pointing to an indexing scheme to use on \p x.
+     */
+    __host__ __device__
+    explicit permutation_iterator(ElementIterator x, IndexIterator y)
+      : super_t(y), m_element_iterator(x) {}
+
+    /*! Copy constructor accepts a related \p permutation_iterator.
+     *  \param r A compatible \p permutation_iterator to copy from.
+     */
+    template<typename OtherElementIterator, typename OtherIndexIterator>
+    __host__ __device__
+    permutation_iterator(permutation_iterator<OtherElementIterator,OtherIndexIterator> const &r
+    // XXX remove these guards when we have static_assert
+    , typename detail::enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
+    , typename detail::enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
+    )
+      : super_t(r.base()), m_element_iterator(r.m_element_iterator)
+    {}
+
+  /*! \cond
+   */
+  private:
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return *(m_element_iterator + *this->base());
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // make friends for the copy constructor
+    template<typename,typename> friend class permutation_iterator;
+
+    ElementIterator m_element_iterator;
+  /*! \endcond
+   */
+}; // end permutation_iterator
+
+
+/*! \p make_permutation_iterator creates a \p permutation_iterator
+ *  from an \c ElementIterator pointing to a range of elements to "permute"
+ *  and an \c IndexIterator pointing to a range of indices defining an indexing
+ *  scheme on the values.
+ *
+ *  \param e An \c ElementIterator pointing to a range of values.
+ *  \param i An \c IndexIterator pointing to an indexing scheme to use on \p e.
+ *  \return A new \p permutation_iterator which permutes the range \p e by \p i.
+ *  \see permutation_iterator
+ */
+template<typename ElementIterator, typename IndexIterator>
+__host__ __device__
+permutation_iterator<ElementIterator,IndexIterator> make_permutation_iterator(ElementIterator e, IndexIterator i)
+{
+  return permutation_iterator<ElementIterator,IndexIterator>(e,i);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/retag.h b/miniCUDA124/include/thrust/iterator/retag.h
new file mode 100644
index 0000000000000000000000000000000000000000..22fb8502b10e3e35c5775b8395c648efb1aa2991
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/retag.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/retag.h
+ *  \brief Functionality for altering an iterator's associated system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/retag.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \ingroup iterator_tags
+ *  \{
+ */
+
+#if 0
+/*! \p reinterpret_tag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag Any system tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is otherwise
+ *          equivalent to \p iter.
+ *  \note Unlike \p retag, \p reinterpret_tag does not enforce that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see retag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type reinterpret_tag(Iterator iter);
+
+/*! \p retag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag \p Tag shall be convertible to <tt>thrust::iterator_system<Iterator>::type</tt>,
+ *              or <tt>thrust::iterator_system<Iterator>::type</tt> is a base type of \p Tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is
+ *          otherwise equivalent to \p iter.
+ *  \note Unlike \p reinterpret_tag, \p retag enforces that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see reinterpret_tag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type retag(Iterator iter);
+#endif
+
+/*! \} // iterator_tags
+ */
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/reverse_iterator.h b/miniCUDA124/include/thrust/iterator/reverse_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..262facb3c73306181e7a758e6293be108a83a0e0
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/reverse_iterator.h
@@ -0,0 +1,245 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/reverse_iterator.h
+ *  \brief An iterator adaptor which adapts another iterator to traverse backwards
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/reverse_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p reverse_iterator is an iterator which represents a pointer into a
+ *  reversed view of a given range. In this way, \p reverse_iterator allows
+ *  backwards iteration through a bidirectional input range.
+ *
+ *  It is important to note that although \p reverse_iterator is constructed
+ *  from a given iterator, it points to the element preceding it. In this way,
+ *  the past-the-end \p reverse_iterator of a given range points to the element
+ *  preceding the first element of the input range. By the same token, the first
+ *  \p reverse_iterator of a given range is constructed from a past-the-end iterator
+ *  of the original range yet points to the last element of the input.
+ *
+ *  The following code snippet demonstrates how to create a \p reverse_iterator
+ *  which represents a reversed view of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/reverse_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  typedef thrust::device_vector<float>::iterator Iterator;
+ *
+ *  // note that we point the iterator to the *end* of the device_vector
+ *  thrust::reverse_iterator<Iterator> iter(values.end());
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Since reversing a range is a common operation, containers like \p device_vector
+ *  have nested typedefs for declaration shorthand and methods for constructing
+ *  reverse_iterators. The following code snippet is equivalent to the previous:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  // we use the nested type reverse_iterator to refer to a reversed view of
+ *  // a device_vector and the method rbegin() to create a reverse_iterator pointing
+ *  // to the beginning of the reversed device_vector
+ *  thrust::device_iterator<float>::reverse_iterator iter = values.rbegin();
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  // similarly, rend() points to the end of the reversed sequence:
+ *  assert(values.rend() == (iter + 4));
+ *  \endcode
+ *
+ *  Finally, the following code snippet demonstrates how to use reverse_iterator to
+ *  perform a reversed prefix sum operation on the contents of a device_vector:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/scan.h>
+ *  ...
+ *  thrust::device_vector<int> v(5);
+ *  v[0] = 0;
+ *  v[1] = 1;
+ *  v[2] = 2;
+ *  v[3] = 3;
+ *  v[4] = 4;
+ *
+ *  thrust::device_vector<int> result(5);
+ *
+ *  // exclusive scan v into result in reverse
+ *  thrust::exclusive_scan(v.rbegin(), v.rend(), result.begin());
+ *
+ *  // result is now {0, 4, 7, 9, 10}
+ *  \endcode
+ *
+ *  \see make_reverse_iterator
+ */
+template<typename BidirectionalIterator>
+  class reverse_iterator
+    : public detail::reverse_iterator_base<BidirectionalIterator>::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename thrust::detail::reverse_iterator_base<
+      BidirectionalIterator
+    >::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Default constructor does nothing.
+     */
+    __host__ __device__
+    reverse_iterator() {}
+
+    /*! \p Constructor accepts a \c BidirectionalIterator pointing to a range
+     *  for this \p reverse_iterator to reverse.
+     *
+     *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+     */
+    __host__ __device__
+    explicit reverse_iterator(BidirectionalIterator x);
+
+    /*! \p Copy constructor allows construction from a related compatible
+     *  \p reverse_iterator.
+     *
+     *  \param r A \p reverse_iterator to copy from.
+     */
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    reverse_iterator(reverse_iterator<OtherBidirectionalIterator> const &r
+// XXX msvc screws this up
+// XXX remove these guards when we have static_assert
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     , typename thrust::detail::enable_if<
+                         thrust::detail::is_convertible<
+                           OtherBidirectionalIterator,
+                           BidirectionalIterator
+                         >::value
+                       >::type * = 0
+#endif // MSVC
+                     );
+
+  /*! \cond
+   */
+  private:
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    __host__ __device__
+    void increment();
+
+    __host__ __device__
+    void decrement();
+
+    __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    typename super_t::difference_type
+    distance_to(reverse_iterator<OtherBidirectionalIterator> const &y) const;
+  /*! \endcond
+   */
+}; // end reverse_iterator
+
+
+/*! \p make_reverse_iterator creates a \p reverse_iterator
+ *  from a \c BidirectionalIterator pointing to a range of elements to reverse.
+ *
+ *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+ *  \return A new \p reverse_iterator which reverses the range \p x.
+ */
+template<typename BidirectionalIterator>
+__host__ __device__
+reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/reverse_iterator.inl>
+
diff --git a/miniCUDA124/include/thrust/iterator/transform_input_output_iterator.h b/miniCUDA124/include/thrust/iterator/transform_input_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e57dd0de95f7331e43657496cd0d8bda6b9d1a9
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/transform_input_output_iterator.h
@@ -0,0 +1,172 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_input_output_iterator.h
+ *  \brief An iterator which adapts another iterator by applying transform
+ *         functions when reading and writing dereferenced values.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/transform_input_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_input_output_iterator is a special kind of iterator which applies
+ * transform functions when reading from or writing to dereferenced values.
+ * This iterator is useful for algorithms that operate on a type that needs to
+ * be serialized/deserialized from values in another iterator, avoiding the
+ * need to materialize intermediate results in memory. This also enables the
+ * transform functions to be fused with the operations that read and write to
+ * the `transform_input_output_iterator`.
+ *
+ * The following code snippet demonstrates how to create a
+ * \p transform_input_output_iterator which performs different transformations when
+ * reading from and writing to the iterator.
+ *
+ * \code
+ * #include <thrust/iterator/transform_input_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    const size_t size = 4;
+ *    thrust::device_vector<float> v(size);
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to vector
+ *    thrust::sequence(v.begin(), v.end(), 1);
+ *
+ *    // Iterator that returns negated values and writes squared values
+ *    auto iter = thrust::make_transform_input_output_iterator(v.begin(),
+ *        thrust::negate<float>{}, thrust::square<float>{});
+ *
+ *    // Iterator negates values when reading
+ *    std::cout << iter[0] << " ";  // -1.0f;
+ *    std::cout << iter[1] << " ";  // -2.0f;
+ *    std::cout << iter[2] << " ";  // -3.0f;
+ *    std::cout << iter[3] << "\n"; // -4.0f;
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to iterator
+ *    thrust::sequence(iter, iter + size, 1);
+ *
+ *    // Values were squared before writing to vector
+ *    std::cout << v[0] << " ";  // 1.0f;
+ *    std::cout << v[1] << " ";  // 4.0f;
+ *    std::cout << v[2] << " ";  // 9.0f;
+ *    std::cout << v[3] << "\n"; // 16.0f;
+ *
+ *  }
+ * \endcode
+ *
+ * \see make_transform_input_output_iterator
+ */
+
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator
+    : public detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_input_output_iterator() = default;
+
+  /*! This constructor takes as argument a \c Iterator an \c InputFunction and an
+   * \c OutputFunction and copies them to a new \p transform_input_output_iterator
+   *
+   * \param io An \c Iterator pointing to where the input to \c InputFunction
+   *           will be read from and the result of \c OutputFunction will be written to
+   * \param input_function An \c InputFunction to be executed on values read from the iterator
+   * \param output_function An \c OutputFunction to be executed on values written to the iterator
+   */
+    __host__ __device__
+    transform_input_output_iterator(Iterator const& io, InputFunction input_function, OutputFunction output_function)
+      : super_t(io), input_function(input_function), output_function(output_function)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_input_output_iterator_proxy<
+        InputFunction, OutputFunction, Iterator
+      >(this->base_reference(), input_function, output_function);
+    }
+
+    InputFunction input_function;
+    OutputFunction output_function;
+
+    /*! \endcond
+     */
+}; // end transform_input_output_iterator
+
+/*! \p make_transform_input_output_iterator creates a \p transform_input_output_iterator from
+ *  an \c Iterator a \c InputFunction and a \c OutputFunction
+ *
+ * \param io An \c Iterator pointing to where the input to \c InputFunction
+ *           will be read from and the result of \c OutputFunction will be written to
+ * \param input_function An \c InputFunction to be executed on values read from the iterator
+ * \param output_function An \c OutputFunction to be executed on values written to the iterator
+ *  \see transform_input_output_iterator
+ */
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+transform_input_output_iterator<InputFunction, OutputFunction, Iterator>
+__host__ __device__
+make_transform_input_output_iterator(Iterator io, InputFunction input_function, OutputFunction output_function)
+{
+    return transform_input_output_iterator<InputFunction, OutputFunction, Iterator>(io, input_function, output_function);
+} // end make_transform_input_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/transform_iterator.h b/miniCUDA124/include/thrust/iterator/transform_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0f422b88d028c6a4ae691f41bd63f3b1595e5aa
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/transform_iterator.h
@@ -0,0 +1,362 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/transform_iterator.h
+ *  \brief An iterator which adapts another iterator by applying a function to the result of its dereference
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+// #include the details first
+#include <thrust/iterator/detail/transform_iterator.inl>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_iterator is an iterator which represents a pointer into a range
+ *  of values after transformation by a function. This iterator is useful for
+ *  creating a range filled with the result of applying an operation to another range
+ *  without either explicitly storing it in memory, or explicitly executing the transformation.
+ *  Using \p transform_iterator facilitates kernel fusion by deferring the execution
+ *  of a transformation until the value is needed while saving both memory capacity
+ *  and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p transform_iterator
+ *  which represents the result of \c sqrtf applied to the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    thrust::transform_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p transform_iterator with the
+ *  \p thrust::reduce function to compute the sum of squares of a sequence.
+ *  We will create temporary \p transform_iterators with the
+ *  \p make_transform_iterator function in order to avoid explicitly specifying their type:
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/reduce.h>
+ *  #include <iostream>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return x * x;
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    // initialize a device array
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 2.0f;
+ *    v[2] = 3.0f;
+ *    v[3] = 4.0f;
+ *
+ *    float sum_of_squares =
+ *     thrust::reduce(thrust::make_transform_iterator(v.begin(), square()),
+ *                    thrust::make_transform_iterator(v.end(),   square()));
+ *
+ *    std::cout << "sum of squares: " << sum_of_squares << std::endl;
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Note that in the previous two examples the transform functor (namely \c square_root
+ *  and \c square) inherits from \c thrust::unary_function.  Inheriting from
+ *  \c thrust::unary_function ensures that a functor is a valid \c AdaptableUnaryFunction
+ *  and provides all the necessary \c typedef declarations.  The \p transform_iterator
+ *  can also be applied to a \c UnaryFunction that does not inherit from
+ *  \c thrust::unary_function using an optional template argument.  The following example
+ *  illustrates how to use the third template argument to specify the \c result_type of
+ *  the function.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor *does not* inherit from unary_function
+ *  struct square_root
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    // note: float result_type is specified explicitly
+ *    thrust::transform_iterator<square_root, FloatIterator, float> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
+  class transform_iterator
+    : public detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+{
+  /*! \cond
+   */
+  public:
+    typedef typename
+    detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor does nothing.
+     */
+    transform_iterator() = default;
+
+#if THRUST_CPP_DIALECT >= 2011
+    transform_iterator(transform_iterator const&) = default;
+#endif
+
+    /*! This constructor takes as arguments an \c Iterator and an \c AdaptableUnaryFunction
+     *  and copies them to a new \p transform_iterator.
+     *
+     *  \param x An \c Iterator pointing to the input to this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \param f An \c AdaptableUnaryFunction used to transform the objects pointed to by \p x.
+     */
+    __host__ __device__
+    transform_iterator(Iterator const& x, AdaptableUnaryFunction f)
+      : super_t(x), m_f(f) {
+    }
+
+    /*! This explicit constructor copies the value of a given \c Iterator and creates
+     *  this \p transform_iterator's \c AdaptableUnaryFunction using its null constructor.
+     *
+     *  \param x An \c Iterator to copy.
+     */
+    __host__ __device__
+    explicit transform_iterator(Iterator const& x)
+      : super_t(x) { }
+
+    /*! This copy constructor creates a new \p transform_iterator from another
+     *  \p transform_iterator.
+     *
+     *  \param other The \p transform_iterator to copy.
+     */
+    template<typename OtherAdaptableUnaryFunction,
+             typename OtherIterator,
+             typename OtherReference,
+             typename OtherValue>
+    __host__ __device__
+    transform_iterator(const transform_iterator<OtherAdaptableUnaryFunction, OtherIterator, OtherReference, OtherValue> &other,
+                       typename thrust::detail::enable_if_convertible<OtherIterator, Iterator>::type* = 0,
+                       typename thrust::detail::enable_if_convertible<OtherAdaptableUnaryFunction, AdaptableUnaryFunction>::type* = 0)
+      : super_t(other.base()), m_f(other.functor()) {}
+
+    /*! Copy assignment operator copies from another \p transform_iterator.
+     *  \p other The other \p transform_iterator to copy
+     *  \return <tt>*this</tt>
+     *
+     *  \note If the type of this \p transform_iterator's functor is not copy assignable
+     *        (for example, if it is a lambda) it is not an error to call this function.
+     *        In this case, however, the functor will not be modified.
+     *
+     *        In any case, this \p transform_iterator's underlying iterator will be copy assigned.
+     */
+    __host__ __device__
+    transform_iterator &operator=(const transform_iterator &other)
+    {
+      return do_assign(other,
+      // XXX gcc 4.2.1 crashes on is_copy_assignable; just assume the functor is assignable as a WAR
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION <= 40201)
+          thrust::detail::true_type()
+#else
+          typename thrust::detail::is_copy_assignable<AdaptableUnaryFunction>::type()
+#endif // THRUST_HOST_COMPILER
+      );
+    }
+
+    /*! This method returns a copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \return A copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     */
+    __host__ __device__
+    AdaptableUnaryFunction functor() const
+      { return m_f; }
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::true_type)
+    {
+      super_t::operator=(other);
+
+      // do assign to m_f
+      m_f = other.functor();
+
+      return *this;
+    }
+
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::false_type)
+    {
+      super_t::operator=(other);
+
+      // don't assign to m_f
+
+      return *this;
+    }
+
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      // Create a temporary to allow iterators with wrapped references to
+      // convert to their value type before calling m_f. Note that this
+      // disallows non-constant operations through m_f.
+      typename thrust::iterator_value<Iterator>::type const& x = *this->base();
+      return m_f(x);
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // tag this as mutable per Dave Abrahams in this thread:
+    // http://lists.boost.org/Archives/boost/2004/05/65332.php
+    mutable AdaptableUnaryFunction m_f;
+
+    /*! \endcond
+     */
+}; // end transform_iterator
+
+
+/*! \p make_transform_iterator creates a \p transform_iterator
+ *  from an \c Iterator and \c AdaptableUnaryFunction.
+ *
+ *  \param it The \c Iterator pointing to the input range of the
+ *            newly created \p transform_iterator.
+ *  \param fun The \c AdaptableUnaryFunction used to transform the range pointed
+ *             to by \p it in the newly created \p transform_iterator.
+ *  \return A new \p transform_iterator which transforms the range at
+ *          \p it by \p fun.
+ *  \see transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator>
+inline __host__ __device__
+transform_iterator<AdaptableUnaryFunction, Iterator>
+make_transform_iterator(Iterator it, AdaptableUnaryFunction fun)
+{
+  return transform_iterator<AdaptableUnaryFunction, Iterator>(it, fun);
+} // end make_transform_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/transform_output_iterator.h b/miniCUDA124/include/thrust/iterator/transform_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc637e535cef36c121349fd45d9225c243c75804
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/transform_output_iterator.h
@@ -0,0 +1,172 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_output_iterator.h
+ *  \brief An output iterator which adapts another output iterator by applying a
+ *         function to the result of its dereference before writing it.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/transform_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_output_iterator is a special kind of output iterator which
+ * transforms a value written upon dereference. This iterator is useful
+ * for transforming an output from algorithms without explicitly storing the
+ * intermediate result in the memory and applying subsequent transformation,
+ * thereby avoiding wasting memory capacity and bandwidth.
+ * Using \p transform_iterator facilitates kernel fusion by deferring execution
+ * of transformation until the value is written while saving both memory
+ * capacity and bandwidth.
+ *
+ * The following code snippet demonstrated how to create a
+ * \p transform_output_iterator which applies \c sqrtf to the assigning value.
+ *
+ * \code
+ * #include <thrust/iterator/transform_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ * // note: functor inherits form unary function
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *    thrust::transform_output_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    iter[0] =  1.0f;    // stores sqrtf( 1.0f)
+ *    iter[1] =  4.0f;    // stores sqrtf( 4.0f)
+ *    iter[2] =  9.0f;    // stores sqrtf( 9.0f)
+ *    iter[3] = 16.0f;    // stores sqrtf(16.0f)
+ *    // iter[4] is an out-of-bounds error
+ *
+ *    v[0]; // returns 1.0f;
+ *    v[1]; // returns 2.0f;
+ *    v[2]; // returns 3.0f;
+ *    v[3]; // returns 4.0f;
+ *
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_output_iterator
+ */
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator
+    : public detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_output_iterator() = default;
+
+  /*! This constructor takes as argument an \c OutputIterator and an \c
+   * UnaryFunction and copies them to a new \p transform_output_iterator
+   *
+   * \param out An \c OutputIterator pointing to the output range whereto the result of
+   *            \p transform_output_iterator's \c UnaryFunction will be written.
+   * \param fun An \c UnaryFunction used to transform the objects assigned to
+   *            this \p transform_output_iterator.
+   */
+    __host__ __device__
+    transform_output_iterator(OutputIterator const& out, UnaryFunction fun) : super_t(out), fun(fun)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_output_iterator_proxy<
+        UnaryFunction, OutputIterator
+      >(this->base_reference(), fun);
+    }
+
+    UnaryFunction fun;
+
+    /*! \endcond
+     */
+}; // end transform_output_iterator
+
+/*! \p make_transform_output_iterator creates a \p transform_output_iterator from
+ *  an \c OutputIterator and \c UnaryFunction.
+ *
+ *  \param out The \c OutputIterator pointing to the output range of the newly
+ *            created \p transform_output_iterator
+ *  \param fun The \c UnaryFunction transform the object before assigning it to
+ *            \c out by the newly created \p transform_output_iterator
+ *  \see transform_output_iterator
+ */
+template <typename UnaryFunction, typename OutputIterator>
+transform_output_iterator<UnaryFunction, OutputIterator>
+__host__ __device__
+make_transform_output_iterator(OutputIterator out, UnaryFunction fun)
+{
+    return transform_output_iterator<UnaryFunction, OutputIterator>(out, fun);
+} // end make_transform_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/iterator/zip_iterator.h b/miniCUDA124/include/thrust/iterator/zip_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..5151eacafb77575bbb2bd7659f45a83db391aca6
--- /dev/null
+++ b/miniCUDA124/include/thrust/iterator/zip_iterator.h
@@ -0,0 +1,266 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/zip_iterator.h
+ *  \brief An iterator which returns a tuple of the result of dereferencing
+ *         a tuple of iterators when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams and Thomas Becker 2000-2006.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/iterator/detail/zip_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p zip_iterator is an iterator which represents a pointer into a range
+ *  of \p tuples whose elements are themselves taken from a \p tuple of input
+ *  iterators. This iterator is useful for creating a virtual array of structures
+ *  while achieving the same performance and bandwidth as the structure of arrays
+ *  idiom. \p zip_iterator also facilitates kernel fusion by providing a convenient
+ *  means of amortizing the execution of the same operation over multiple ranges.
+ *
+ *  The following code snippet demonstrates how to create a \p zip_iterator
+ *  which represents the result of "zipping" multiple ranges together.
+ *
+ *  \code
+ *  #include <thrust/iterator/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> int_v(3);
+ *  int_v[0] = 0; int_v[1] = 1; int_v[2] = 2;
+ *
+ *  thrust::device_vector<float> float_v(3);
+ *  float_v[0] = 0.0f; float_v[1] = 1.0f; float_v[2] = 2.0f;
+ *
+ *  thrust::device_vector<char> char_v(3);
+ *  char_v[0] = 'a'; char_v[1] = 'b'; char_v[2] = 'c';
+ *
+ *  // typedef these iterators for shorthand
+ *  typedef thrust::device_vector<int>::iterator   IntIterator;
+ *  typedef thrust::device_vector<float>::iterator FloatIterator;
+ *  typedef thrust::device_vector<char>::iterator  CharIterator;
+ *
+ *  // typedef a tuple of these iterators
+ *  typedef thrust::tuple<IntIterator, FloatIterator, CharIterator> IteratorTuple;
+ *
+ *  // typedef the zip_iterator of this tuple
+ *  typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
+ *
+ *  // finally, create the zip_iterator
+ *  ZipIterator iter(thrust::make_tuple(int_v.begin(), float_v.begin(), char_v.begin()));
+ *
+ *  *iter;   // returns (0, 0.0f, 'a')
+ *  iter[0]; // returns (0, 0.0f, 'a')
+ *  iter[1]; // returns (1, 1.0f, 'b')
+ *  iter[2]; // returns (2, 2.0f, 'c')
+ *
+ *  thrust::get<0>(iter[2]); // returns 2
+ *  thrust::get<1>(iter[0]); // returns 0.0f
+ *  thrust::get<2>(iter[1]); // returns 'b'
+ *
+ *  // iter[3] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Defining the type of a \p zip_iterator can be complex. The next code example demonstrates
+ *  how to use the \p make_zip_iterator function with the \p make_tuple function to avoid
+ *  explicitly specifying the type of the \p zip_iterator. This example shows how to use
+ *  \p zip_iterator to copy multiple ranges with a single call to \p thrust::copy.
+ *
+ *  \code
+ *  #include <thrust/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> int_in(3), int_out(3);
+ *    int_in[0] = 0;
+ *    int_in[1] = 1;
+ *    int_in[2] = 2;
+ *
+ *    thrust::device_vector<float> float_in(3), float_out(3);
+ *    float_in[0] =  0.0f;
+ *    float_in[1] = 10.0f;
+ *    float_in[2] = 20.0f;
+ *
+ *    thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(int_in.begin(), float_in.begin())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_in.end(),   float_in.end())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_out.begin(),float_out.begin())));
+ *
+ *    // int_out is now [0, 1, 2]
+ *    // float_out is now [0.0f, 10.0f, 20.0f]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_zip_iterator
+ *  \see make_tuple
+ *  \see tuple
+ *  \see get
+ */
+template <typename IteratorTuple>
+  class zip_iterator
+    : public detail::zip_iterator_base<IteratorTuple>::type
+{
+  public:
+    /*! Null constructor does nothing.
+     */
+    inline __host__ __device__
+    zip_iterator();
+
+    /*! This constructor creates a new \p zip_iterator from a
+     *  \p tuple of iterators.
+     *
+     *  \param iterator_tuple The \p tuple of iterators to copy from.
+     */
+    inline __host__ __device__
+    zip_iterator(IteratorTuple iterator_tuple);
+
+    /*! This copy constructor creates a new \p zip_iterator from another
+     *  \p zip_iterator.
+     *
+     *  \param other The \p zip_iterator to copy.
+     */
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
+                 typename thrust::detail::enable_if_convertible<
+                   OtherIteratorTuple,
+                   IteratorTuple
+                 >::type * = 0);
+
+    /*! This method returns a \c const reference to this \p zip_iterator's
+     *  \p tuple of iterators.
+     *
+     *  \return A \c const reference to this \p zip_iterator's \p tuple
+     *          of iterators.
+     */
+    inline __host__ __device__
+    const IteratorTuple &get_iterator_tuple() const;
+
+    /*! \cond
+     */
+  private:
+    typedef typename
+    detail::zip_iterator_base<IteratorTuple>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+    // Dereferencing returns a tuple built from the dereferenced
+    // iterators in the iterator tuple.
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    // Two zip_iterators are equal if the two first iterators of the
+    // tuple are equal. Note this differs from Boost's implementation, which
+    // considers the entire tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    bool equal(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // Advancing a zip_iterator means to advance all iterators in the tuple
+    inline __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    // Incrementing a zip iterator means to increment all iterators in the tuple
+    inline __host__ __device__
+    void increment();
+
+    // Decrementing a zip iterator means to decrement all iterators in the tuple
+    inline __host__ __device__
+    void decrement();
+
+    // Distance is calculated using the first iterator in the tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+      typename super_t::difference_type
+        distance_to(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // The iterator tuple.
+    IteratorTuple m_iterator_tuple;
+
+    /*! \endcond
+     */
+}; // end zip_iterator
+
+/*! \p make_zip_iterator creates a \p zip_iterator from a \p tuple
+ *  of iterators.
+ *
+ *  \param t The \p tuple of iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators encapsulated in \p t.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(thrust::tuple<Iterators...> t);
+
+
+/*! \p make_zip_iterator creates a \p zip_iterator from
+ *  iterators.
+ *
+ *  \param its The iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(Iterators... its);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/zip_iterator.inl>
+
diff --git a/miniCUDA124/include/thrust/mr/allocator.h b/miniCUDA124/include/thrust/mr/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd6fd000d73e49b391fdc49aa4a2609332544c4d
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/allocator.h
@@ -0,0 +1,262 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Allocator types usable with \ref Memory Resources.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <limits>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/validator.h>
+#include <thrust/mr/polymorphic_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! An \p mr::allocator is a template that fulfills the C++ requirements for Allocators,
+ *  allowing to use the NPA-based memory resources where an Allocator is required. Unlike
+ *  memory resources, but like other allocators, \p mr::allocator is typed and bound to
+ *  allocate object of a specific type, however it can be freely rebound to other types.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam MR the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, class MR>
+class allocator : private validator<MR>
+{
+public:
+    /*! The pointer to void type of this allocator. */
+    typedef typename MR::pointer void_pointer;
+
+    /*! The value type allocated by this allocator. Equivalent to \p T. */
+    typedef T value_type;
+    /*! The pointer type allocated by this allocator. Equivaled to the pointer type of \p MR rebound to \p T. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<T>::other pointer;
+    /*! The pointer to const type. Equivalent to a pointer type of \p MR rebound to <tt>const T</tt>. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<const T>::other const_pointer;
+    /*! The reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+    /*! The const reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+    /*! The size type of this allocator. Always \p std::size_t. */
+    typedef std::size_t size_type;
+    /*! The difference type between pointers allocated by this allocator. */
+    typedef typename thrust::detail::pointer_traits<pointer>::difference_type difference_type;
+
+    /*! Specifies that the allocator shall be propagated on container copy assignment. */
+    typedef detail::true_type propagate_on_container_copy_assignment;
+    /*! Specifies that the allocator shall be propagated on container move assignment. */
+    typedef detail::true_type propagate_on_container_move_assignment;
+    /*! Specifies that the allocator shall be propagated on container swap. */
+    typedef detail::true_type propagate_on_container_swap;
+
+    /*! The \p rebind metafunction provides the type of an \p allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p allocator.
+         */
+        typedef allocator<U, MR> other;
+    };
+
+    /*! Calculates the maximum number of elements allocated by this allocator.
+     *
+     *  \return the maximum value of \p std::size_t, divided by the size of \p T.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)() / sizeof(T);
+    }
+
+    /*! Constructor.
+     *
+     *  \param resource the resource to be used to allocate raw memory.
+     */
+    __host__ __device__
+    allocator(MR * resource) : mem_res(resource)
+    {
+    }
+
+    /*! Copy constructor. Copies the resource pointer. */
+    template<typename U>
+    __host__ __device__
+    allocator(const allocator<U, MR> & other) : mem_res(other.resource())
+    {
+    }
+
+    /*! Allocates objects of type \p T.
+     *
+     *  \param n number of elements to allocate
+     *  \return a pointer to the newly allocated storage.
+     */
+    THRUST_NODISCARD
+    __host__
+    pointer allocate(size_type n)
+    {
+        return static_cast<pointer>(mem_res->do_allocate(n * sizeof(T), THRUST_ALIGNOF(T)));
+    }
+
+    /*! Deallocates objects of type \p T.
+     *
+     *  \param p pointer returned by a previous call to \p allocate
+     *  \param n number of elements, passed as an argument to the \p allocate call that produced \p p
+     */
+    __host__
+    void deallocate(pointer p, size_type n)
+    {
+        return mem_res->do_deallocate(p, n * sizeof(T), THRUST_ALIGNOF(T));
+    }
+
+    /*! Extracts the memory resource used by this allocator.
+     *
+     *  \return the memory resource used by this allocator.
+     */
+    __host__ __device__
+    MR * resource() const
+    {
+        return mem_res;
+    }
+
+private:
+    MR * mem_res;
+};
+
+/*! Compares the allocators for equality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator==(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return *lhs.resource() == *rhs.resource();
+}
+
+/*! Compares the allocators for inequality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator!=(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename T, typename Pointer>
+using polymorphic_allocator = allocator<T, polymorphic_adaptor_resource<Pointer> >;
+
+#else // C++11
+
+template<typename T, typename Pointer>
+class polymorphic_allocator : public allocator<T, polymorphic_adaptor_resource<Pointer> >
+{
+    typedef allocator<T, polymorphic_adaptor_resource<Pointer> > base;
+
+public:
+    /*! Initializes the base class with the parameter \p resource.
+     */
+    polymorphic_allocator(polymorphic_adaptor_resource<Pointer>  * resource) : base(resource)
+    {
+    }
+};
+
+#endif // C++11
+
+/*! A helper allocator class that uses global instances of a given upstream memory resource. Requires the memory resource
+ *      to be default constructible.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam Upstream the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, typename Upstream>
+class stateless_resource_allocator : public thrust::mr::allocator<T, Upstream>
+{
+    typedef thrust::mr::allocator<T, Upstream> base;
+
+public:
+    /*! The \p rebind metafunction provides the type of an \p stateless_resource_allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p stateless_resource_allocator.
+         */
+        typedef stateless_resource_allocator<U, Upstream> other;
+    };
+
+    /*! Default constructor. Uses \p get_global_resource to get the global instance of \p Upstream and initializes the
+     *      \p allocator base subobject with that resource.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    stateless_resource_allocator() : base(get_global_resource<Upstream>())
+    {
+    }
+
+    /*! Copy constructor. Copies the memory resource pointer. */
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator & other)
+        : base(other) {}
+
+    /*! Conversion constructor from an allocator of a different type. Copies the memory resource pointer. */
+    template<typename U>
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator<U, Upstream> & other)
+        : base(other) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    stateless_resource_allocator & operator=(const stateless_resource_allocator &) = default;
+#endif
+
+    /*! Destructor. */
+    __host__ __device__
+    ~stateless_resource_allocator() {}
+};
+
+/*! \} // allocators
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/device_memory_resource.h b/miniCUDA124/include/thrust/mr/device_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..aad807db9357b794d4784f255c68350eacd03236
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/device_memory_resource.h
@@ -0,0 +1,46 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+// #include the device system's memory_resource header
+#define __THRUST_DEVICE_SYSTEM_MEMORY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::memory_resource
+    device_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_memory_resource
+    universal_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_host_pinned_memory_resource
+    universal_host_pinned_memory_resource;
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/disjoint_pool.h b/miniCUDA124/include/thrust/mr/disjoint_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d4e05d44c26f95ff17a71030aea966f884c0d30
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/disjoint_pool.h
@@ -0,0 +1,499 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A caching and pooling memory resource adaptor which uses separate upstream resources for memory allocation
+ *      and bookkeeping.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/algorithm_wrapper.h>
+#include <thrust/detail/config.h>
+
+#include <thrust/host_vector.h>
+#include <thrust/binary_search.h>
+#include <thrust/detail/seq.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/pool_options.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource adaptor allowing for pooling and caching allocations from \p Upstream, using \p Bookkeeper for
+ *      management of that cached and pooled memory, allowing to cache portions of memory inaccessible from the host.
+ *
+ *  On a typical memory resource, calls to \p allocate and \p deallocate actually allocate and deallocate memory. Pooling
+ *      memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when
+ *      there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make
+ *      memory allocation faster and more efficient.
+ *
+ *  The disjoint version of the pool resources uses a separate upstream memory resource, \p Bookkeeper, to allocate memory
+ *      necessary to manage the cached memory. There may be many reasons to do that; the canonical one is that \p Upstream
+ *      allocates memory that is inaccessible to the code of the pool resource, which means that it cannot embed the necessary
+ *      information in memory obtained from \p Upstream; for instance, \p Upstream can be a CUDA non-managed memory
+ *      resource, or a CUDA managed memory resource whose memory we would prefer to not migrate back and forth between
+ *      host and device when executing bookkeeping code.
+ *
+ *  This is not the only case where it makes sense to use a disjoint pool resource, though. In a multi-core environment
+ *      it may be beneficial to avoid stealing cache lines from other cores by writing over bookkeeping information
+ *      embedded in an allocated block of memory. In such a case, one can imagine wanting to use a disjoint pool where
+ *      both the upstream and the bookkeeper are of the same type, to allocate memory consistently, but separately for
+ *      those two purposes.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+class disjoint_unsynchronized_pool_resource final
+    : public memory_resource<typename Upstream::pointer>,
+        private validator2<Upstream, Bookkeeper>
+{
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        pool_options ret;
+
+        ret.min_blocks_per_chunk = 16;
+        ret.min_bytes_per_chunk = 1024;
+        ret.max_blocks_per_chunk = static_cast<std::size_t>(1) << 20;
+        ret.max_bytes_per_chunk = static_cast<std::size_t>(1) << 30;
+
+        ret.smallest_block_size = THRUST_MR_DEFAULT_ALIGNMENT;
+        ret.largest_block_size = static_cast<std::size_t>(1) << 20;
+
+        ret.alignment = THRUST_MR_DEFAULT_ALIGNMENT;
+
+        ret.cache_oversized = true;
+
+        ret.cached_size_cutoff_factor = 16;
+        ret.cached_alignment_cutoff_factor = 16;
+
+        return ret;
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : m_upstream(upstream),
+        m_bookkeeper(bookkeeper),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    // TODO: C++11: use delegating constructors
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(pool_options options = get_default_options())
+        : m_upstream(get_global_resource<Upstream>()),
+        m_bookkeeper(get_global_resource<Bookkeeper>()),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    /*! Destructor. Releases all held memory to upstream.
+     */
+    ~disjoint_unsynchronized_pool_resource()
+    {
+        release();
+    }
+
+private:
+    typedef typename Upstream::pointer void_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<char>::other char_ptr;
+
+    struct chunk_descriptor
+    {
+        std::size_t size;
+        void_ptr pointer;
+    };
+
+    typedef thrust::host_vector<
+        chunk_descriptor,
+        allocator<chunk_descriptor, Bookkeeper>
+    > chunk_vector;
+
+    struct oversized_block_descriptor
+    {
+        std::size_t size;
+        std::size_t alignment;
+        void_ptr pointer;
+
+        __host__ __device__
+        bool operator==(const oversized_block_descriptor & other) const
+        {
+            return size == other.size && alignment == other.alignment && pointer == other.pointer;
+        }
+
+        __host__ __device__
+        bool operator<(const oversized_block_descriptor & other) const
+        {
+            return size < other.size || (size == other.size && alignment < other.alignment);
+        }
+    };
+
+    struct equal_pointers
+    {
+    public:
+        __host__ __device__
+        equal_pointers(void_ptr p) : p(p)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.pointer == p;
+        }
+
+    private:
+        void_ptr p;
+    };
+
+    struct matching_alignment
+    {
+    public:
+        __host__ __device__
+        matching_alignment(std::size_t requested) : requested(requested)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.alignment >= requested;
+        }
+
+    private:
+        std::size_t requested;
+    };
+
+    typedef thrust::host_vector<
+        oversized_block_descriptor,
+        allocator<oversized_block_descriptor, Bookkeeper>
+    > oversized_block_vector;
+
+    typedef thrust::host_vector<
+        void_ptr,
+        allocator<void_ptr, Bookkeeper>
+    > pointer_vector;
+
+    struct pool
+    {
+        __host__
+        pool(const pointer_vector & free)
+            : free_blocks(free),
+            previous_allocated_count(0)
+        {
+        }
+
+        __host__
+        pool(const pool & other)
+            : free_blocks(other.free_blocks),
+            previous_allocated_count(other.previous_allocated_count)
+        {
+        }
+
+#if THRUST_CPP_DIALECT >= 2011
+        pool & operator=(const pool &) = default;
+#endif
+
+        __host__
+        ~pool() {}
+
+        pointer_vector free_blocks;
+        std::size_t previous_allocated_count;
+    };
+
+    typedef thrust::host_vector<
+        pool,
+        allocator<pool, Bookkeeper>
+    > pool_vector;
+
+    Upstream * m_upstream;
+    Bookkeeper * m_bookkeeper;
+
+    pool_options m_options;
+    std::size_t m_smallest_block_log2;
+
+    // buckets containing free lists for each pooled size
+    pool_vector m_pools;
+    // list of all allocations from upstream for the above
+    chunk_vector m_allocated;
+    // list of all cached oversized/overaligned blocks that have been returned to the pool to cache
+    oversized_block_vector m_cached_oversized;
+    // list of all oversized/overaligned allocations from upstream
+    oversized_block_vector m_oversized;
+
+public:
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        // reset the buckets
+        for (std::size_t i = 0; i < m_pools.size(); ++i)
+        {
+            m_pools[i].free_blocks.clear();
+            m_pools[i].previous_allocated_count = 0;
+        }
+
+        // deallocate memory allocated for the buckets
+        for (std::size_t i = 0; i < m_allocated.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_allocated[i].pointer,
+                m_allocated[i].size,
+                m_options.alignment);
+        }
+
+        // deallocate cached oversized/overaligned memory
+        for (std::size_t i = 0; i < m_oversized.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_oversized[i].pointer,
+                m_oversized[i].size,
+                m_oversized[i].alignment);
+        }
+
+        m_allocated.clear();
+        m_oversized.clear();
+        m_cached_oversized.clear();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        bytes = (std::max)(bytes, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // an oversized and/or overaligned allocation requested; needs to be allocated separately
+        if (bytes > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            oversized_block_descriptor oversized;
+            oversized.size = bytes;
+            oversized.alignment = alignment;
+
+            if (m_options.cache_oversized && !m_cached_oversized.empty())
+            {
+                typename oversized_block_vector::iterator it = thrust::lower_bound(
+                    thrust::seq,
+                    m_cached_oversized.begin(),
+                    m_cached_oversized.end(),
+                    oversized);
+
+                // if the size is bigger than the requested size by a factor
+                // bigger than or equal to the specified cutoff for size,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t size_factor = (*it).size / bytes;
+                    if (size_factor >= m_options.cached_size_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end() && (*it).alignment < alignment)
+                {
+                    it = find_if(it + 1, m_cached_oversized.end(), matching_alignment(alignment));
+                }
+
+                // if the alignment is bigger than the requested one by a factor
+                // bigger than or equal to the specified cutoff for alignment,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t alignment_factor = (*it).alignment / alignment;
+                    if (alignment_factor >= m_options.cached_alignment_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end())
+                {
+                    oversized.pointer = (*it).pointer;
+                    m_cached_oversized.erase(it);
+                    return oversized.pointer;
+                }
+            }
+
+            // no fitting cached block found; allocate a new one that's just up to the specs
+            oversized.pointer = m_upstream->do_allocate(bytes, alignment);
+            m_oversized.push_back(oversized);
+
+            return oversized.pointer;
+        }
+
+        // the request is NOT for oversized and/or overaligned memory
+        // allocate a block from an appropriate bucket
+        std::size_t bytes_log2 = thrust::detail::log2_ri(bytes);
+        std::size_t bucket_idx = bytes_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        // if the free list of the bucket has no elements, allocate a new chunk
+        // and split it into blocks pushed to the free list
+        if (bucket.free_blocks.empty())
+        {
+            std::size_t bucket_size = static_cast<std::size_t>(1) << bytes_log2;
+
+            std::size_t n = bucket.previous_allocated_count;
+            if (n == 0)
+            {
+                n = m_options.min_blocks_per_chunk;
+                if (n < (m_options.min_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.min_bytes_per_chunk >> bytes_log2;
+                }
+            }
+            else
+            {
+                n = n * 3 / 2;
+                if (n > (m_options.max_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.max_bytes_per_chunk >> bytes_log2;
+                }
+                if (n > m_options.max_blocks_per_chunk)
+                {
+                    n = m_options.max_blocks_per_chunk;
+                }
+            }
+
+            bytes = n << bytes_log2;
+
+            assert(n >= m_options.min_blocks_per_chunk);
+            assert(n <= m_options.max_blocks_per_chunk);
+            assert(bytes >= m_options.min_bytes_per_chunk);
+            assert(bytes <= m_options.max_bytes_per_chunk);
+
+            chunk_descriptor allocated;
+            allocated.size = bytes;
+            allocated.pointer = m_upstream->do_allocate(bytes, m_options.alignment);
+            m_allocated.push_back(allocated);
+            bucket.previous_allocated_count = n;
+
+            for (std::size_t i = 0; i < n; ++i)
+            {
+                bucket.free_blocks.push_back(
+                    static_cast<void_ptr>(
+                        static_cast<char_ptr>(allocated.pointer) + i * bucket_size
+                    )
+                );
+            }
+        }
+
+        // allocate a block from the front of the bucket's free list
+        void_ptr ret = bucket.free_blocks.back();
+        bucket.free_blocks.pop_back();
+        return ret;
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        n = (std::max)(n, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // verify that the pointer is at least as aligned as claimed
+        assert(reinterpret_cast<detail::intmax_t>(detail::pointer_traits<void_ptr>::get(p)) % alignment == 0);
+
+        // the deallocated block is oversized and/or overaligned
+        if (n > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            typename oversized_block_vector::iterator it = find_if(m_oversized.begin(), m_oversized.end(), equal_pointers(p));
+            assert(it != m_oversized.end());
+
+            oversized_block_descriptor oversized = *it;
+
+            if (m_options.cache_oversized)
+            {
+                typename oversized_block_vector::iterator position = lower_bound(m_cached_oversized.begin(), m_cached_oversized.end(), oversized);
+                m_cached_oversized.insert(position, oversized);
+                return;
+            }
+
+            m_oversized.erase(it);
+
+            m_upstream->do_deallocate(p, oversized.size, oversized.alignment);
+
+            return;
+        }
+
+        // push the block to the front of the appropriate bucket's free list
+        std::size_t n_log2 = thrust::detail::log2_ri(n);
+        std::size_t bucket_idx = n_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        bucket.free_blocks.push_back(p);
+    }
+};
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/disjoint_sync_pool.h b/miniCUDA124/include/thrust/mr/disjoint_sync_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..738c487864377d3db80aad1567e0a8bc99f3d290
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/disjoint_sync_pool.h
@@ -0,0 +1,125 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <mutex>
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource. Uses \p std::mutex, and therefore requires C++11.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+struct disjoint_synchronized_pool_resource : public memory_resource<typename Upstream::pointer>
+{
+    typedef disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> unsync_pool;
+    typedef std::lock_guard<std::mutex> lock_t;
+
+    typedef typename Upstream::pointer void_ptr;
+
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        return unsync_pool::get_default_options();
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : upstream_pool(upstream, bookkeeper, options)
+    {
+    }
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(pool_options options = get_default_options())
+        : upstream_pool(get_global_resource<Upstream>(), get_global_resource<Bookkeeper>(), options)
+    {
+    }
+
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        lock_t lock(mtx);
+        upstream_pool.release();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        return upstream_pool.do_allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        upstream_pool.do_deallocate(p, n, alignment);
+    }
+
+private:
+    std::mutex mtx;
+    unsync_pool upstream_pool;
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/mr/disjoint_tls_pool.h b/miniCUDA124/include/thrust/mr/disjoint_tls_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f509eec55c9e5d543c7c210b9881748efb6553f7
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/disjoint_tls_pool.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file disjoint_tls_pool.h
+ *  \brief A function wrapping a thread local instance of a \p disjoint_unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_management Memory Management
+ *  \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_resources
+ *  \{
+ */
+
+/*! Potentially constructs, if not yet created, and then returns the address of a thread-local
+ *      \p disjoint_unsynchronized_pool_resource,
+ *
+ *  \tparam Upstream the first template argument to the pool template
+ *  \tparam Bookkeeper the second template argument to the pool template
+ *  \param upstream the first argument to the constructor, if invoked
+ *  \param bookkeeper the second argument to the constructor, if invoked
+ */
+template<typename Upstream, typename Bookkeeper>
+__host__
+thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> & tls_disjoint_pool(
+    Upstream * upstream = NULL,
+    Bookkeeper * bookkeeper = NULL)
+{
+    static thread_local auto adaptor = [&]{
+        assert(upstream && bookkeeper);
+        return thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper>(upstream, bookkeeper);
+    }();
+
+    return adaptor;
+}
+
+/*! \}
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/mr/fancy_pointer_resource.h b/miniCUDA124/include/thrust/mr/fancy_pointer_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..f98da296bdb067731185ad5175687c61f6244cd6
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/fancy_pointer_resource.h
@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/validator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename Upstream, typename Pointer>
+class fancy_pointer_resource final : public memory_resource<Pointer>, private validator<Upstream>
+{
+public:
+    fancy_pointer_resource() : m_upstream(get_global_resource<Upstream>())
+    {
+    }
+
+    fancy_pointer_resource(Upstream * upstream) : m_upstream(upstream)
+    {
+    }
+
+    THRUST_NODISCARD
+    virtual Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return static_cast<Pointer>(m_upstream->do_allocate(bytes, alignment));
+    }
+
+    virtual void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        return m_upstream->do_deallocate(
+            static_cast<typename Upstream::pointer>(
+                thrust::detail::pointer_traits<Pointer>::get(p)),
+            bytes, alignment);
+    }
+
+private:
+    Upstream * m_upstream;
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/host_memory_resource.h b/miniCUDA124/include/thrust/mr/host_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..df016a1d9347e8aa064a59f53341c30dbc6714fc
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/host_memory_resource.h
@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+// #include the host system's memory_resource header
+#define __THRUST_HOST_SYSTEM_MEMORY_HEADER <__THRUST_HOST_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_HOST_SYSTEM_MEMORY_HEADER
+#undef __THRUST_HOST_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::memory_resource
+    host_memory_resource;
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/memory_resource.h b/miniCUDA124/include/thrust/mr/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b4ebede97cafd06ccce0fc01723dbb95e851604
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/memory_resource.h
@@ -0,0 +1,226 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A base class for the memory resource system, similar to
+ *  std::memory_resource, and related utilities.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/config/memory_resource.h>
+#ifdef THRUST_MR_STD_MR_HEADER
+#  include THRUST_MR_STD_MR_HEADER
+#endif
+
+THRUST_NAMESPACE_BEGIN
+/*! \brief \p thrust::mr is the namespace containing system agnostic types and functions for \p memory_resource related functionalities.
+ */
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p memory_resource is the base class for all other memory resources.
+ *
+ *  \tparam Pointer the pointer type that is allocated and deallocated by the memory resource
+ *      derived from this base class. If this is <tt>void *</tt>, this class derives from
+ *      <tt>std::pmr::memory_resource</tt>.
+ */
+template<typename Pointer = void *>
+class memory_resource
+{
+public:
+    /*! Alias for the template parameter.
+     */
+    typedef Pointer pointer;
+
+    /*! Virtual destructor, defaulted when possible.
+     */
+    virtual ~memory_resource() = default;
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the alignment of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the size of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+};
+
+template<>
+class memory_resource<void *>
+#ifdef THRUST_STD_MR_NS
+    : THRUST_STD_MR_NS::memory_resource
+#endif
+{
+public:
+    typedef void * pointer;
+
+    virtual ~memory_resource() = default;
+
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+
+#ifdef THRUST_STD_MR_NS
+    // the above do_is_equal is a different function than the one from the standard memory resource
+    // can't implement this reasonably without RTTI though; it's reasonable to assume false otherwise
+
+    virtual bool do_is_equal(const THRUST_STD_MR_NS::memory_resource & other) const noexcept override
+    {
+#  ifdef THRUST_HAS_DYNAMIC_CAST
+        auto mr_resource = dynamic_cast<memory_resource<> *>(&other);
+        return mr_resource && do_is_equal(*mr_resource);
+#  else
+        return this == &other;
+#  endif
+    }
+#endif
+};
+
+/*! Compares the memory resources for equality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator==(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return &lhs == &rhs || rhs.is_equal(rhs);
+}
+
+/*! Compares the memory resources for inequality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator!=(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+/*! Returns a global instance of \p MR, created as a function local static variable.
+ *
+ *  \tparam MR type of a memory resource to get an instance from. Must be \p DefaultConstructible.
+ *  \return a pointer to a global instance of \p MR.
+ */
+template<typename MR>
+__host__
+MR * get_global_resource()
+{
+    static MR resource;
+    return &resource;
+}
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/new.h b/miniCUDA124/include/thrust/mr/new.h
new file mode 100644
index 0000000000000000000000000000000000000000..94e2cc7586c5c800c63566cea215163bf4bd7518
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/new.h
@@ -0,0 +1,97 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Global operator new-based memory resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource that uses global operators new and delete to allocate and deallocate memory. Uses alignment-enabled
+ *      overloads when available, otherwise uses regular overloads and implements alignment requirements by itself.
+ */
+class new_delete_resource final : public memory_resource<>
+{
+public:
+    void * do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+#if defined(__cpp_aligned_new)
+        return ::operator new(bytes, std::align_val_t(alignment));
+#else
+        // allocate memory for bytes, plus potential alignment correction,
+        // plus store of the correction offset
+        void * p = ::operator new(bytes + alignment + sizeof(std::size_t));
+        std::size_t ptr_int = reinterpret_cast<std::size_t>(p);
+        // calculate the offset, i.e. how many bytes of correction was necessary
+        // to get an aligned pointer
+        std::size_t offset = (ptr_int % alignment) ? (alignment - ptr_int % alignment) : 0;
+        // calculate the return pointer
+        char * ptr = static_cast<char *>(p) + offset;
+        // store the offset right after the actually returned value
+        std::size_t * offset_store = reinterpret_cast<std::size_t *>(ptr + bytes);
+        *offset_store = offset;
+        return static_cast<void *>(ptr);
+#endif
+    }
+
+    void do_deallocate(void * p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+#if defined(__cpp_aligned_new)
+# if defined(__cpp_sized_deallocation)
+        ::operator delete(p, bytes, std::align_val_t(alignment));
+# else
+        (void)bytes;
+        ::operator delete(p, std::align_val_t(alignment));
+# endif
+#else
+        (void)alignment;
+        char * ptr = static_cast<char *>(p);
+        // calculate where the offset is stored
+        std::size_t * offset = reinterpret_cast<std::size_t *>(ptr + bytes);
+        // calculate the original pointer
+        p = static_cast<void *>(ptr - *offset);
+        ::operator delete(p);
+#endif
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/polymorphic_adaptor.h b/miniCUDA124/include/thrust/mr/polymorphic_adaptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..f44241e1cc58b0860f1e174cea57e8160cc2560f
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/polymorphic_adaptor.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright 2018-2019 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename Pointer = void *>
+class polymorphic_adaptor_resource final : public memory_resource<Pointer>
+{
+public:
+    polymorphic_adaptor_resource(memory_resource<Pointer> * t) : upstream_resource(t)
+    {
+    }
+
+    virtual Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return upstream_resource->allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        return upstream_resource->deallocate(p, bytes, alignment);
+    }
+
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource<Pointer> & other) const noexcept override
+    {
+        return upstream_resource->is_equal(other);
+    }
+
+private:
+    memory_resource<Pointer> * upstream_resource;
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/pool.h b/miniCUDA124/include/thrust/mr/pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..433e6409325aa46a03246646162679c8d611c6d2
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/pool.h
@@ -0,0 +1,547 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A caching and pooling memory resource adaptor which uses a single
+ *  upstream resource for memory allocation, and embeds bookkeeping information
+ *  in allocated blocks.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/algorithm_wrapper.h>
+
+#include <thrust/host_vector.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/pool_options.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource adaptor allowing for pooling and caching allocations from \p Upstream, using memory allocated
+ *      from it for both blocks then allocated to the user and for internal bookkeeping of the cached memory.
+ *
+ *  On a typical memory resource, calls to \p allocate and \p deallocate actually allocate and deallocate memory. Pooling
+ *      memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when
+ *      there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make
+ *      memory allocation faster and more efficient.
+ *
+ *  The non-disjoint version of the pool resource uses a single upstream memory resource. Every allocation is larger than
+ *      strictly necessary to fulfill the end-user's request, because it needs to account for the memory overhead of tracking
+ *      the memory blocks and chunks inside those same memory regions. Nevertheless, this version should be more memory-efficient
+ *      than the \p disjoint_unsynchronized_pool_resource, because it doesn't need to allocate additional blocks of memory
+ *      from a separate resource, which in turn would necessitate the bookkeeping overhead in the upstream resource.
+ *
+ *  This version requires that memory allocated from Upstream is accessible from device. It supports smart references,
+ *      meaning that the non-managed CUDA resource, returning a device-tagged pointer, will work, but will be much less
+ *      efficient than the disjoint version, which wouldn't need to touch device memory at all, and therefore wouldn't need
+ *      to transfer it back and forth between the host and the device whenever an allocation or a deallocation happens.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks
+ */
+template<typename Upstream>
+class unsynchronized_pool_resource final
+    : public memory_resource<typename Upstream::pointer>,
+        private validator<Upstream>
+{
+public:
+    /*! Get the default options for a pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        pool_options ret;
+
+        ret.min_blocks_per_chunk = 16;
+        ret.min_bytes_per_chunk = 1024;
+        ret.max_blocks_per_chunk = static_cast<std::size_t>(1) << 20;
+        ret.max_bytes_per_chunk = static_cast<std::size_t>(1) << 30;
+
+        ret.smallest_block_size = THRUST_MR_DEFAULT_ALIGNMENT;
+        ret.largest_block_size = static_cast<std::size_t>(1) << 20;
+
+        ret.alignment = THRUST_MR_DEFAULT_ALIGNMENT;
+
+        ret.cache_oversized = true;
+
+        ret.cached_size_cutoff_factor = 16;
+        ret.cached_alignment_cutoff_factor = 16;
+
+        return ret;
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param options pool options to use
+     */
+    unsynchronized_pool_resource(Upstream * upstream, pool_options options = get_default_options())
+        : m_upstream(upstream),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(upstream),
+        m_allocated(),
+        m_oversized(),
+        m_cached_oversized()
+    {
+        assert(m_options.validate());
+
+        pool p = { block_descriptor_ptr(), 0 };
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    // TODO: C++11: use delegating constructors
+
+    /*! Constructor. The upstream resource is obtained by calling \p get_global_resource<Upstream>.
+     *
+     *  \param options pool options to use
+     */
+    unsynchronized_pool_resource(pool_options options = get_default_options())
+        : m_upstream(get_global_resource<Upstream>()),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(get_global_resource<Upstream>()),
+        m_allocated(),
+        m_oversized(),
+        m_cached_oversized()
+    {
+        assert(m_options.validate());
+
+        pool p = { block_descriptor_ptr(), 0 };
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    /*! Destructor. Releases all held memory to upstream.
+     */
+    ~unsynchronized_pool_resource()
+    {
+        release();
+    }
+
+private:
+    typedef typename Upstream::pointer void_ptr;
+    typedef thrust::detail::pointer_traits<void_ptr> void_ptr_traits;
+    typedef typename void_ptr_traits::template rebind<char>::other char_ptr;
+
+    struct block_descriptor;
+    struct chunk_descriptor;
+    struct oversized_block_descriptor;
+
+    typedef typename void_ptr_traits::template rebind<block_descriptor>::other block_descriptor_ptr;
+    typedef typename void_ptr_traits::template rebind<chunk_descriptor>::other chunk_descriptor_ptr;
+    typedef typename void_ptr_traits::template rebind<oversized_block_descriptor>::other oversized_block_descriptor_ptr;
+    typedef thrust::detail::pointer_traits<oversized_block_descriptor_ptr> oversized_block_ptr_traits;
+
+    struct block_descriptor
+    {
+        block_descriptor_ptr next;
+    };
+
+    struct chunk_descriptor
+    {
+        std::size_t size;
+        chunk_descriptor_ptr next;
+    };
+
+    // this was originally a forward list, but I made it a doubly linked list
+    // because that way deallocation when not caching is faster and doesn't require
+    // traversal of a linked list (it's still a forward list for the cached list,
+    // because allocation from that list already traverses)
+    //
+    // TODO: investigate whether it's better to have this be a doubly-linked list
+    // with fast do_deallocate when !m_options.cache_oversized, or to have this be
+    // a forward list and require traversal in do_deallocate
+    //
+    // I assume that it is better this way, but the additional pointer could
+    // potentially hurt? these are supposed to be oversized and/or overaligned,
+    // so they are kinda memory intensive already
+    struct oversized_block_descriptor
+    {
+        std::size_t size;
+        std::size_t alignment;
+        oversized_block_descriptor_ptr prev;
+        oversized_block_descriptor_ptr next;
+        oversized_block_descriptor_ptr next_cached;
+        std::size_t current_size;
+    };
+
+    struct pool
+    {
+        block_descriptor_ptr free_list;
+        std::size_t previous_allocated_count;
+    };
+
+    typedef thrust::host_vector<
+        pool,
+        allocator<pool, Upstream>
+    > pool_vector;
+
+    Upstream * m_upstream;
+
+    pool_options m_options;
+    std::size_t m_smallest_block_log2;
+
+    pool_vector m_pools;
+    chunk_descriptor_ptr m_allocated;
+    oversized_block_descriptor_ptr m_oversized;
+    oversized_block_descriptor_ptr m_cached_oversized;
+
+public:
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        // reset the buckets
+        for (std::size_t i = 0; i < m_pools.size(); ++i)
+        {
+            thrust::raw_reference_cast(m_pools[i]).free_list = block_descriptor_ptr();
+            thrust::raw_reference_cast(m_pools[i]).previous_allocated_count = 0;
+        }
+
+        // deallocate memory allocated for the buckets
+        while (detail::pointer_traits<chunk_descriptor_ptr>::get(m_allocated))
+        {
+            chunk_descriptor_ptr alloc = m_allocated;
+            m_allocated = thrust::raw_reference_cast(*m_allocated).next;
+
+            void_ptr p = static_cast<void_ptr>(
+                static_cast<char_ptr>(
+                    static_cast<void_ptr>(alloc)
+                ) - thrust::raw_reference_cast(*alloc).size
+            );
+            m_upstream->do_deallocate(p, thrust::raw_reference_cast(*alloc).size + sizeof(chunk_descriptor), m_options.alignment);
+        }
+
+        // deallocate cached oversized/overaligned memory
+        while (oversized_block_ptr_traits::get(m_oversized))
+        {
+            oversized_block_descriptor_ptr alloc = m_oversized;
+            m_oversized = thrust::raw_reference_cast(*m_oversized).next;
+
+            oversized_block_descriptor desc =
+                thrust::raw_reference_cast(*alloc);
+
+            void_ptr p = static_cast<void_ptr>(
+                static_cast<char_ptr>(static_cast<void_ptr>(alloc)) -
+                desc.current_size);
+            m_upstream->do_deallocate(
+                p, desc.size + sizeof(oversized_block_descriptor),
+                desc.alignment);
+        }
+
+        m_cached_oversized = oversized_block_descriptor_ptr();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        bytes = (std::max)(bytes, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // an oversized and/or overaligned allocation requested; needs to be allocated separately
+        if (bytes > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            if (m_options.cache_oversized)
+            {
+                oversized_block_descriptor_ptr ptr = m_cached_oversized;
+                oversized_block_descriptor_ptr * previous = &m_cached_oversized;
+                while (oversized_block_ptr_traits::get(ptr))
+                {
+                    oversized_block_descriptor desc = *ptr;
+                    bool is_good = desc.size >= bytes && desc.alignment >= alignment;
+
+                    // if the size is bigger than the requested size by a factor
+                    // bigger than or equal to the specified cutoff for size,
+                    // allocate a new block
+                    if (is_good)
+                    {
+                        std::size_t size_factor = desc.size / bytes;
+                        if (size_factor >= m_options.cached_size_cutoff_factor)
+                        {
+                            is_good = false;
+                        }
+                    }
+
+                    // if the alignment is bigger than the requested one by a factor
+                    // bigger than or equal to the specified cutoff for alignment,
+                    // allocate a new block
+                    if (is_good)
+                    {
+                        std::size_t alignment_factor = desc.alignment / alignment;
+                        if (alignment_factor >= m_options.cached_alignment_cutoff_factor)
+                        {
+                            is_good = false;
+                        }
+                    }
+
+                    if (is_good)
+                    {
+                        if (previous != &m_cached_oversized)
+                        {
+                            *previous = desc.next_cached;
+                        }
+                        else
+                        {
+                            m_cached_oversized = desc.next_cached;
+                        }
+
+                        desc.next_cached = oversized_block_descriptor_ptr();
+
+                        auto ret =
+                            static_cast<char_ptr>(static_cast<void_ptr>(ptr)) -
+                            desc.size;
+
+                        if (bytes != desc.size) {
+                            desc.current_size = bytes;
+
+                            ptr = static_cast<oversized_block_descriptor_ptr>(
+                                static_cast<void_ptr>(ret + bytes));
+
+                            if (oversized_block_ptr_traits::get(desc.prev)) {
+                                thrust::raw_reference_cast(*desc.prev).next = ptr;
+                            } else {
+                                m_oversized = ptr;
+                            }
+
+                            if (oversized_block_ptr_traits::get(desc.next)) {
+                                thrust::raw_reference_cast(*desc.next).prev = ptr;
+                            }
+                        }
+
+                        *ptr = desc;
+
+                        return static_cast<void_ptr>(ret);
+                    }
+
+                    previous = &thrust::raw_reference_cast(*ptr).next_cached;
+                    ptr = *previous;
+                }
+            }
+
+            // no fitting cached block found; allocate a new one that's just up to the specs
+            void_ptr allocated = m_upstream->do_allocate(bytes + sizeof(oversized_block_descriptor), alignment);
+            oversized_block_descriptor_ptr block = static_cast<oversized_block_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(allocated) + bytes
+                )
+            );
+
+            oversized_block_descriptor desc;
+            desc.size = bytes;
+            desc.alignment = alignment;
+            desc.prev = oversized_block_descriptor_ptr();
+            desc.next = m_oversized;
+            desc.next_cached = oversized_block_descriptor_ptr();
+            desc.current_size = bytes;
+            *block = desc;
+            m_oversized = block;
+
+            if (oversized_block_ptr_traits::get(desc.next))
+            {
+                oversized_block_descriptor next = *desc.next;
+                next.prev = block;
+                *desc.next = next;
+            }
+
+            return allocated;
+        }
+
+        // the request is NOT for oversized and/or overaligned memory
+        // allocate a block from an appropriate bucket
+        std::size_t bytes_log2 = thrust::detail::log2_ri(bytes);
+        std::size_t bucket_idx = bytes_log2 - m_smallest_block_log2;
+        pool & bucket = thrust::raw_reference_cast(m_pools[bucket_idx]);
+
+        bytes = static_cast<std::size_t>(1) << bytes_log2;
+
+        // if the free list of the bucket has no elements, allocate a new chunk
+        // and split it into blocks pushed to the free list
+        if (!detail::pointer_traits<block_descriptor_ptr>::get(bucket.free_list))
+        {
+            std::size_t n = bucket.previous_allocated_count;
+            if (n == 0)
+            {
+                n = m_options.min_blocks_per_chunk;
+                if (n < (m_options.min_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.min_bytes_per_chunk >> bytes_log2;
+                }
+            }
+            else
+            {
+                n = n * 3 / 2;
+                if (n > (m_options.max_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.max_bytes_per_chunk >> bytes_log2;
+                }
+                if (n > m_options.max_blocks_per_chunk)
+                {
+                    n = m_options.max_blocks_per_chunk;
+                }
+            }
+
+            std::size_t descriptor_size = (std::max)(sizeof(block_descriptor), m_options.alignment);
+            std::size_t block_size = bytes + descriptor_size;
+            block_size += m_options.alignment - block_size % m_options.alignment;
+            std::size_t chunk_size = block_size * n;
+
+            void_ptr allocated = m_upstream->do_allocate(chunk_size + sizeof(chunk_descriptor), m_options.alignment);
+            chunk_descriptor_ptr chunk = static_cast<chunk_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(allocated) + chunk_size
+                )
+            );
+
+            chunk_descriptor chunk_desc;
+            chunk_desc.size = chunk_size;
+            chunk_desc.next = m_allocated;
+            *chunk = chunk_desc;
+            m_allocated = chunk;
+
+            for (std::size_t i = 0; i < n; ++i)
+            {
+                block_descriptor_ptr block = static_cast<block_descriptor_ptr>(
+                    static_cast<void_ptr>(
+                        static_cast<char_ptr>(allocated) + block_size * i + bytes
+                    )
+                );
+
+                block_descriptor block_desc;
+                block_desc.next = bucket.free_list;
+                *block = block_desc;
+                bucket.free_list = block;
+            }
+        }
+
+        // allocate a block from the front of the bucket's free list
+        block_descriptor_ptr block = bucket.free_list;
+        bucket.free_list = thrust::raw_reference_cast(*block).next;
+        return static_cast<void_ptr>(
+            static_cast<char_ptr>(
+                static_cast<void_ptr>(block)
+            ) - bytes
+        );
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        n = (std::max)(n, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // verify that the pointer is at least as aligned as claimed
+        assert(reinterpret_cast<detail::intmax_t>(void_ptr_traits::get(p)) % alignment == 0);
+
+        // the deallocated block is oversized and/or overaligned
+        if (n > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            oversized_block_descriptor_ptr block = static_cast<oversized_block_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(p) + n
+                )
+            );
+
+            oversized_block_descriptor desc = *block;
+            assert(desc.current_size == n);
+            assert(desc.alignment == alignment);
+
+            if (m_options.cache_oversized)
+            {
+                desc.next_cached = m_cached_oversized;
+
+                if (desc.size != n) {
+                    desc.current_size = desc.size;
+                    block = static_cast<oversized_block_descriptor_ptr>(
+                        static_cast<void_ptr>(static_cast<char_ptr>(p) +
+                                              desc.size));
+                    if (oversized_block_ptr_traits::get(desc.prev)) {
+                        thrust::raw_reference_cast(*desc.prev).next = block;
+                    } else {
+                        m_oversized = block;
+                    }
+
+                    if (oversized_block_ptr_traits::get(desc.next)) {
+                        thrust::raw_reference_cast(*desc.next).prev = block;
+                    }
+                }
+
+                m_cached_oversized = block;
+                *block = desc;
+
+                return;
+            }
+
+            if (oversized_block_ptr_traits::get(
+                    desc.prev)) {
+                thrust::raw_reference_cast(*desc.prev).next = desc.next;
+            } else {
+                m_oversized = desc.next;
+            }
+
+            if (oversized_block_ptr_traits::get(desc.next)) {
+                thrust::raw_reference_cast(*desc.next).prev = desc.prev;
+            }
+
+            m_upstream->do_deallocate(p, desc.size + sizeof(oversized_block_descriptor), desc.alignment);
+
+            return;
+        }
+
+        // push the block to the front of the appropriate bucket's free list
+        std::size_t n_log2 = thrust::detail::log2_ri(n);
+        std::size_t bucket_idx = n_log2 - m_smallest_block_log2;
+        pool & bucket = thrust::raw_reference_cast(m_pools[bucket_idx]);
+
+        n = static_cast<std::size_t>(1) << n_log2;
+
+        block_descriptor_ptr block = static_cast<block_descriptor_ptr>(
+            static_cast<void_ptr>(
+                static_cast<char_ptr>(p) + n
+            )
+        );
+
+        block_descriptor desc;
+        desc.next = bucket.free_list;
+        *block = desc;
+        bucket.free_list = block;
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/pool_options.h b/miniCUDA124/include/thrust/mr/pool_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e5d3b3abb9878c7cfddd0c94c66feb17e132169
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/pool_options.h
@@ -0,0 +1,136 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A type used by the pooling resource adaptors to fine-tune their
+ *  behavior.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <cstddef>
+
+#include <thrust/detail/integer_math.h>
+#include <thrust/detail/config/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A type used for configuring pooling resource adaptors, to fine-tune their behavior and parameters.
+ */
+struct pool_options
+{
+    /*! The minimal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
+     *      chunk allocated from upstream.
+     */
+    std::size_t min_blocks_per_chunk;
+    /*! The minimal number of bytes in a single chunk allocated from upstream.
+     */
+    std::size_t min_bytes_per_chunk;
+    /*! The maximal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
+     *      chunk allocated from upstream.
+     */
+    std::size_t max_blocks_per_chunk;
+    /*! The maximal number of bytes in a single chunk allocated from upstream.
+     */
+    std::size_t max_bytes_per_chunk;
+
+    /*! The size of blocks in the smallest pool covered by the pool resource. All allocation requests below this size will
+     *      be rounded up to this size.
+     */
+    std::size_t smallest_block_size;
+    /*! The size of blocks in the largest pool covered by the pool resource. All allocation requests above this size will
+     *      be considered oversized, allocated directly from upstream (and not from a pool), and cached only of \p cache_oversized
+     *      is true.
+     */
+    std::size_t largest_block_size;
+
+    /*! The alignment of all blocks in internal pools of the pool resource. All allocation requests above this alignment
+     *      will be considered oversized, allocated directly from upstream (and not from a pool), and cached only of
+     *      \p cache_oversized is true.
+     */
+    std::size_t alignment;
+
+    /*! Decides whether oversized and overaligned blocks are cached for later use, or immediately return it to the upstream
+     *      resource.
+     */
+    bool cache_oversized;
+
+    /*! The size factor at which a cached allocation is considered too ridiculously oversized to use to fulfill an allocation
+     *      request. For instance: the user requests an allocation of size 1024 bytes. A block of size 32 * 1024 bytes is
+     *      cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too big for that allocation
+     *      request.
+     */
+    std::size_t cached_size_cutoff_factor;
+    /*! The alignment factor at which a cached allocation is considered too ridiculously overaligned to use to fulfill an
+     *      allocation request. For instance: the user requests an allocation aligned to 32 bytes. A block aligned to 1024 bytes
+     *      is cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too overaligned for that
+     *      allocation request.
+     */
+    std::size_t cached_alignment_cutoff_factor;
+
+    /*! Checks if the options are self-consistent.
+     *
+     *  /returns true if the options are self-consitent, false otherwise.
+     */
+    bool validate() const
+    {
+        if (!detail::is_power_of_2(smallest_block_size)) return false;
+        if (!detail::is_power_of_2(largest_block_size)) return false;
+        if (!detail::is_power_of_2(alignment)) return false;
+
+        if (max_bytes_per_chunk == 0 || max_blocks_per_chunk == 0) return false;
+        if (smallest_block_size == 0 || largest_block_size == 0) return false;
+
+        if (min_blocks_per_chunk > max_blocks_per_chunk) return false;
+        if (min_bytes_per_chunk > max_bytes_per_chunk) return false;
+
+        if (smallest_block_size > largest_block_size) return false;
+
+        if (min_blocks_per_chunk * smallest_block_size > max_bytes_per_chunk) return false;
+        if (min_blocks_per_chunk * largest_block_size > max_bytes_per_chunk) return false;
+
+        if (max_blocks_per_chunk * largest_block_size < min_bytes_per_chunk) return false;
+        if (max_blocks_per_chunk * smallest_block_size < min_bytes_per_chunk) return false;
+
+        if (alignment > smallest_block_size) return false;
+
+        return true;
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/mr/sync_pool.h b/miniCUDA124/include/thrust/mr/sync_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..80e2e5a8d9910a3d08401a603a26ad169e7d549a
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/sync_pool.h
@@ -0,0 +1,122 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A mutex-synchronized version of \p unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <mutex>
+
+#include <thrust/mr/pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A mutex-synchronized version of \p unsynchronized_pool_resource. Uses \p std::mutex, and therefore requires C++11.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory
+ */
+template<typename Upstream>
+struct synchronized_pool_resource : public memory_resource<typename Upstream::pointer>
+{
+    typedef unsynchronized_pool_resource<Upstream> unsync_pool;
+    typedef std::lock_guard<std::mutex> lock_t;
+
+    typedef typename Upstream::pointer void_ptr;
+
+public:
+    /*! Get the default options for a pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        return unsync_pool::get_default_options();
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param options pool options to use
+     */
+    synchronized_pool_resource(Upstream * upstream, pool_options options = get_default_options())
+        : upstream_pool(upstream, options)
+    {
+    }
+
+    /*! Constructor. The upstream resource is obtained by calling \p get_global_resource<Upstream>.
+     *
+     *  \param options pool options to use
+     */
+    synchronized_pool_resource(pool_options options = get_default_options())
+        : upstream_pool(get_global_resource<Upstream>(), options)
+    {
+    }
+
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        lock_t lock(mtx);
+        upstream_pool.release();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        return upstream_pool.do_allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        upstream_pool.do_deallocate(p, n, alignment);
+    }
+
+private:
+    std::mutex mtx;
+    unsync_pool upstream_pool;
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/mr/tls_pool.h b/miniCUDA124/include/thrust/mr/tls_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e3dcd86f48c885f8bac493b589e85dc684bf287
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/tls_pool.h
@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file tls_pool.h
+ *  \brief A function wrapping a thread local instance of a \p unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/mr/pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_management Memory Management
+ *  \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_resources
+ *  \{
+ */
+
+/*! Potentially constructs, if not yet created, and then returns the address of a thread-local \p unsynchronized_pool_resource,
+ *
+ *  \tparam Upstream the template argument to the pool template
+ *  \param upstream the argument to the constructor, if invoked
+ */
+template<typename Upstream, typename Bookkeeper>
+__host__
+thrust::mr::unsynchronized_pool_resource<Upstream> & tls_pool(Upstream * upstream = NULL)
+{
+    static thread_local auto adaptor = [&]{
+        assert(upstream);
+        return thrust::mr::unsynchronized_pool_resource<Upstream>(upstream);
+    }();
+
+    return adaptor;
+}
+
+/*! \}
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/mr/universal_memory_resource.h b/miniCUDA124/include/thrust/mr/universal_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..814be582c65c33c73d3d5a6d0da7c9c9e9cd4a8a
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/universal_memory_resource.h
@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/mr/device_memory_resource.h>
+
diff --git a/miniCUDA124/include/thrust/mr/validator.h b/miniCUDA124/include/thrust/mr/validator.h
new file mode 100644
index 0000000000000000000000000000000000000000..2fed90deb42a1a2be0182c57d8c6d3c292b0441b
--- /dev/null
+++ b/miniCUDA124/include/thrust/mr/validator.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename MR>
+struct validator
+{
+#if THRUST_CPP_DIALECT >= 2011
+  static_assert(
+    std::is_base_of<memory_resource<typename MR::pointer>, MR>::value,
+    "a type used as a memory resource must derive from memory_resource"
+  );
+#endif
+};
+
+template<typename T, typename U>
+struct validator2 : private validator<T>, private validator<U>
+{
+};
+
+template<typename T>
+struct validator2<T, T> : private validator<T>
+{
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/random/discard_block_engine.h b/miniCUDA124/include/thrust/random/discard_block_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..da65f266b916a1618fb7d0cae29a4da5c9d981e5
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/discard_block_engine.h
@@ -0,0 +1,258 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file discard_block_engine.h
+ *  \brief A random number engine which adapts a base engine and produces
+ *         numbers by discarding all but a contiguous blocks of its values.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <iostream>
+#include <thrust/detail/cstdint.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_adaptors Random Number Engine Adaptor Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class discard_block_engine
+ *  \brief A \p discard_block_engine adapts an existing base random number engine and produces
+ *         random values by discarding some of the values returned by its base engine.
+ *         Each cycle of the compound engine begins by returning \c r values successively produced
+ *         by the base engine and ends by discarding <tt>p-r</tt> such values. The engine's state
+ *         is the state of its base engine followed by the number of calls to <tt>operator()</tt>
+ *         that have occurred since the beginning of the current cycle.
+ *
+ *  \tparam Engine The type of the base random number engine to adapt.
+ *  \tparam p The discard cycle length.
+ *  \tparam r The number of values to return of the base engine. Because <tt>p-r</tt> will be
+ *            discarded, <tt>r <= p</tt>.
+ *
+ *  The following code snippet shows an example of using a \p discard_block_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/discard_block_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create a discard_block_engine from minstd_rand, with a cycle length of 13
+ *    // keep every first 10 values, and discard the next 3
+ *    thrust::discard_block_engine<thrust::minstd_rand, 13, 10> rng;
+ *
+ *    // print a random number to standard output
+ *    std::cout << rng() << std::endl;
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename Engine, size_t p, size_t r>
+  class discard_block_engine
+{
+  public:
+    // types
+
+    /*! \typedef base_type
+     *  \brief The type of the adapted base random number engine.
+     */
+    typedef Engine base_type;
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_congruential_engine.
+     */
+    typedef typename base_type::result_type result_type;
+
+    // engine characteristics
+
+    /*! The length of the production cycle.
+     */
+    static const size_t block_size = p;
+
+    /*! The number of used numbers per production cycle.
+     */
+    static const size_t used_block = r;
+
+    /*! The smallest value this \p discard_block_engine may potentially produce.
+     */
+    static const result_type min = base_type::min;
+
+    /*! The largest value this \p discard_block_engine may potentially produce.
+     */
+    static const result_type max = base_type::max;
+
+    // constructors and seeding functions
+
+    /*! This constructor constructs a new \p discard_block_engine and constructs
+     *  its \p base_type engine using its null constructor.
+     */
+    __host__ __device__
+    discard_block_engine();
+
+    /*! This constructor constructs a new \p discard_block_engine using
+     *  a given \p base_type engine to initialize its adapted base engine.
+     *
+     *  \param urng A \p base_type to use to initialize this \p discard_block_engine's
+     *         adapted base engine.
+     */
+    __host__ __device__
+    explicit discard_block_engine(const base_type &urng);
+
+    /*! This constructor initializes a new \p discard_block_engine with a given seed.
+     *
+     *  \param s The seed used to intialize this \p discard_block_engine's adapted base engine.
+     */
+    __host__ __device__
+    explicit discard_block_engine(result_type s);
+
+    /*! This method initializes the state of this \p discard_block_engine's adapted base engine
+     *  by using its \p default_seed value.
+     */
+    __host__ __device__
+    void seed(void);
+
+    /*! This method initializes the state of this \p discard_block_engine's adapted base engine
+     *  by using the given seed.
+     *
+     *  \param s The seed with which to intialize this \p discard_block_engine's adapted base engine.
+     */
+    __host__ __device__
+    void seed(result_type s);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p discard_block_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p discard_block_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    // property functions
+
+    /*! This member function returns a const reference to this \p discard_block_engine's
+     *  adapted base engine.
+     *
+     *  \return A const reference to the base engine this \p discard_block_engine adapts.
+     */
+    __host__ __device__
+    const base_type &base(void) const;
+
+    /*! \cond
+     */
+  private:
+    base_type m_e;
+    unsigned int m_n;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const discard_block_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end discard_block_engine
+
+
+/*! This function checks two \p discard_block_engines for equality.
+ *  \param lhs The first \p discard_block_engine to test.
+ *  \param rhs The second \p discard_block_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator==(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs);
+
+
+/*! This function checks two \p discard_block_engines for inequality.
+ *  \param lhs The first \p discard_block_engine to test.
+ *  \param rhs The second \p discard_block_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator!=(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs);
+
+
+/*! This function streams a discard_block_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p discard_block_engine to stream out.
+ *  \return \p os
+ */
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const discard_block_engine<Engine,p,r> &e);
+
+
+/*! This function streams a discard_block_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p discard_block_engine to stream in.
+ *  \return \p is
+ */
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           discard_block_engine<Engine,p,r> &e);
+
+/*! \} // end random_number_engine_adaptors
+ */
+
+} // end random
+
+// import names into thrust::
+using random::discard_block_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/discard_block_engine.inl>
+
diff --git a/miniCUDA124/include/thrust/random/linear_congruential_engine.h b/miniCUDA124/include/thrust/random/linear_congruential_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cdefb1a6e8e14cb32685f8aad49c5fbc6469439
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/linear_congruential_engine.h
@@ -0,0 +1,302 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file linear_congruential_engine.h
+ *  \brief A linear congruential pseudorandom number engine.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <iostream>
+#include <thrust/detail/cstdint.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <thrust/random/detail/linear_congruential_engine_discard.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_templates Random Number Engine Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class linear_congruential_engine
+ *  \brief A \p linear_congruential_engine random number engine produces unsigned integer
+ *         random numbers using a linear congruential random number generation algorithm.
+ *
+ *         The generation algorithm has the form <tt>x_i = (a * x_{i-1} + c) mod m</tt>.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam a The multiplier used in the generation algorithm.
+ *  \tparam c The increment used in the generation algorithm.
+ *  \tparam m The modulus used in the generation algorithm.
+ *
+ *  \note Inexperienced users should not use this class template directly.  Instead, use
+ *  \p minstd_rand or \p minstd_rand0.
+ *
+ *  The following code snippet shows examples of use of a \p linear_congruential_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object, which is an instance of linear_congruential_engine
+ *    thrust::minstd_rand rng1;
+ *
+ *    // output some random values to cout
+ *    std::cout << rng1() << std::endl;
+ *
+ *    // a random value is printed
+ *
+ *    // create a new minstd_rand from a seed
+ *    thrust::minstd_rand rng2(13);
+ *
+ *    // discard some random values
+ *    rng2.discard(13);
+ *
+ *    // stream the object to an iostream
+ *    std::cout << rng2 << std::endl;
+ *
+ *    // rng2's current state is printed
+ *
+ *    // print the minimum and maximum values that minstd_rand can produce
+ *    std::cout << thrust::minstd_rand::min << std::endl;
+ *    std::cout << thrust::minstd_rand::max << std::endl;
+ *
+ *    // the range of minstd_rand is printed
+ *
+ *    // save the state of rng2 to a different object
+ *    thrust::minstd_rand rng3 = rng2;
+ *
+ *    // compare rng2 and rng3
+ *    std::cout << (rng2 == rng3) << std::endl;
+ *
+ *    // 1 is printed
+ *
+ *    // re-seed rng2 with a different seed
+ *    rng2.seed(7);
+ *
+ *    // compare rng2 and rng3
+ *    std::cout << (rng2 == rng3) << std::endl;
+ *
+ *    // 0 is printed
+ *
+ *    return 0;
+ *  }
+ *
+ *  \endcode
+ *
+ *  \see thrust::random::minstd_rand
+ *  \see thrust::random::minstd_rand0
+ */
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  class linear_congruential_engine
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_congruential_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The multiplier used in the generation algorithm.
+     */
+    static const result_type multiplier = a;
+
+    /*! The increment used in the generation algorithm.
+     */
+    static const result_type increment = c;
+
+    /*! The modulus used in the generation algorithm.
+     */
+    static const result_type modulus = m;
+
+    /*! The smallest value this \p linear_congruential_engine may potentially produce.
+     */
+    static const result_type min = c == 0u ? 1u : 0u;
+
+    /*! The largest value this \p linear_congruential_engine may potentially produce.
+     */
+    static const result_type max = m - 1u;
+
+    /*! The default seed of this \p linear_congruential_engine.
+     */
+    static const result_type default_seed = 1u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p linear_congruential_engine.
+     *
+     *  \param s The seed used to intialize this \p linear_congruential_engine's state.
+     */
+    __host__ __device__
+    explicit linear_congruential_engine(result_type s = default_seed);
+
+    /*! This method initializes this \p linear_congruential_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param s The seed used to initializes this \p linear_congruential_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type s = default_seed);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p linear_congruential_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p linear_congruential_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_x;
+
+    static void transition(result_type &state);
+
+    friend struct thrust::random::detail::random_core_access;
+
+    friend struct thrust::random::detail::linear_congruential_engine_discard;
+
+    __host__ __device__
+    bool equal(const linear_congruential_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end linear_congruential_engine
+
+
+/*! This function checks two \p linear_congruential_engines for equality.
+ *  \param lhs The first \p linear_congruential_engine to test.
+ *  \param rhs The second \p linear_congruential_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator==(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs);
+
+
+/*! This function checks two \p linear_congruential_engines for inequality.
+ *  \param lhs The first \p linear_congruential_engine to test.
+ *  \param rhs The second \p linear_congruential_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator!=(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs);
+
+
+/*! This function streams a linear_congruential_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p linear_congruential_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_congruential_engine<UIntType_,a_,c_,m_> &e);
+
+
+/*! This function streams a linear_congruential_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p linear_congruential_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_congruential_engine<UIntType_,a_,c_,m_> &e);
+
+
+/*! \} // random_number_engine_templates
+ */
+
+
+/*! \addtogroup predefined_random
+ *  \{
+ */
+
+// XXX the type N2111 used here was uint_fast32_t
+
+/*! \typedef minstd_rand0
+ *  \brief A random number engine with predefined parameters which implements a version of
+ *         the Minimal Standard random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p minstd_rand0
+ *        shall produce the value \c 1043618065 .
+ */
+typedef linear_congruential_engine<thrust::detail::uint32_t, 16807, 0, 2147483647> minstd_rand0;
+
+
+/*! \typedef minstd_rand
+ *  \brief A random number engine with predefined parameters which implements a version of
+ *         the Minimal Standard random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p minstd_rand
+ *        shall produce the value \c 399268537 .
+ */
+typedef linear_congruential_engine<thrust::detail::uint32_t, 48271, 0, 2147483647> minstd_rand;
+
+/*! \} // predefined_random
+ */
+
+} // end random
+
+// import names into thrust::
+using random::linear_congruential_engine;
+using random::minstd_rand;
+using random::minstd_rand0;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/linear_congruential_engine.inl>
+
diff --git a/miniCUDA124/include/thrust/random/linear_feedback_shift_engine.h b/miniCUDA124/include/thrust/random/linear_feedback_shift_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..466afe9c49451e9c32bfafefde447247c52084a8
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/linear_feedback_shift_engine.h
@@ -0,0 +1,237 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file linear_feedback_shift_engine.h
+ *  \brief A linear feedback shift pseudorandom number generator.
+ */
+
+/*
+ * Copyright Jens Maurer 2002
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/random/detail/linear_feedback_shift_engine_wordmask.h>
+#include <iostream>
+#include <cstddef> // for size_t
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_templates
+ *  \{
+ */
+
+/*! \class linear_feedback_shift_engine
+ *  \brief A \p linear_feedback_shift_engine random number engine produces
+ *         unsigned integer random values using a linear feedback shift random number
+ *         generation algorithm.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam w The word size of the produced values (<tt>w <= sizeof(UIntType)</tt>).
+ *  \tparam k The k parameter of Tausworthe's 1965 algorithm.
+ *  \tparam q The q exponent of Tausworthe's 1965 algorithm.
+ *  \tparam s The step size of Tausworthe's 1965 algorithm.
+ *
+ *  \note linear_feedback_shift_engine is based on the Boost Template Library's linear_feedback_shift.
+ */
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  class linear_feedback_shift_engine
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_feedback_shift_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The word size of the produced values.
+     */
+    static const size_t word_size = w;
+
+    /*! A constant used in the generation algorithm.
+     */
+    static const size_t exponent1 = k;
+
+    /*! A constant used in the generation algorithm.
+     */
+    static const size_t exponent2 = q;
+
+    /*! The step size used in the generation algorithm.
+     */
+    static const size_t step_size = s;
+
+    /*! \cond
+     */
+  private:
+    static const result_type wordmask =
+      detail::linear_feedback_shift_engine_wordmask<
+        result_type,
+        w
+      >::value;
+    /*! \endcond
+     */
+
+  public:
+
+    /*! The smallest value this \p linear_feedback_shift_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p linear_feedback_shift_engine may potentially produce.
+     */
+    static const result_type max = wordmask;
+
+    /*! The default seed of this \p linear_feedback_shift_engine.
+     */
+    static const result_type default_seed = 341u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p linear_feedback_shift_engine.
+     *
+     *  \param value The seed used to intialize this \p linear_feedback_shift_engine's state.
+     */
+    __host__ __device__
+    explicit linear_feedback_shift_engine(result_type value = default_seed);
+
+    /*! This method initializes this \p linear_feedback_shift_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param value The seed used to initializes this \p linear_feedback_shift_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type value = default_seed);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p linear_feedback_shift_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p linear_feedback_shift_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_value;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const linear_feedback_shift_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end linear_feedback_shift_engine
+
+
+/*! This function checks two \p linear_feedback_shift_engines for equality.
+ *  \param lhs The first \p linear_feedback_shift_engine to test.
+ *  \param rhs The second \p linear_feedback_shift_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
+__host__ __device__
+bool operator==(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
+                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
+
+
+/*! This function checks two \p linear_feedback_shift_engines for inequality.
+ *  \param lhs The first \p linear_feedback_shift_engine to test.
+ *  \param rhs The second \p linear_feedback_shift_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
+__host__ __device__
+bool operator!=(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
+                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
+
+
+/*! This function streams a linear_feedback_shift_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p linear_feedback_shift_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
+
+
+/*! This function streams a linear_feedback_shift_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p linear_feedback_shift_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
+
+
+/*! \} // end random_number_engine_templates
+ */
+
+
+} // end random
+
+// import names into thrust::
+using random::linear_feedback_shift_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/linear_feedback_shift_engine.inl>
+
diff --git a/miniCUDA124/include/thrust/random/normal_distribution.h b/miniCUDA124/include/thrust/random/normal_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5b6ea53d4c8b91f5d531ce93f0b3f80dcf9ce88
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/normal_distribution.h
@@ -0,0 +1,282 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file normal_distribution.h
+ *  \brief A normal (Gaussian) distribution of real-valued numbers.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/pair.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <thrust/random/detail/normal_distribution_base.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_distributions
+ *  \{
+ */
+
+/*! \class normal_distribution
+ *  \brief A \p normal_distribution random number distribution produces floating point
+ *         Normally distributed random numbers.
+ *
+ *  \tparam RealType The type of floating point number to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p normal_distribution with a
+ *  random number engine to produce random values drawn from the Normal distribution with a given
+ *  mean and variance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/normal_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a normal_distribution to produce floats from the Normal distribution
+ *    // with mean 2.0 and standard deviation 3.5
+ *    thrust::random::normal_distribution<float> dist(2.0f, 3.5f);
+ *
+ *    // write a random number to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the mean of the distribution, just in case we forgot
+ *    std::cout << dist.mean() << std::endl;
+ *
+ *    // 2.0 is printed
+ *
+ *    // and the standard deviation
+ *    std::cout << dist.stddev() << std::endl;
+ *
+ *    // 3.5 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename RealType = double>
+  class normal_distribution
+    : public detail::normal_distribution_base<RealType>::type
+{
+  private:
+    typedef typename detail::normal_distribution_base<RealType>::type super_t;
+
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the floating point number produced by this \p normal_distribution.
+     */
+    typedef RealType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p normal_distribution's parameters.
+     */
+    typedef thrust::pair<RealType,RealType> param_type;
+
+    // constructors and reset functions
+
+    /*! This constructor creates a new \p normal_distribution from two values defining the
+     *  half-open interval of the distribution.
+     *
+     *  \param mean The mean (expected value) of the distribution. Defaults to \c 0.0.
+     *  \param stddev The standard deviation of the distribution. Defaults to \c 1.0.
+     */
+    __host__ __device__
+    explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
+
+    /*! This constructor creates a new \p normal_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of the distribution.
+     */
+    __host__ __device__
+    explicit normal_distribution(const param_type &parm);
+
+    /*! Calling this member function guarantees that subsequent uses of this
+     *  \p normal_distribution do not depend on values produced by any random
+     *  number generator prior to invoking this function.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new Normal random integer drawn from this \p normal_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new Normal random integer as if by creating a new \p normal_distribution
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p normal_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+
+    /*! This method returns the value of the parameter with which this \p normal_distribution
+     *  was constructed.
+     *
+     *  \return The mean (expected value) of this \p normal_distribution's output.
+     */
+    __host__ __device__
+    result_type mean(void) const;
+
+    /*! This method returns the value of the parameter with which this \p normal_distribution
+     *  was constructed.
+     *
+     *  \return The standard deviation of this \p uniform_real_distribution's output.
+     */
+    __host__ __device__
+    result_type stddev(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p normal_distribution was constructed.
+     *
+     *  \return A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of this \p normal_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p normal_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new parameters (i.e., the mean and variance) of this \p normal_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest floating point number this \p normal_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p normal_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the smallest number larger than largest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p normal_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const normal_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end normal_distribution
+
+
+/*! This function checks two \p normal_distributions for equality.
+ *  \param lhs The first \p normal_distribution to test.
+ *  \param rhs The second \p normal_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator==(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs);
+
+
+/*! This function checks two \p normal_distributions for inequality.
+ *  \param lhs The first \p normal_distribution to test.
+ *  \param rhs The second \p normal_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator!=(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs);
+
+
+/*! This function streams a normal_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p normal_distribution to stream out.
+ *  \return \p os
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const normal_distribution<RealType> &d);
+
+
+/*! This function streams a normal_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p normal_distribution to stream in.
+ *  \return \p is
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           normal_distribution<RealType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::normal_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/normal_distribution.inl>
+
diff --git a/miniCUDA124/include/thrust/random/subtract_with_carry_engine.h b/miniCUDA124/include/thrust/random/subtract_with_carry_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0130016280b75f9ac0f12164ee4f4492975c66b
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/subtract_with_carry_engine.h
@@ -0,0 +1,263 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file subtract_with_carry_engine.h
+ *  \brief A subtract-with-carry pseudorandom number generator
+ *         based on Marsaglia & Zaman.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/random/detail/random_core_access.h>
+
+#include <thrust/detail/cstdint.h>
+#include <cstddef> // for size_t
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_engine_templates
+ *  \{
+ */
+
+/*! \class subtract_with_carry_engine
+ *  \brief A \p subtract_with_carry_engine random number engine produces unsigned
+ *         integer random numbers using the subtract with carry algorithm of Marsaglia & Zaman.
+ *
+ *         The generation algorithm is performed as follows:
+ *         -# Let <tt>Y = X_{i-s}- X_{i-r} - c</tt>.
+ *         -# Set <tt>X_i</tt> to <tt>y = T mod m</tt>. Set \c c to \c 1 if <tt>Y < 0</tt>, otherwise set \c c to \c 0.
+ *
+ *         This algorithm corresponds to a modular linear function of the form
+ *
+ *         <tt>TA(x_i) = (a * x_i) mod b</tt>, where \c b is of the form <tt>m^r - m^s + 1</tt> and
+ *         <tt>a = b - (b-1)/m</tt>.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam w The word size of the produced values (<tt> w <= sizeof(UIntType)</tt>).
+ *  \tparam s The short lag of the generation algorithm.
+ *  \tparam r The long lag of the generation algorithm.
+ *
+ *  \note Inexperienced users should not use this class template directly.  Instead, use
+ *  \p ranlux24_base or \p ranlux48_base, which are instances of \p subtract_with_carry_engine.
+ *
+ *  \see thrust::random::ranlux24_base
+ *  \see thrust::random::ranlux48_base
+ */
+template<typename UIntType, size_t w, size_t s, size_t r>
+  class subtract_with_carry_engine
+{
+    /*! \cond
+     */
+  private:
+    static const UIntType modulus = UIntType(1) << w;
+    /*! \endcond
+     */
+
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p subtract_with_carry_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The word size of the produced values.
+     */
+    static const size_t word_size = w;
+
+    /*! The size of the short lag used in the generation algorithm.
+     */
+    static const size_t short_lag = s;
+
+    /*! The size of the long lag used in the generation algorithm.
+     */
+    static const size_t long_lag = r;
+
+    /*! The smallest value this \p subtract_with_carry_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p subtract_with_carry_engine may potentially produce.
+     */
+    static const result_type max = modulus - 1;
+
+    /*! The default seed of this \p subtract_with_carry_engine.
+     */
+    static const result_type default_seed = 19780503u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p subtract_with_carry_engine.
+     *
+     *  \param value The seed used to intialize this \p subtract_with_carry_engine's state.
+     */
+    __host__ __device__
+    explicit subtract_with_carry_engine(result_type value = default_seed);
+
+    /*! This method initializes this \p subtract_with_carry_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param value The seed used to initializes this \p subtract_with_carry_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type value = default_seed);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p subtract_with_carry_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p subtract_with_carry_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_x[long_lag];
+    unsigned int m_k;
+    int m_carry;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const subtract_with_carry_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end subtract_with_carry_engine
+
+
+/*! This function checks two \p subtract_with_carry_engines for equality.
+ *  \param lhs The first \p subtract_with_carry_engine to test.
+ *  \param rhs The second \p subtract_with_carry_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_>
+__host__ __device__
+bool operator==(const subtract_with_carry_engine<UIntType_,w_,s_,r_> &lhs,
+                const subtract_with_carry_engine<UIntType_,w_,s_,r_> &rhs);
+
+
+/*! This function checks two \p subtract_with_carry_engines for inequality.
+ *  \param lhs The first \p subtract_with_carry_engine to test.
+ *  \param rhs The second \p subtract_with_carry_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_>
+__host__ __device__
+bool operator!=(const subtract_with_carry_engine<UIntType_,w_,s_,r_>&lhs,
+                const subtract_with_carry_engine<UIntType_,w_,s_,r_>&rhs);
+
+
+/*! This function streams a subtract_with_carry_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p subtract_with_carry_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const subtract_with_carry_engine<UIntType_,w_,s_,r_> &e);
+
+
+/*! This function streams a subtract_with_carry_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p subtract_with_carry_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           subtract_with_carry_engine<UIntType_,w_,s_,r_> &e);
+
+
+/*! \} // end random_number_engine_templates
+ */
+
+
+/*! \addtogroup predefined_random
+ *  \{
+ */
+
+// XXX N2111 uses uint_fast32_t here
+
+/*! \typedef ranlux24_base
+ *  \brief A random number engine with predefined parameters which implements the
+ *         base engine of the \p ranlux24 random number engine.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux24_base
+ *        shall produce the value \c 7937952 .
+ */
+typedef subtract_with_carry_engine<thrust::detail::uint32_t, 24, 10, 24> ranlux24_base;
+
+
+// XXX N2111 uses uint_fast64_t here
+
+/*! \typedef ranlux48_base
+ *  \brief A random number engine with predefined parameters which implements the
+ *         base engine of the \p ranlux48 random number engine.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux48_base
+ *        shall produce the value \c 192113843633948 .
+ */
+typedef subtract_with_carry_engine<thrust::detail::uint64_t, 48,  5, 12> ranlux48_base;
+
+/*! \} // end predefined_random
+ */
+
+} // end random
+
+// import names into thrust::
+using random::subtract_with_carry_engine;
+using random::ranlux24_base;
+using random::ranlux48_base;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/subtract_with_carry_engine.inl>
+
diff --git a/miniCUDA124/include/thrust/random/uniform_int_distribution.h b/miniCUDA124/include/thrust/random/uniform_int_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..93cea2bd7b47a116f168aaa9d5882693b4a946dd
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/uniform_int_distribution.h
@@ -0,0 +1,284 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file uniform_int_distribution.h
+ *  \brief A uniform distribution of integer-valued numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/pair.h>
+#include <thrust/detail/integer_traits.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_distributions Random Number Distributions Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class uniform_int_distribution
+ *  \brief A \p uniform_int_distribution random number distribution produces signed or unsigned integer
+ *         uniform random numbers from a given range.
+ *
+ *  \tparam IntType The type of integer to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p uniform_int_distribution with a
+ *  random number engine to produce random integers drawn from a given range:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/uniform_int_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a uniform_int_distribution to produce ints from [-7,13]
+ *    thrust::uniform_int_distribution<int> dist(-7,13);
+ *
+ *    // write a random number from the range [-7,13] to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the range of the distribution, just in case we forgot
+ *    std::cout << dist.min() << std::endl;
+ *
+ *    // -7 is printed
+ *
+ *    std::cout << dist.max() << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    // write the parameters of the distribution (which happen to be the bounds) to standard output
+ *    std::cout << dist.a() << std::endl;
+ *
+ *    // -7 is printed
+ *
+ *    std::cout << dist.b() << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename IntType = int>
+  class uniform_int_distribution
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the integer produced by this \p uniform_int_distribution.
+     */
+    typedef IntType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p uniform_int_distribution's parameters.
+     */
+    typedef thrust::pair<IntType,IntType> param_type;
+
+    // constructors and reset functions
+
+    /*! This constructor creates a new \p uniform_int_distribution from two values defining the
+     *  range of the distribution.
+     *
+     *  \param a The smallest integer to potentially produce. Defaults to \c 0.
+     *  \param b The largest integer to potentially produce. Defaults to the largest representable integer in
+     *           the platform.
+     */
+    __host__ __device__
+    explicit uniform_int_distribution(IntType a = 0,
+                                      IntType b = THRUST_NS_QUALIFIER::detail::integer_traits<IntType>::const_max);
+
+    /*! This constructor creates a new \p uniform_int_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the range) of the distribution.
+     */
+    __host__ __device__
+    explicit uniform_int_distribution(const param_type &parm);
+
+    /*! This does nothing.  It is included to conform to the requirements of the RandomDistribution concept.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new uniform random integer drawn from this \p uniform_int_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new uniform random integer as if by creating a new \p uniform_int_distribution
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p uniform_int_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+
+    /*! This method returns the value of the parameter with which this \p uniform_int_distribution
+     *  was constructed.
+     *
+     *  \return The lower bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type a(void) const;
+
+    /*! This method returns the value of the parameter with which this \p uniform_int_distribution
+     *  was constructed.
+     *
+     *  \return The upper bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type b(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p uniform_int_distribution was constructed.
+     *
+     *  \return A \p param_type object enapsulating the range of this \p uniform_int_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p uniform_int_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new range of this \p uniform_int_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest integer this \p uniform_int_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the largest integer this \p uniform_int_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const uniform_int_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end uniform_int_distribution
+
+
+/*! This function checks two \p uniform_int_distributions for equality.
+ *  \param lhs The first \p uniform_int_distribution to test.
+ *  \param rhs The second \p uniform_int_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename IntType>
+__host__ __device__
+bool operator==(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs);
+
+
+/*! This function checks two \p uniform_int_distributions for inequality.
+ *  \param lhs The first \p uniform_int_distribution to test.
+ *  \param rhs The second \p uniform_int_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename IntType>
+__host__ __device__
+bool operator!=(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs);
+
+
+/*! This function streams a uniform_int_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p uniform_int_distribution to stream out.
+ *  \return \p os
+ */
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_int_distribution<IntType> &d);
+
+
+/*! This function streams a uniform_int_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p uniform_int_distribution to stream in.
+ *  \return \p is
+ */
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_int_distribution<IntType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::uniform_int_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/uniform_int_distribution.inl>
+
diff --git a/miniCUDA124/include/thrust/random/uniform_real_distribution.h b/miniCUDA124/include/thrust/random/uniform_real_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8db56eda24c4e534715ffcbdb96f897f2e17983
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/uniform_real_distribution.h
@@ -0,0 +1,281 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file uniform_real_distribution.h
+ *  \brief A uniform distribution of real-valued numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/pair.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_distributions
+ *  \{
+ */
+
+/*! \class uniform_real_distribution
+ *  \brief A \p uniform_real_distribution random number distribution produces floating point
+ *         uniform random numbers from a half-open interval.
+ *
+ *  \tparam RealType The type of floating point number to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p uniform_real_distribution with a
+ *  random number engine to produce random integers drawn from a given range:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/uniform_real_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a uniform_real_distribution to produce floats from [-7,13)
+ *    thrust::uniform_real_distribution<float> dist(-7,13);
+ *
+ *    // write a random number from the range [-7,13) to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the range of the distribution, just in case we forgot
+ *    std::cout << dist.min() << std::endl;
+ *
+ *    // -7.0 is printed
+ *
+ *    std::cout << dist.max() << std::endl;
+ *
+ *    // 13.0 is printed
+ *
+ *    // write the parameters of the distribution (which happen to be the bounds) to standard output
+ *    std::cout << dist.a() << std::endl;
+ *
+ *    // -7.0 is printed
+ *
+ *    std::cout << dist.b() << std::endl;
+ *
+ *    // 13.0 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename RealType = double>
+  class uniform_real_distribution
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the floating point number produced by this \p uniform_real_distribution.
+     */
+    typedef RealType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p uniform_real_distribution's parameters.
+     */
+    typedef thrust::pair<RealType,RealType> param_type;
+
+    // constructors and reset functions
+
+    /*! This constructor creates a new \p uniform_real_distribution from two values defining the
+     *  half-open interval of the distribution.
+     *
+     *  \param a The smallest floating point number to potentially produce. Defaults to \c 0.0.
+     *  \param b The smallest number larger than the largest floating point number to potentially produce. Defaults to \c 1.0.
+     */
+    __host__ __device__
+    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
+
+    /*! This constructor creates a new \p uniform_real_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the range) of the distribution.
+     */
+    __host__ __device__
+    explicit uniform_real_distribution(const param_type &parm);
+
+    /*! This does nothing.  It is included to conform to the requirements of the RandomDistribution concept.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new uniform random integer drawn from this \p uniform_real_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new uniform random integer as if by creating a new \p uniform_real_distribution
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p uniform_real_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+
+    /*! This method returns the value of the parameter with which this \p uniform_real_distribution
+     *  was constructed.
+     *
+     *  \return The lower bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type a(void) const;
+
+    /*! This method returns the value of the parameter with which this \p uniform_real_distribution
+     *  was constructed.
+     *
+     *  \return The upper bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type b(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p uniform_real_distribution was constructed.
+     *
+     *  \return A \p param_type object enapsulating the half-open interval of this \p uniform_real_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p uniform_real_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new half-open interval of this \p uniform_real_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the smallest number larger than largest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const uniform_real_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end uniform_real_distribution
+
+
+/*! This function checks two \p uniform_real_distributions for equality.
+ *  \param lhs The first \p uniform_real_distribution to test.
+ *  \param rhs The second \p uniform_real_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator==(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs);
+
+
+/*! This function checks two \p uniform_real_distributions for inequality.
+ *  \param lhs The first \p uniform_real_distribution to test.
+ *  \param rhs The second \p uniform_real_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator!=(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs);
+
+
+/*! This function streams a uniform_real_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p uniform_real_distribution to stream out.
+ *  \return \p os
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_real_distribution<RealType> &d);
+
+
+/*! This function streams a uniform_real_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p uniform_real_distribution to stream in.
+ *  \return \p is
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_real_distribution<RealType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::uniform_real_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/uniform_real_distribution.inl>
+
diff --git a/miniCUDA124/include/thrust/random/xor_combine_engine.h b/miniCUDA124/include/thrust/random/xor_combine_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..616b87513aec8e7d8d149f41dd981cd205b6038e
--- /dev/null
+++ b/miniCUDA124/include/thrust/random/xor_combine_engine.h
@@ -0,0 +1,278 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file xor_combine_engine.h
+ *  \brief A pseudorandom number generator which produces pseudorandom
+ *         numbers from two integer base engines by merging their
+ *         pseudorandom numbers with bitwise exclusive-or.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits.h>
+#include <thrust/random/detail/xor_combine_engine_max.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+#include <cstddef> // for size_t
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_adaptors
+ *  \{
+ */
+
+/*! \class xor_combine_engine
+ *  \brief An \p xor_combine_engine adapts two existing base random number engines and
+ *         produces random values by combining the values produced by each.
+ *
+ *  \tparam Engine1 The type of the first base random number engine to adapt.
+ *  \tparam s1 The size of the first shift to use in the generation algorithm.
+ *  \tparam Engine2 The type of the second base random number engine to adapt.
+ *  \tparam s2 The second of the second shift to use in the generation algorithm. Defaults to \c 0.
+ *
+ *  The following code snippet shows an example of using an \p xor_combine_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/xor_combine_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create an xor_combine_engine from minstd_rand and minstd_rand0
+ *    // use a shift of 0 for each
+ *    thrust::xor_combine_engine<thrust::minstd_rand,0,thrust::minstd_rand0,0> rng;
+ *
+ *    // print a random number to standard output
+ *    std::cout << rng() << std::endl;
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2=0u>
+  class xor_combine_engine
+{
+  public:
+    // types
+
+    /*! \typedef base1_type
+     *  \brief The type of the first adapted base random number engine.
+     */
+    typedef Engine1 base1_type;
+
+    /*! \typedef base2_type
+     *  \brief The type of the second adapted base random number engine.
+     */
+    typedef Engine2 base2_type;
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p xor_combine_engine.
+     */
+    typedef typename thrust::detail::eval_if<
+      (sizeof(typename base2_type::result_type) > sizeof(typename base1_type::result_type)),
+      thrust::detail::identity_<typename base2_type::result_type>,
+      thrust::detail::identity_<typename base1_type::result_type>
+    >::type result_type;
+
+    /*! The size of the first shift used in the generation algorithm.
+     */
+    static const size_t shift1 = s1;
+
+    /*! The size of the second shift used in the generation algorithm.
+     */
+    static const size_t shift2 = s2;
+
+    /*! The smallest value this \p xor_combine_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p xor_combine_engine may potentially produce.
+     */
+    static const result_type max =
+      detail::xor_combine_engine_max<
+        Engine1, s1, Engine2, s2, result_type
+      >::value;
+
+    // constructors and seeding functions
+
+    /*! This constructor constructs a new \p xor_combine_engine and constructs
+     *  its adapted engines using their null constructors.
+     */
+    __host__ __device__
+    xor_combine_engine(void);
+
+    /*! This constructor constructs a new \p xor_combine_engine using
+     *  given \p base1_type and \p base2_type engines to initialize its adapted base engines.
+     *
+     *  \param urng1 A \p base1_type to use to initialize this \p xor_combine_engine's
+     *         first adapted base engine.
+     *  \param urng2 A \p base2_type to use to initialize this \p xor_combine_engine's
+     *         first adapted base engine.
+     */
+    __host__ __device__
+    xor_combine_engine(const base1_type &urng1, const base2_type &urng2);
+
+    /*! This constructor initializes a new \p xor_combine_engine with a given seed.
+     *
+     *  \param s The seed used to intialize this \p xor_combine_engine's adapted base engines.
+     */
+    __host__ __device__
+    xor_combine_engine(result_type s);
+
+    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
+     *  by using their \p default_seed values.
+     */
+    __host__ __device__
+    void seed(void);
+
+    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
+     *  by using the given seed.
+     *
+     *  \param s The seed with which to intialize this \p xor_combine_engine's adapted base engines.
+     */
+    __host__ __device__
+    void seed(result_type s);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p xor_combine_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p xor_combine_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    // property functions
+
+    /*! This member function returns a const reference to this \p xor_combine_engine's
+     *  first adapted base engine.
+     *
+     *  \return A const reference to the first base engine this \p xor_combine_engine adapts.
+     */
+    __host__ __device__
+    const base1_type &base1(void) const;
+
+    /*! This member function returns a const reference to this \p xor_combine_engine's
+     *  second adapted base engine.
+     *
+     *  \return A const reference to the second base engine this \p xor_combine_engine adapts.
+     */
+    __host__ __device__
+    const base2_type &base2(void) const;
+
+    /*! \cond
+     */
+  private:
+    base1_type m_b1;
+    base2_type m_b2;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const xor_combine_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    /*! \endcond
+     */
+}; // end xor_combine_engine
+
+
+/*! This function checks two \p xor_combine_engines for equality.
+ *  \param lhs The first \p xor_combine_engine to test.
+ *  \param rhs The second \p xor_combine_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
+__host__ __device__
+bool operator==(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
+                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
+
+
+/*! This function checks two \p xor_combine_engines for inequality.
+ *  \param lhs The first \p xor_combine_engine to test.
+ *  \param rhs The second \p xor_combine_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
+__host__ __device__
+bool operator!=(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
+                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
+
+
+/*! This function streams a xor_combine_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p xor_combine_engine to stream out.
+ *  \return \p os
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
+
+
+/*! This function streams a xor_combine_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p xor_combine_engine to stream in.
+ *  \return \p is
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
+
+
+/*! \} // end random_number_engine_adaptors
+ */
+
+
+} // end random
+
+// import names into thrust::
+using random::xor_combine_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/xor_combine_engine.inl>
+
diff --git a/miniCUDA124/include/thrust/system/error_code.h b/miniCUDA124/include/thrust/system/error_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..729c6d15a676cb32465d83080b4b782dba4e7f1d
--- /dev/null
+++ b/miniCUDA124/include/thrust/system/error_code.h
@@ -0,0 +1,530 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file error_code.h
+ *  \brief An object used to hold error values, such as those originating from the
+ *         operating system or other low-level application program interfaces.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/type_traits.h>
+#include <thrust/system/detail/errno.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+
+/*! \addtogroup system_diagnostics
+ *  \{
+ */
+
+class error_condition;
+class error_code;
+
+/*! A metafunction returning whether or not the parameter is an \p error_code enum.
+ */
+template<typename T> struct is_error_code_enum : public thrust::detail::false_type {};
+
+/*! A metafunction returning whether or not the parameter is an \p error_condition enum.
+ */
+template<typename T> struct is_error_condition_enum : public thrust::detail::false_type {};
+
+
+// XXX N3092 prefers enum class errc { ... }
+namespace errc
+{
+
+/*! An enum containing common error codes.
+ */
+enum errc_t
+{
+  address_family_not_supported       = detail::eafnosupport,
+  address_in_use                     = detail::eaddrinuse,
+  address_not_available              = detail::eaddrnotavail,
+  already_connected                  = detail::eisconn,
+  argument_list_too_long             = detail::e2big,
+  argument_out_of_domain             = detail::edom,
+  bad_address                        = detail::efault,
+  bad_file_descriptor                = detail::ebadf,
+  bad_message                        = detail::ebadmsg,
+  broken_pipe                        = detail::epipe,
+  connection_aborted                 = detail::econnaborted,
+  connection_already_in_progress     = detail::ealready,
+  connection_refused                 = detail::econnrefused,
+  connection_reset                   = detail::econnreset,
+  cross_device_link                  = detail::exdev,
+  destination_address_required       = detail::edestaddrreq,
+  device_or_resource_busy            = detail::ebusy,
+  directory_not_empty                = detail::enotempty,
+  executable_format_error            = detail::enoexec,
+  file_exists                        = detail::eexist,
+  file_too_large                     = detail::efbig,
+  filename_too_long                  = detail::enametoolong,
+  function_not_supported             = detail::enosys,
+  host_unreachable                   = detail::ehostunreach,
+  identifier_removed                 = detail::eidrm,
+  illegal_byte_sequence              = detail::eilseq,
+  inappropriate_io_control_operation = detail::enotty,
+  interrupted                        = detail::eintr,
+  invalid_argument                   = detail::einval,
+  invalid_seek                       = detail::espipe,
+  io_error                           = detail::eio,
+  is_a_directory                     = detail::eisdir,
+  message_size                       = detail::emsgsize,
+  network_down                       = detail::enetdown,
+  network_reset                      = detail::enetreset,
+  network_unreachable                = detail::enetunreach,
+  no_buffer_space                    = detail::enobufs,
+  no_child_process                   = detail::echild,
+  no_link                            = detail::enolink,
+  no_lock_available                  = detail::enolck,
+  no_message_available               = detail::enodata,
+  no_message                         = detail::enomsg,
+  no_protocol_option                 = detail::enoprotoopt,
+  no_space_on_device                 = detail::enospc,
+  no_stream_resources                = detail::enosr,
+  no_such_device_or_address          = detail::enxio,
+  no_such_device                     = detail::enodev,
+  no_such_file_or_directory          = detail::enoent,
+  no_such_process                    = detail::esrch,
+  not_a_directory                    = detail::enotdir,
+  not_a_socket                       = detail::enotsock,
+  not_a_stream                       = detail::enostr,
+  not_connected                      = detail::enotconn,
+  not_enough_memory                  = detail::enomem,
+  not_supported                      = detail::enotsup,
+  operation_canceled                 = detail::ecanceled,
+  operation_in_progress              = detail::einprogress,
+  operation_not_permitted            = detail::eperm,
+  operation_not_supported            = detail::eopnotsupp,
+  operation_would_block              = detail::ewouldblock,
+  owner_dead                         = detail::eownerdead,
+  permission_denied                  = detail::eacces,
+  protocol_error                     = detail::eproto,
+  protocol_not_supported             = detail::eprotonosupport,
+  read_only_file_system              = detail::erofs,
+  resource_deadlock_would_occur      = detail::edeadlk,
+  resource_unavailable_try_again     = detail::eagain,
+  result_out_of_range                = detail::erange,
+  state_not_recoverable              = detail::enotrecoverable,
+  stream_timeout                     = detail::etime,
+  text_file_busy                     = detail::etxtbsy,
+  timed_out                          = detail::etimedout,
+  too_many_files_open_in_system      = detail::enfile,
+  too_many_files_open                = detail::emfile,
+  too_many_links                     = detail::emlink,
+  too_many_symbolic_link_levels      = detail::eloop,
+  value_too_large                    = detail::eoverflow,
+  wrong_protocol_type                = detail::eprototype
+}; // end errc_t
+
+} // end namespace errc
+
+
+/*! Specialization of \p is_error_condition_enum for \p errc::errc_t
+ */
+template<> struct is_error_condition_enum<errc::errc_t> : public thrust::detail::true_type {};
+
+
+// [19.5.1.1] class error_category
+
+/*! \brief The class \p error_category serves as a base class for types used to identify the
+ *         source and encoding of a particular category of error code. Classes may be derived
+ *         from \p error_category to support categories of errors in addition to those defined
+ *         in the C++ International Standard.
+ */
+class error_category
+{
+  public:
+    /*! Destructor does nothing.
+     */
+    inline virtual ~error_category(void);
+
+    // XXX enable upon c++0x
+    // error_category(const error_category &) = delete;
+    // error_category &operator=(const error_category &) = delete;
+
+    /*! \return A string naming the error category.
+     */
+    inline virtual const char *name(void) const = 0;
+
+    /*! \return \p error_condition(ev, *this).
+     */
+    inline virtual error_condition default_error_condition(int ev) const;
+
+    /*! \return <tt>default_error_condition(code) == condition</tt>
+     */
+    inline virtual bool equivalent(int code, const error_condition &condition) const;
+
+    /*! \return <tt>*this == code.category() && code.value() == condition</tt>
+     */
+    inline virtual bool equivalent(const error_code &code, int condition) const;
+
+    /*! \return A string that describes the error condition denoted by \p ev.
+     */
+    virtual std::string message(int ev) const = 0;
+
+    /*! \return <tt>*this == &rhs</tt>
+     */
+    inline bool operator==(const error_category &rhs) const;
+
+    /*! \return <tt>!(*this == rhs)</tt>
+     */
+    inline bool operator!=(const error_category &rhs) const;
+
+    /*! \return <tt>less<const error_category*>()(this, &rhs)</tt>
+     *  \note \c less provides a total ordering for pointers.
+     */
+    inline bool operator<(const error_category &rhs) const;
+}; // end error_category
+
+
+// [19.5.1.5] error_category objects
+
+
+/*! \return A reference to an object of a type derived from class \p error_category.
+ *  \note The object's \p default_error_condition and \p equivalent virtual functions
+ *        shall behave as specified for the class \p error_category. The object's
+ *        \p name virtual function shall return a pointer to the string <tt>"generic"</tt>.
+ */
+inline const error_category &generic_category(void);
+
+
+/*! \return A reference to an object of a type derived from class \p error_category.
+ *  \note The object's \p equivalent virtual functions shall behave as specified for
+ *        class \p error_category. The object's \p name virtual function shall return
+ *        a pointer to the string <tt>"system"</tt>. The object's \p default_error_condition
+ *        virtual function shall behave as follows:
+ *
+ *        If the argument <tt>ev</tt> corresponds to a POSIX <tt>errno</tt> value
+ *        \c posv, the function shall return <tt>error_condition(ev,generic_category())</tt>.
+ *        Otherwise, the function shall return <tt>error_condition(ev,system_category())</tt>.
+ *        What constitutes correspondence for any given operating system is unspecified.
+ */
+inline const error_category &system_category(void);
+
+
+// [19.5.2] Class error_code
+
+
+/*! \brief The class \p error_code describes an object used to hold error code values, such as
+ *         those originating from the operating system or other low-level application program
+ *         interfaces.
+ */
+class error_code
+{
+  public:
+    // [19.5.2.2] constructors:
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>value() == 0</tt> and <tt>category() == &system_category()</tt>.
+     */
+    inline error_code(void);
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>value() == val</tt> and <tt>category() == &cat</tt>.
+     */
+    inline error_code(int val, const error_category &cat);
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>*this == make_error_code(e)</tt>.
+     */
+    template <typename ErrorCodeEnum>
+      error_code(ErrorCodeEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        , typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0
+#endif // THRUST_HOST_COMPILER_MSVC
+        );
+
+    // [19.5.2.3] modifiers:
+
+    /*! \post <tt>value() == val</tt> and <tt>category() == &cat</tt>.
+     */
+    inline void assign(int val, const error_category &cat);
+
+    /*! \post <tt>*this == make_error_code(e)</tt>.
+     */
+    template <typename ErrorCodeEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+      typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
+#else
+      error_code &
+#endif // THRUST_HOST_COMPILER_MSVC
+        operator=(ErrorCodeEnum e);
+
+    /*! \post <tt>value() == 0</tt> and <tt>category() == system_category()</tt>.
+     */
+    inline void clear(void);
+
+    // [19.5.2.4] observers:
+
+    /*! \return An integral value of this \p error_code object.
+     */
+    inline int value(void) const;
+
+    /*! \return An \p error_category describing the category of this \p error_code object.
+     */
+    inline const error_category &category(void) const;
+
+    /*! \return <tt>category().default_error_condition()</tt>.
+     */
+    inline error_condition default_error_condition(void) const;
+
+    /*! \return <tt>category().message(value())</tt>.
+     */
+    inline std::string message(void) const;
+
+    // XXX replace the below upon c++0x
+    // inline explicit operator bool (void) const;
+
+    /*! \return <tt>value() != 0</tt>.
+     */
+    inline operator bool (void) const;
+
+    /*! \cond
+     */
+  private:
+    int m_val;
+    const error_category *m_cat;
+    /*! \endcond
+     */
+}; // end error_code
+
+
+// [19.5.2.5] Class error_code non-member functions
+
+
+// XXX replace errc::errc_t with errc upon c++0x
+/*! \return <tt>error_code(static_cast<int>(e), generic_category())</tt>
+ */
+inline error_code make_error_code(errc::errc_t e);
+
+
+/*! \return <tt>lhs.category() < rhs.category() || lhs.category() == rhs.category() && lhs.value() < rhs.value()</tt>.
+ */
+inline bool operator<(const error_code &lhs, const error_code &rhs);
+
+
+/*! Effects: <tt>os << ec.category().name() << ':' << ec.value()</tt>.
+ */
+template <typename charT, typename traits>
+  std::basic_ostream<charT,traits>&
+    operator<<(std::basic_ostream<charT,traits>& os, const error_code &ec);
+
+
+// [19.5.3] class error_condition
+
+
+/*! \brief The class \p error_condition describes an object used to hold values identifying
+ *  error conditions.
+ *
+ *  \note \p error_condition values are portable abstractions, while \p error_code values
+ *        are implementation specific.
+ */
+class error_condition
+{
+  public:
+    // [19.5.3.2] constructors
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>value() == 0</tt>.
+     *  \post <tt>category() == generic_category()</tt>.
+     */
+    inline error_condition(void);
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>value() == val</tt>.
+     *  \post <tt>category() == cat</tt>.
+     */
+    inline error_condition(int val, const error_category &cat);
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>*this == make_error_condition(e)</tt>.
+     *  \note This constructor shall not participate in overload resolution unless
+     *        <tt>is_error_condition_enum<ErrorConditionEnum>::value</tt> is <tt>true</tt>.
+     */
+    template<typename ErrorConditionEnum>
+      error_condition(ErrorConditionEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        , typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type * = 0
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     );
+
+    // [19.5.3.3] modifiers
+
+    /*! Assigns to this \p error_code object from an error value and an \p error_category.
+     *  \param val The new value to return from <tt>value()</tt>.
+     *  \param cat The new \p error_category to return from <tt>category()</tt>.
+     *  \post <tt>value() == val</tt>.
+     *  \post <tt>category() == cat</tt>.
+     */
+    inline void assign(int val, const error_category &cat);
+
+    /*! Assigns to this \p error_code object from an error condition enumeration.
+     *  \return *this
+     *  \post <tt>*this == make_error_condition(e)</tt>.
+     *  \note This operator shall not participate in overload resolution unless
+     *        <tt>is_error_condition_enum<ErrorConditionEnum>::value</tt> is <tt>true</tt>.
+     */
+    template<typename ErrorConditionEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+      typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
+#else
+      error_condition &
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        operator=(ErrorConditionEnum e);
+
+    /*! Clears this \p error_code object.
+     *  \post <tt>value == 0</tt>
+     *  \post <tt>category() == generic_category()</tt>.
+     */
+    inline void clear(void);
+
+    // [19.5.3.4] observers
+
+    /*! \return The value encoded by this \p error_condition.
+     */
+    inline int value(void) const;
+
+    /*! \return A <tt>const</tt> reference to the \p error_category encoded by this \p error_condition.
+     */
+    inline const error_category &category(void) const;
+
+    /*! \return <tt>category().message(value())</tt>.
+     */
+    inline std::string message(void) const;
+
+    // XXX replace below with this upon c++0x
+    //explicit operator bool (void) const;
+
+    /*! \return <tt>value() != 0</tt>.
+     */
+    inline operator bool (void) const;
+
+    /*! \cond
+     */
+
+  private:
+    int m_val;
+    const error_category *m_cat;
+
+    /*! \endcond
+     */
+}; // end error_condition
+
+
+
+// [19.5.3.5] Class error_condition non-member functions
+
+// XXX replace errc::errc_t with errc upon c++0x
+/*! \return <tt>error_condition(static_cast<int>(e), generic_category())</tt>.
+ */
+inline error_condition make_error_condition(errc::errc_t e);
+
+
+/*! \return <tt>lhs.category() < rhs.category() || lhs.category() == rhs.category() && lhs.value() < rhs.value()</tt>.
+ */
+inline bool operator<(const error_condition &lhs, const error_condition &rhs);
+
+
+// [19.5.4] Comparison operators
+
+
+/*! \return <tt>lhs.category() == rhs.category() && lhs.value() == rhs.value()</tt>.
+ */
+inline bool operator==(const error_code &lhs, const error_code &rhs);
+
+
+/*! \return <tt>lhs.category().equivalent(lhs.value(), rhs) || rhs.category().equivalent(lhs,rhs.value())</tt>.
+ */
+inline bool operator==(const error_code &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>rhs.category().equivalent(lhs.value(), lhs) || lhs.category().equivalent(rhs, lhs.value())</tt>.
+ */
+inline bool operator==(const error_condition &lhs, const error_code &rhs);
+
+
+/*! \return <tt>lhs.category() == rhs.category() && lhs.value() == rhs.value()</tt>
+ */
+inline bool operator==(const error_condition &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_code &lhs, const error_code &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_code &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_condition &lhs, const error_code &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_condition &lhs, const error_condition &rhs);
+
+/*! \} // end system_diagnostics
+ */
+
+
+} // end system
+
+
+// import names into thrust::
+using system::error_category;
+using system::error_code;
+using system::error_condition;
+using system::is_error_code_enum;
+using system::is_error_condition_enum;
+using system::make_error_code;
+using system::make_error_condition;
+
+// XXX replace with using system::errc upon c++0x
+namespace errc = system::errc;
+
+using system::generic_category;
+using system::system_category;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/error_category.inl>
+#include <thrust/system/detail/error_code.inl>
+#include <thrust/system/detail/error_condition.inl>
+
diff --git a/miniCUDA124/include/thrust/system/system_error.h b/miniCUDA124/include/thrust/system/system_error.h
new file mode 100644
index 0000000000000000000000000000000000000000..056bea53eed88c4de322f6572a596a105055a35d
--- /dev/null
+++ b/miniCUDA124/include/thrust/system/system_error.h
@@ -0,0 +1,186 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file system/system_error.h
+ *  \brief An exception object used to report error conditions that have an
+ *         associated error code
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <stdexcept>
+#include <string>
+
+#include <thrust/system/error_code.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+// [19.5.5] Class system_error
+
+// [19.5.5.1] Class system_error overview
+
+/*! \addtogroup system_diagnostics System Diagnostics
+ *  \ingroup system
+ *  \{
+ */
+
+/*! \brief The class \p system_error describes an exception object used to report error
+ *  conditions that have an associated \p error_code. Such error conditions typically
+ *  originate from the operating system or other low-level application program interfaces.
+ *
+ *  Thrust uses \p system_error to report the error codes returned from device backends
+ *  such as the CUDA runtime.
+ *
+ *  The following code listing demonstrates how to catch a \p system_error to recover
+ *  from an error.
+ *
+ *  \code
+ *
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/system.h>
+ *  #include <thrust/sort.h>
+ *
+ *  void terminate_gracefully(void)
+ *  {
+ *    // application-specific termination code here
+ *    ...
+ *  }
+ *
+ *  int main(void)
+ *  {
+ *    try
+ *    {
+ *      thrust::device_vector<float> vec;
+ *      thrust::sort(vec.begin(), vec.end());
+ *    }
+ *    catch(thrust::system_error e)
+ *    {
+ *      std::cerr << "Error inside sort: " << e.what() << std::endl;
+ *      terminate_gracefully();
+ *    }
+ *
+ *    return 0;
+ *  }
+ *
+ *  \endcode
+ *
+ *  \note If an error represents an out-of-memory condition, implementations are encouraged
+ *  to throw an exception object of type \p std::bad_alloc rather than \p system_error.
+ */
+class system_error
+  : public std::runtime_error
+{
+  public:
+    // [19.5.5.2] Class system_error members
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == ec</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(error_code ec, const std::string &what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == ec</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(error_code ec, const char *what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \post <tt>code() == ec</tt>.
+     */
+    inline system_error(error_code ec);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat, const std::string &what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat, const char *what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat);
+
+    /*! Destructor does not throw.
+     */
+    inline virtual ~system_error(void) noexcept {};
+
+    /*! Returns an object encoding the error.
+     *  \return <tt>ec</tt> or <tt>error_code(ev, ecat)</tt>, from the
+     *          constructor, as appropriate.
+     */
+    inline const error_code &code(void) const noexcept;
+
+    /*! Returns a human-readable string indicating the nature of the error.
+     *  \return a string incorporating <tt>code().message()</tt> and the
+     *          arguments supplied in the constructor.
+     */
+    inline const char *what(void) const noexcept;
+
+    /*! \cond
+     */
+  private:
+    error_code          m_error_code;
+    mutable std::string m_what;
+
+    /*! \endcond
+     */
+}; // end system_error
+
+} // end system
+
+/*! \} // end system_diagnostics
+ */
+
+// import names into thrust::
+using system::system_error;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/system_error.inl>
+
diff --git a/miniCUDA124/include/thrust/type_traits/integer_sequence.h b/miniCUDA124/include/thrust/type_traits/integer_sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cb7b032296a9ee6d0d2d4bc9c4807058fe2432a
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/integer_sequence.h
@@ -0,0 +1,389 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief C++14's
+ *  <a href="https://en.cppreference.com/w/cpp/utility/integer_sequence"><tt>std::index_sequence</tt></a>,
+ *  associated helper aliases, and some related extensions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <type_traits>
+#include <utility>
+#include <cstdint>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \brief A compile-time sequence of
+ *  <a href="https://en.cppreference.com/w/cpp/language/constant_expression#Integral_constant_expression"><i>integral constants</i></a>
+ *  of type \c T with values <tt>Is...</tt>.
+ *
+ *  \see <a href="https://en.cppreference.com/w/cpp/language/constant_expression#Integral_constant_expression"><i>integral constants</i></a>
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ *  \see integer_sequence_push_front
+ *  \see integer_sequence_push_back
+ *  \see <a href="https://en.cppreference.com/w/cpp/utility/integer_sequence"><tt>std::integer_sequence</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <typename T, T... Is>
+using integer_sequence = std::integer_sequence<T, Is...>;
+#else
+template <typename T, T... Is>
+struct integer_sequence
+{
+  using type = integer_sequence;
+  using value_type = T;
+  using size_type = std::size_t;
+
+  __host__ __device__
+  static constexpr size_type size() noexcept
+  {
+    return sizeof...(Is);
+  }
+};
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief A compile-time sequence of type
+ *  <a href="https://en.cppreference.com/w/cpp/types/size_t">std::size_t</a>
+ *  with values <tt>Is...</tt>.
+ *
+ *  \see integer_sequence
+ *  \see make_integer_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ *  \see integer_sequence_push_front
+ *  \see integer_sequence_push_back
+ *  \see <a href="https://en.cppreference.com/w/cpp/utility/integer_sequence"><tt>std::index_sequence</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <std::size_t... Is>
+using index_sequence = std::index_sequence<Is...>;
+#else
+template <std::size_t... Is>
+using index_sequence = integer_sequence<std::size_t, Is...>;
+#endif
+
+#if THRUST_CPP_DIALECT < 2014
+/*! \cond
+ */
+
+namespace detail
+{
+
+/*! \brief Create a new \c integer_sequence containing the elements of \c
+ * Sequence0 followed by the elements of \c Sequence1. \c Sequence0::size() is
+ * added to each element from \c Sequence1 in the new sequence.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ *  \see merge_and_renumber_reversed_integer_sequences_impl
+ */
+template <typename Sequence0, typename Sequence1>
+  struct merge_and_renumber_integer_sequences_impl;
+template <typename Sequence0, typename Sequence1>
+  using merge_and_renumber_integer_sequences =
+      typename merge_and_renumber_integer_sequences_impl<
+          Sequence0, Sequence1
+      >::type;
+
+template <typename T, std::size_t N>
+  struct make_integer_sequence_impl;
+
+} // namespace detail
+
+/*! \endcond
+ */
+#endif
+
+/*! \brief Create a new \c integer_sequence with elements
+ *  <tt>0, 1, 2, ..., N - 1</tt> of type \c T.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ *  \see <a href="https://en.cppreference.com/w/cpp/utility/integer_sequence"><tt>std::make_integer_sequence</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <typename T, std::size_t N>
+using make_integer_sequence = std::make_integer_sequence<T, N>;
+#else
+template <typename T, std::size_t N>
+using make_integer_sequence =
+  typename detail::make_integer_sequence_impl<T, N>::type;
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T, T... Is0, T... Is1>
+struct merge_and_renumber_integer_sequences_impl<
+  integer_sequence<T, Is0...>, integer_sequence<T, Is1...>
+>
+{
+  using type = integer_sequence<T, Is0..., (sizeof...(Is0) + Is1)...>;
+};
+
+template <typename T, std::size_t N>
+struct make_integer_sequence_impl
+{
+  using type = merge_and_renumber_integer_sequences<
+    make_integer_sequence<T, N / 2>
+  , make_integer_sequence<T, N - N / 2>
+  >;
+};
+
+template <typename T>
+struct make_integer_sequence_impl<T, 0>
+{
+  using type = integer_sequence<T>;
+};
+
+template <typename T>
+struct make_integer_sequence_impl<T, 1>
+{
+  using type = integer_sequence<T, 0>;
+};
+
+} // namespace detail
+
+/*! \endcond
+ */
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief Create a new \c integer_sequence with elements
+ *  <tt>0, 1, 2, ..., N - 1</tt> of type
+ *  <a href="https://en.cppreference.com/w/cpp/types/size_t">std::size_t</a>.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_reversed_index_sequence
+ *  \see <a href="https://en.cppreference.com/w/cpp/utility/integer_sequence"><tt>std::make_index_sequence</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <std::size_t N>
+using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <std::size_t N>
+using make_index_sequence =
+  make_integer_sequence<std::size_t, N>;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+/*! \brief Create a new \c integer_sequence containing the elements of \c
+ *  Sequence0 followed by the elements of \c Sequence1. \c Sequence1::size() is
+ *  added to each element from \c Sequence0 in the new sequence.
+ *
+ *  \see make_reversed_integer_sequence
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ *  \see merge_and_renumber_integer_sequences_impl
+ */
+template <typename Sequence0, typename Sequence1>
+  struct merge_and_renumber_reversed_integer_sequences_impl;
+template <typename Sequence0, typename Sequence1>
+  using merge_and_renumber_reversed_integer_sequences =
+      typename merge_and_renumber_reversed_integer_sequences_impl<
+          Sequence0, Sequence1
+      >::type;
+
+template <typename T, std::size_t N>
+struct make_reversed_integer_sequence_impl;
+
+template <typename T, T Value, typename Sequence>
+struct integer_sequence_push_front_impl;
+
+template <typename T, T Value, typename Sequence>
+struct integer_sequence_push_back_impl;
+
+template <typename T, T... Is0, T... Is1>
+struct merge_and_renumber_reversed_integer_sequences_impl<
+  integer_sequence<T, Is0...>, integer_sequence<T, Is1...>
+>
+{
+  using type = integer_sequence<T, (sizeof...(Is1) + Is0)..., Is1...>;
+};
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief Create a new \c integer_sequence with elements
+ *  <tt>N - 1, N - 2, N - 3, ..., 0</tt>.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_index_sequence
+ *  \see make_reversed_index_sequence
+ */
+template <typename T, std::size_t N>
+using make_reversed_integer_sequence =
+  typename detail::make_reversed_integer_sequence_impl<T, N>::type;
+
+/*! \brief Create a new \c index_sequence with elements
+ *  <tt>N - 1, N - 2, N - 3, ..., 0</tt>.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_reversed_integer_sequence
+ *  \see make_reversed_index_sequence
+ */
+template <std::size_t N>
+using make_reversed_index_sequence =
+  make_reversed_integer_sequence<std::size_t, N>;
+
+/*! \brief Add a new element to the front of an \c integer_sequence.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_index_sequence
+ */
+template <typename T, T Value, typename Sequence>
+using integer_sequence_push_front =
+  typename detail::integer_sequence_push_front_impl<T, Value, Sequence>::type;
+
+/*! \brief Add a new element to the back of an \c integer_sequence.
+ *
+ *  \see integer_sequence
+ *  \see index_sequence
+ *  \see make_integer_sequence
+ *  \see make_index_sequence
+ */
+template <typename T, T Value, typename Sequence>
+using integer_sequence_push_back =
+  typename detail::integer_sequence_push_back_impl<T, Value, Sequence>::type;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T, std::size_t N>
+struct make_reversed_integer_sequence_impl
+{
+  using type = merge_and_renumber_reversed_integer_sequences<
+      make_reversed_integer_sequence<T, N / 2>
+    , make_reversed_integer_sequence<T, N - N / 2>
+  >;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+struct make_reversed_integer_sequence_impl<T, 0>
+{
+  using type = integer_sequence<T>;
+};
+
+template <typename T>
+struct make_reversed_integer_sequence_impl<T, 1>
+{
+  using type = integer_sequence<T, 0>;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, T I0, T... Is>
+struct integer_sequence_push_front_impl<T, I0, integer_sequence<T, Is...> >
+{
+  using type = integer_sequence<T, I0, Is...>;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, T I0, T... Is>
+struct integer_sequence_push_back_impl<T, I0, integer_sequence<T, Is...> >
+{
+  using type = integer_sequence<T, Is..., I0>;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/type_traits/is_contiguous_iterator.h b/miniCUDA124/include/thrust/type_traits/is_contiguous_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..959abc69597205bf7e35da0fbe9c4de8398b8dfc
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/is_contiguous_iterator.h
@@ -0,0 +1,303 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief An extensible type trait for determining if an iterator satisifies the
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousIterator">ContiguousIterator</a>
+ *  requirements (aka is pointer-like).
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && _MSC_VER < 1916 // MSVC 2017 version 15.9
+  #include <vector>
+  #include <string>
+  #include <array>
+
+  #if THRUST_CPP_DIALECT >= 2017
+    #include <string_view>
+  #endif
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename Iterator>
+struct is_contiguous_iterator_impl;
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c Iterator satisfies
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousIterator">ContiguousIterator</a>,
+ *  aka it points to elements that are contiguous in memory, and \c false_type
+ *  otherwise.
+ *
+ * \see is_contiguous_iterator_v
+ * \see proclaim_contiguous_iterator
+ * \see THRUST_PROCLAIM_CONTIGUOUS_ITERATOR
+ */
+template <typename Iterator>
+#if THRUST_CPP_DIALECT >= 2011
+using is_contiguous_iterator =
+#else
+struct is_contiguous_iterator :
+#endif
+  detail::is_contiguous_iterator_impl<Iterator>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c Iterator satisfies
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousIterator">ContiguousIterator</a>,
+ *  aka it points to elements that are contiguous in memory, and \c false
+ *  otherwise.
+ *
+ * \see is_contiguous_iterator
+ * \see proclaim_contiguous_iterator
+ * \see THRUST_PROCLAIM_CONTIGUOUS_ITERATOR
+ */
+template <typename Iterator>
+constexpr bool is_contiguous_iterator_v = is_contiguous_iterator<Iterator>::value;
+#endif
+
+/*! \brief Customization point that can be customized to indicate that an
+ *  iterator type \c Iterator satisfies
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousIterator">ContiguousIterator</a>,
+ *  aka it points to elements that are contiguous in memory.
+ *
+ * \see is_contiguous_iterator
+ * \see THRUST_PROCLAIM_CONTIGUOUS_ITERATOR
+ */
+template <typename Iterator>
+struct proclaim_contiguous_iterator : false_type {};
+
+/*! \brief Declares that the iterator \c Iterator is
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousIterator">ContiguousIterator</a>
+ *  by specializing \c proclaim_contiguous_iterator.
+ *
+ * \see is_contiguous_iterator
+ * \see proclaim_contiguous_iterator
+ */
+#define THRUST_PROCLAIM_CONTIGUOUS_ITERATOR(Iterator)                         \
+  THRUST_NAMESPACE_BEGIN                                                      \
+  template <>                                                                 \
+  struct proclaim_contiguous_iterator<Iterator>                               \
+      : THRUST_NS_QUALIFIER::true_type {};                                    \
+  THRUST_NAMESPACE_END                                                        \
+  /**/
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename Iterator>
+struct is_libcxx_wrap_iter : false_type {};
+
+#if defined(_LIBCPP_VERSION)
+template <typename Iterator>
+struct is_libcxx_wrap_iter<
+  _VSTD::__wrap_iter<Iterator>
+> : true_type {};
+#endif
+
+template <typename Iterator>
+struct is_libstdcxx_normal_iterator : false_type {};
+
+#if defined(__GLIBCXX__)
+template <typename Iterator, typename Container>
+struct is_libstdcxx_normal_iterator<
+  ::__gnu_cxx::__normal_iterator<Iterator, Container>
+> : true_type {};
+#endif
+
+#if   _MSC_VER >= 1916 // MSVC 2017 version 15.9.
+template <typename Iterator>
+struct is_msvc_contiguous_iterator
+  : is_pointer<::std::_Unwrapped_t<Iterator> > {};
+#elif _MSC_VER >= 1700 // MSVC 2012.
+template <typename Iterator>
+struct is_msvc_contiguous_iterator : false_type {};
+
+template <typename Vector>
+struct is_msvc_contiguous_iterator<
+  ::std::_Vector_const_iterator<Vector>
+> : true_type {};
+
+template <typename Vector>
+struct is_msvc_contiguous_iterator<
+  ::std::_Vector_iterator<Vector>
+> : true_type {};
+
+template <typename String>
+struct is_msvc_contiguous_iterator<
+  ::std::_String_const_iterator<String>
+> : true_type {};
+
+template <typename String>
+struct is_msvc_contiguous_iterator<
+  ::std::_String_iterator<String>
+> : true_type {};
+
+template <typename T, std::size_t N>
+struct is_msvc_contiguous_iterator<
+  ::std::_Array_const_iterator<T, N>
+> : true_type {};
+
+template <typename T, std::size_t N>
+struct is_msvc_contiguous_iterator<
+  ::std::_Array_iterator<T, N>
+> : true_type {};
+
+#if THRUST_CPP_DIALECT >= 2017
+template <typename Traits>
+struct is_msvc_contiguous_iterator<
+  ::std::_String_view_iterator<Traits>
+> : true_type {};
+#endif
+#else
+template <typename Iterator>
+struct is_msvc_contiguous_iterator : false_type {};
+#endif
+
+template <typename Iterator>
+struct is_contiguous_iterator_impl
+  : integral_constant<
+      bool
+    ,    is_pointer<Iterator>::value
+      || is_thrust_pointer<Iterator>::value
+      || is_libcxx_wrap_iter<Iterator>::value
+      || is_libstdcxx_normal_iterator<Iterator>::value
+      || is_msvc_contiguous_iterator<Iterator>::value
+      || proclaim_contiguous_iterator<Iterator>::value
+    >
+{};
+
+// Type traits for contiguous iterators:
+template <typename Iterator>
+struct contiguous_iterator_traits
+{
+  static_assert(thrust::is_contiguous_iterator<Iterator>::value,
+                "contiguous_iterator_traits requires a contiguous iterator.");
+
+  using raw_pointer = typename thrust::detail::pointer_traits<
+    decltype(&*std::declval<Iterator>())>::raw_pointer;
+};
+
+template <typename Iterator>
+using contiguous_iterator_raw_pointer_t =
+  typename contiguous_iterator_traits<Iterator>::raw_pointer;
+
+// Converts a contiguous iterator to a raw pointer:
+template <typename Iterator>
+__host__ __device__
+contiguous_iterator_raw_pointer_t<Iterator>
+contiguous_iterator_raw_pointer_cast(Iterator it)
+{
+  static_assert(thrust::is_contiguous_iterator<Iterator>::value,
+                "contiguous_iterator_raw_pointer_cast called with "
+                "non-contiguous iterator.");
+  return thrust::raw_pointer_cast(&*it);
+}
+
+// Implementation for non-contiguous iterators -- passthrough.
+template <typename Iterator,
+          bool IsContiguous = thrust::is_contiguous_iterator<Iterator>::value>
+struct try_unwrap_contiguous_iterator_impl
+{
+  using type = Iterator;
+
+  static __host__ __device__ type get(Iterator it) { return it; }
+};
+
+// Implementation for contiguous iterators -- unwraps to raw pointer.
+template <typename Iterator>
+struct try_unwrap_contiguous_iterator_impl<Iterator, true /*is_contiguous*/>
+{
+  using type = contiguous_iterator_raw_pointer_t<Iterator>;
+
+  static __host__ __device__ type get(Iterator it)
+  {
+    return contiguous_iterator_raw_pointer_cast(it);
+  }
+};
+
+template <typename Iterator>
+using try_unwrap_contiguous_iterator_return_t =
+  typename try_unwrap_contiguous_iterator_impl<Iterator>::type;
+
+// Casts to a raw pointer if iterator is marked as contiguous, otherwise returns
+// the input iterator.
+template <typename Iterator>
+__host__ __device__
+try_unwrap_contiguous_iterator_return_t<Iterator>
+try_unwrap_contiguous_iterator(Iterator it)
+{
+  return try_unwrap_contiguous_iterator_impl<Iterator>::get(it);
+}
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/type_traits/is_execution_policy.h b/miniCUDA124/include/thrust/type_traits/is_execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..cff75dc71f73e984fd4c369d1f5c43ff59220144
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/is_execution_policy.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A type trait that determines if a type is an \a ExecutionPolicy.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is an \a ExecutionPolicy and \c false_type
+ *  otherwise.
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_execution_policy =
+#else
+struct is_execution_policy :
+#endif
+  detail::is_base_of<detail::execution_policy_marker, T>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is an
+ *  \a ExecutionPolicy and \c false otherwise.
+ */
+template <typename T>
+constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
+#endif
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/type_traits/is_operator_less_or_greater_function_object.h b/miniCUDA124/include/thrust/type_traits/is_operator_less_or_greater_function_object.h
new file mode 100644
index 0000000000000000000000000000000000000000..075a7ebd9826e73410e5f1cd9c80a09bed89137f
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/is_operator_less_or_greater_function_object.h
@@ -0,0 +1,216 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Type traits for determining if a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  is equivalent to either \c operator< or \c operator>.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/functional.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T>
+struct is_operator_less_function_object_impl;
+
+template <typename T>
+struct is_operator_greater_function_object_impl;
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator<, and \c false_type otherwise.
+ *
+ *  \see is_operator_less_function_object_v
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_less_or_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_operator_less_function_object =
+#else
+struct is_operator_less_function_object :
+#endif
+  detail::is_operator_less_function_object_impl<T>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator<, and \c false otherwise.
+ *
+ *  \see is_operator_less_function_object
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_less_or_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+constexpr bool is_operator_less_function_object_v
+  = is_operator_less_function_object<T>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator>, and \c false_type otherwise.
+ *
+ *  \see is_operator_greater_function_object_v
+ *  \see is_operator_less_function_object
+ *  \see is_operator_less_or_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_operator_greater_function_object =
+#else
+struct is_operator_greater_function_object :
+#endif
+  detail::is_operator_greater_function_object_impl<T>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator>, and \c false otherwise.
+ *
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_less_function_object
+ *  \see is_operator_less_or_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+constexpr bool is_operator_greater_function_object_v
+  = is_operator_greater_function_object<T>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator< or \c operator>, and \c false_type otherwise.
+ *
+ *  \see is_operator_less_or_greater_function_object_v
+ *  \see is_operator_less_function_object
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_operator_less_or_greater_function_object =
+#else
+struct is_operator_less_or_greater_function_object :
+#endif
+  integral_constant<
+    bool
+  ,    detail::is_operator_less_function_object_impl<T>::value
+    || detail::is_operator_greater_function_object_impl<T>::value
+  >
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>
+ *  equivalent to \c operator< or \c operator>, and \c false otherwise.
+ *
+ *  \see is_operator_less_or_greater_function_object
+ *  \see is_operator_less_function_object
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_plus_function_object
+ */
+template <typename T>
+constexpr bool is_operator_less_or_greater_function_object_v
+  = is_operator_less_or_greater_function_object<T>::value;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T>
+struct is_operator_less_function_object_impl                   : false_type {};
+template <typename T>
+struct is_operator_less_function_object_impl<thrust::less<T> > : true_type {};
+template <typename T>
+struct is_operator_less_function_object_impl<std::less<T>    > : true_type {};
+
+template <typename T>
+struct is_operator_greater_function_object_impl                      : false_type {};
+template <typename T>
+struct is_operator_greater_function_object_impl<thrust::greater<T> > : true_type {};
+template <typename T>
+struct is_operator_greater_function_object_impl<std::greater<T>    > : true_type {};
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/type_traits/is_operator_plus_function_object.h b/miniCUDA124/include/thrust/type_traits/is_operator_plus_function_object.h
new file mode 100644
index 0000000000000000000000000000000000000000..24c6aa18f9a1800040bafd845a846cb0ff752441
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/is_operator_plus_function_object.h
@@ -0,0 +1,126 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Type traits for determining if a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/FunctionObject">FunctionObject</a>
+ *  is equivalent to \c operator+.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/functional.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T>
+struct is_operator_plus_function_object_impl;
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/FunctionObject">FunctionObject</a>
+ *  equivalent to \c operator+, and \c false_type otherwise.
+ *
+ *  \see is_operator_plus_function_object_v
+ *  \see is_operator_less_function_object
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_less_or_greater_function_object
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_operator_plus_function_object =
+#else
+struct is_operator_plus_function_object :
+#endif
+  detail::is_operator_plus_function_object_impl<T>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is a
+ *  <a href="https://en.cppreference.com/w/cpp/named_req/FunctionObject">FunctionObject</a>
+ *  equivalent to \c operator<, and \c false otherwise.
+ *
+ *  \see is_operator_plus_function_object
+ *  \see is_operator_less_function_object
+ *  \see is_operator_greater_function_object
+ *  \see is_operator_less_or_greater_function_object
+ */
+template <typename T>
+constexpr bool is_operator_plus_function_object_v
+  = is_operator_plus_function_object<T>::value;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T>
+struct is_operator_plus_function_object_impl                   : false_type {};
+template <typename T>
+struct is_operator_plus_function_object_impl<thrust::plus<T> > : true_type {};
+template <typename T>
+struct is_operator_plus_function_object_impl<std::plus<T>    > : true_type {};
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/type_traits/is_trivially_relocatable.h b/miniCUDA124/include/thrust/type_traits/is_trivially_relocatable.h
new file mode 100644
index 0000000000000000000000000000000000000000..0cc4efc01ee230d524f5b8145da9935a764143bd
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/is_trivially_relocatable.h
@@ -0,0 +1,374 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief <a href="https://wg21.link/P1144">P1144</a>'s proposed
+ *  \c std::is_trivially_relocatable, an extensible type trait indicating
+ *  whether a type can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <type_traits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T>
+struct is_trivially_relocatable_impl;
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that returns \c true_type if \c T is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  aka can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false_type otherwise.
+ *
+ * \see is_trivially_relocatable_v
+ * \see is_trivially_relocatable_to
+ * \see is_indirectly_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename T>
+#if THRUST_CPP_DIALECT >= 2011
+using is_trivially_relocatable =
+#else
+struct is_trivially_relocatable :
+#endif
+  detail::is_trivially_relocatable_impl<T>
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c T is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  aka can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false otherwise.
+ *
+ * \see is_trivially_relocatable
+ * \see is_trivially_relocatable_to
+ * \see is_indirectly_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename T>
+constexpr bool is_trivially_relocatable_v = is_trivially_relocatable<T>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/BinaryTypeTrait"><i>BinaryTypeTrait</i></a>
+ *  that returns \c true_type if \c From is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  to \c To, aka can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false_type otherwise.
+ *
+ * \see is_trivially_relocatable_to_v
+ * \see is_trivially_relocatable
+ * \see is_indirectly_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename From, typename To>
+#if THRUST_CPP_DIALECT >= 2011
+using is_trivially_relocatable_to =
+#else
+struct is_trivially_relocatable_to :
+#endif
+  integral_constant<
+    bool
+  , detail::is_same<From, To>::value && is_trivially_relocatable<To>::value
+  >
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if \c From is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  to \c To, aka can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false otherwise.
+ *
+ * \see is_trivially_relocatable_to
+ * \see is_trivially_relocatable
+ * \see is_indirectly_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename From, typename To>
+constexpr bool is_trivially_relocatable_to_v
+  = is_trivially_relocatable_to<From, To>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/BinaryTypeTrait"><i>BinaryTypeTrait</i></a>
+ *  that returns \c true_type if the element type of \c FromIterator is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  to the element type of \c ToIterator, aka can be bitwise copied with a
+ *  facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false_type otherwise.
+ *
+ * \see is_indirectly_trivially_relocatable_to_v
+ * \see is_trivially_relocatable
+ * \see is_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename FromIterator, typename ToIterator>
+#if THRUST_CPP_DIALECT >= 2011
+using is_indirectly_trivially_relocatable_to =
+#else
+struct is_indirectly_trivially_relocatable_to :
+#endif
+  integral_constant<
+    bool
+  ,    is_contiguous_iterator<FromIterator>::value
+    && is_contiguous_iterator<ToIterator>::value
+    && is_trivially_relocatable_to<
+         typename thrust::iterator_traits<FromIterator>::value_type,
+         typename thrust::iterator_traits<ToIterator>::value_type
+       >::value
+  >
+#if THRUST_CPP_DIALECT < 2011
+{}
+#endif
+;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> that is \c true if the element type of
+ *  \c FromIterator is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  to the element type of \c ToIterator, aka can be bitwise copied with a
+ *  facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  and \c false otherwise.
+ *
+ * \see is_indirectly_trivially_relocatable_to
+ * \see is_trivially_relocatable
+ * \see is_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename FromIterator, typename ToIterator>
+constexpr bool is_indirectly_trivially_relocate_to_v
+  = is_indirectly_trivially_relocatable_to<FromIterator, ToIterator>::value;
+#endif
+
+/*! \brief <a href="http://eel.is/c++draft/namespace.std#def:customization_point"><i>customization point</i></a>
+ *  that can be specialized customized to indicate that a type \c T is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  aka it can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>.
+ *
+ * \see is_indirectly_trivially_relocatable_to
+ * \see is_trivially_relocatable
+ * \see is_trivially_relocatable_to
+ * \see THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE
+ */
+template <typename T>
+struct proclaim_trivially_relocatable : false_type {};
+
+/*! \brief Declares that the type \c T is
+ *  <a href="https://wg21.link/P1144"><i>TriviallyRelocatable</i></a>,
+ *  aka it can be bitwise copied with a facility like
+ *  <a href="https://en.cppreference.com/w/cpp/string/byte/memcpy"><tt>std::memcpy</tt></a>,
+ *  by specializing \c proclaim_trivially_relocatable.
+ *
+ * \see is_indirectly_trivially_relocatable_to
+ * \see is_trivially_relocatable
+ * \see is_trivially_relocatable_to
+ * \see proclaim_trivially_relocatable
+ */
+#define THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(T)                              \
+  THRUST_NAMESPACE_BEGIN                                                      \
+  template <>                                                                 \
+  struct proclaim_trivially_relocatable<T> : THRUST_NS_QUALIFIER::true_type   \
+  {};                                                                         \
+  THRUST_NAMESPACE_END                                                        \
+  /**/
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+// There is no way to actually detect the libstdc++ version; __GLIBCXX__
+// is always set to the date of libstdc++ being packaged, not the release
+// day or version. This means that we can't detect the libstdc++ version,
+// except when compiling with GCC.
+//
+// Therefore, for the best approximation of is_trivially_copyable, we need to
+// handle three distinct cases:
+// 1) GCC above 5, or another C++11 compiler not using libstdc++: use the
+//      standard trait directly.
+// 2) A C++11 compiler using libstdc++ that provides the intrinsic: use the
+//      intrinsic.
+// 3) Any other case (essentially: compiling without C++11): has_trivial_assign.
+
+#ifndef __has_feature
+    #define __has_feature(x) 0
+#endif
+
+template <typename T>
+struct is_trivially_copyable_impl
+    : integral_constant<
+        bool,
+        #if THRUST_CPP_DIALECT >= 2011
+            #if defined(__GLIBCXX__) && __has_feature(is_trivially_copyable)
+                __is_trivially_copyable(T)
+            #elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC && THRUST_GCC_VERSION >= 50000
+                std::is_trivially_copyable<T>::value
+            #else
+                has_trivial_assign<T>::value
+            #endif
+        #else
+            has_trivial_assign<T>::value
+        #endif
+    >
+{
+};
+
+// https://wg21.link/P1144R0#wording-inheritance
+template <typename T>
+struct is_trivially_relocatable_impl
+    : integral_constant<
+        bool,
+        is_trivially_copyable_impl<T>::value
+            || proclaim_trivially_relocatable<T>::value
+    >
+{};
+
+template <typename T, std::size_t N>
+struct is_trivially_relocatable_impl<T[N]> : is_trivially_relocatable_impl<T> {};
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(char1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(char2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(char3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(char4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uchar1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uchar2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uchar3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uchar4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(short1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(short2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(short3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(short4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ushort1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ushort2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ushort3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ushort4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(int1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(int2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(int3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(int4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uint1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uint2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uint3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(uint4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(long1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(long2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(long3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(long4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulong1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulong2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulong3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulong4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(longlong1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(longlong2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(longlong3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(longlong4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulonglong1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulonglong2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulonglong3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(ulonglong4)
+
+struct __half;
+struct __half2;
+
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(__half)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(__half2)
+
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(float1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(float2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(float3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(float4)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(double1)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(double2)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(double3)
+THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(double4)
+#endif
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
diff --git a/miniCUDA124/include/thrust/type_traits/logical_metafunctions.h b/miniCUDA124/include/thrust/type_traits/logical_metafunctions.h
new file mode 100644
index 0000000000000000000000000000000000000000..e362f5e9dda2e0192c15d303ec03e7f1f8628f01
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/logical_metafunctions.h
@@ -0,0 +1,295 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief C++17's
+ *  <a href="https://en.cppreference.com/w/cpp/types/conjunction"><tt>std::conjunction</tt></a>,
+ *  <a href="https://en.cppreference.com/w/cpp/types/disjunction"><tt>std::disjunction</tt></a>,
+ *  and <a href="https://en.cppreference.com/w/cpp/types/negation"><tt>std::negation</tt></a>
+ *  metafunctions and related extensions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>(... && Ts::value)</tt>.
+ *
+ *  \see conjunction_v
+ *  \see conjunction_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/conjunction"><tt>std::conjunction</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2017
+template <typename... Ts>
+using conjunction = std::conjunction<Ts...>;
+#else // Older than C++17.
+template <typename... Ts>
+struct conjunction;
+
+/*! \cond
+ */
+
+template <>
+struct conjunction<> : std::true_type {};
+
+template <typename T>
+struct conjunction<T> : T {};
+
+template <typename T0, typename T1>
+struct conjunction<T0, T1> : std::conditional<T0::value, T1, T0>::type {};
+
+template<typename T0, typename T1, typename T2, typename... TN>
+struct conjunction<T0, T1, T2, TN...>
+  : std::conditional<T0::value, conjunction<T1, T2, TN...>, T0>::type {};
+
+/*! \endcond
+ */
+#endif
+
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>(... && Ts::value)</tt>.
+ *
+ *  \see conjunction
+ *  \see conjunction_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/conjunction"><tt>std::conjunction</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <typename... Ts>
+constexpr bool conjunction_v = conjunction<Ts...>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>(... || Ts::value)</tt>.
+ *
+ *  \see disjunction_v
+ *  \see disjunction_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/disjunction"><tt>std::disjunction</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2017
+template <typename... Ts>
+using disjunction = std::disjunction<Ts...>;
+#else // Older than C++17.
+template <typename... Ts>
+struct disjunction;
+
+/*! \cond
+ */
+
+template <>
+struct disjunction<> : std::false_type {};
+
+template <typename T>
+struct disjunction<T> : T {};
+
+template <typename T0, typename... TN>
+struct disjunction<T0, TN...>
+  : std::conditional<T0::value != false, T0, disjunction<TN...> >::type {};
+
+/*! \endcond
+ */
+#endif
+
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>(... || Ts::value)</tt>.
+ *
+ *  \see disjunction
+ *  \see disjunction_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/disjunction"><tt>std::disjunction</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <typename... Ts>
+constexpr bool disjunction_v = disjunction<Ts...>::value;
+#endif
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>!Ts::value</tt>.
+ *
+ *  \see negation_v
+ *  \see negation_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/negation"><tt>std::negation</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2017
+template <typename T>
+using negation = std::negation<T>;
+#else // Older than C++17.
+template <typename T>
+struct negation;
+
+/*! \cond
+ */
+
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+/*! \endcond
+ */
+#endif
+
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>!Ts::value</tt>.
+ *
+ *  \see negation
+ *  \see negation_value
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/negation"><tt>std::negation</tt></a>
+ */
+#if THRUST_CPP_DIALECT >= 2014
+template <typename T>
+constexpr bool negation_v = negation<T>::value;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>(... && Bs)</tt>.
+ *
+ *  \see conjunction_value_v
+ *  \see conjunction
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/conjunction"><tt>std::conjunction</tt></a>
+ */
+template <bool... Bs>
+struct conjunction_value;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>(... && Bs)</tt>.
+ *
+ *  \see conjunction_value
+ *  \see conjunction
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/conjunction"><tt>std::conjunction</tt></a>
+ */
+template <bool... Bs>
+constexpr bool conjunction_value_v = conjunction_value<Bs...>::value;
+#endif
+
+/*! \cond
+ */
+
+template <>
+struct conjunction_value<> : std::true_type {};
+
+template <bool B>
+struct conjunction_value<B> : std::integral_constant<bool, B> {};
+
+template <bool B, bool... Bs>
+struct conjunction_value<B, Bs...>
+  : std::integral_constant<bool, B && conjunction_value<Bs...>::value> {};
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>(... || Bs)</tt>.
+ *
+ *  \see disjunction_value_v
+ *  \see disjunction
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/disjunction"><tt>std::disjunction</tt></a>
+ */
+template <bool... Bs>
+struct disjunction_value;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>(... || Bs)</tt>.
+ *
+ *  \see disjunction_value
+ *  \see disjunction
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/disjunction"><tt>std::disjunction</tt></a>
+ */
+template <bool... Bs>
+constexpr bool disjunction_value_v = disjunction_value<Bs...>::value;
+#endif
+
+/*! \cond
+ */
+
+template <>
+struct disjunction_value<> : std::false_type {};
+
+template <bool B>
+struct disjunction_value<B> : std::integral_constant<bool, B> {};
+
+template <bool B, bool... Bs>
+struct disjunction_value<B, Bs...>
+  : std::integral_constant<bool, B || disjunction_value<Bs...>::value> {};
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/types/integral_constant"><tt>std::integral_constant</tt></a>
+ *  whose value is <tt>!Bs</tt>.
+ *
+ *  \see negation_value_v
+ *  \see negation
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/negation"><tt>std::negation</tt></a>
+ */
+template <bool B>
+struct negation_value;
+
+#if THRUST_CPP_DIALECT >= 2014
+/*! \brief <tt>constexpr bool</tt> whose value is <tt>!Ts::value</tt>.
+ *
+ *  \see negation_value
+ *  \see negation
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/negation"><tt>std::negation</tt></a>
+ */
+template <bool B>
+constexpr bool negation_value_v = negation_value<B>::value;
+#endif
+
+/*! \cond
+ */
+
+template <bool B>
+struct negation_value : std::integral_constant<bool, !B> {};
+
+/*! \endcond
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniCUDA124/include/thrust/type_traits/remove_cvref.h b/miniCUDA124/include/thrust/type_traits/remove_cvref.h
new file mode 100644
index 0000000000000000000000000000000000000000..f157670aa4e56ba3638e0b3d4d247c8b878dec45
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/remove_cvref.h
@@ -0,0 +1,105 @@
+/*
+ *  Copyright 2018-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief C++20's
+ *  <a href="https://en.cppreference.com/w/cpp/types/remove_cvref">std::remove_cvref</a>.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#if  THRUST_CPP_DIALECT >= 2017
+#if __has_include(<version>)
+#  include <version>
+#endif
+#endif
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+/*! \brief <a href="https://en.cppreference.com/w/cpp/named_req/UnaryTypeTrait"><i>UnaryTypeTrait</i></a>
+ *  that removes
+ *  <a href="https://en.cppreference.com/w/cpp/language/cv">const-volatile qualifiers</a>
+ *  and
+ *  <a href="https://en.cppreference.com/w/cpp/language/reference">references</a>
+ *  from \c T.
+ *  Equivalent to \c remove_cv_t<remove_reference_t<T>>.
+ *
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cvref">std::remove_cvref</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_cv</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_const</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_volatile</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_reference</a>
+ */
+#if defined(__cpp_lib_remove_cvref) && (__cpp_lib_remove_cvref >= 201711L)
+using std::remove_cvref;
+#else // Older than C++20.
+template <typename T>
+struct remove_cvref
+{
+  using type = typename std::remove_cv<
+    typename std::remove_reference<T>::type
+  >::type;
+};
+#endif
+
+/*! \brief Type alias that removes
+ *  <a href="https://en.cppreference.com/w/cpp/language/cv">const-volatile qualifiers</a>
+ *  and
+ *  <a href="https://en.cppreference.com/w/cpp/language/reference">references</a>
+ *  from \c T.
+ *  Equivalent to \c remove_cv_t<remove_reference_t<T>>.
+ *
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cvref">std::remove_cvref</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_cv</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_const</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_volatile</a>
+ *  \see <a href="https://en.cppreference.com/w/cpp/types/remove_cv">std::remove_reference</a>
+ */
+#if defined(__cpp_lib_remove_cvref) && (__cpp_lib_remove_cvref >= 201711L)
+using std::remove_cvref_t;
+#else // Older than C++20.
+template <typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+#endif
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniCUDA124/include/thrust/type_traits/void_t.h b/miniCUDA124/include/thrust/type_traits/void_t.h
new file mode 100644
index 0000000000000000000000000000000000000000..d177f97b94c5379fdc6e27f14202e9748a71d1c3
--- /dev/null
+++ b/miniCUDA124/include/thrust/type_traits/void_t.h
@@ -0,0 +1,85 @@
+/*
+ *  Copyright 2018-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief C++17's `void_t`.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.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
+
+#if THRUST_CPP_DIALECT >= 2017
+#  include <type_traits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup type_traits Type Traits
+ *  \{
+ */
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template <typename...> struct voider { using type = void; };
+
+#if THRUST_CPP_DIALECT >= 2017
+using std::void_t;
+#else
+template <typename... Ts> using void_t = typename voider<Ts...>::type;
+#endif
+
+#else // Older than C++11.
+
+template <
+  typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+, typename = void
+>
+struct voider
+{
+  typedef void type;
+};
+
+#endif
+
+/*! \} // type traits
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+