diff --git a/.gitattributes b/.gitattributes
index c0b29e7f56361ff9f392272ddc0c2b490013015c..ffdb50485e44c1b0d3bad8d9b0878c73b4fd14e2 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1769,3 +1769,4 @@ vllm/lib/python3.10/site-packages/cupy/_core/flags.cpython-310-x86_64-linux-gnu.
 vllm/lib/python3.10/site-packages/cupy/_core/_accelerator.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/cupy/_core/_fusion_kernel.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/libcrypto.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/libcrypto.a filter=lfs diff=lfs merge=lfs -text
diff --git a/vllm/lib/libcrypto.a b/vllm/lib/libcrypto.a
new file mode 100644
index 0000000000000000000000000000000000000000..ca3c8ee148a475b9bf722d9dc8bc39201c246cbb
--- /dev/null
+++ b/vllm/lib/libcrypto.a
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a24a0e923980a3ecf86ea44854f64a05ff75ed5b1e4ee1ebbbb8a043073a1b1
+size 11086938
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/algorithm_wrapper.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/algorithm_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..c732e106c1df71b294ecde2f2696c330724b5daa
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/algorithm_wrapper.h
@@ -0,0 +1,37 @@
+/*
+ *  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.
+ */
+
+#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
+
+// When a compiler uses Thrust as part of its implementation of Standard C++
+// algorithms, a cycle of included files may result when Thrust code tries to
+// use a standard algorithm.  Having a macro that is defined only when Thrust
+// is including an algorithms-related header gives the compiler a chance to
+// detect and break the cycle of includes.
+
+#define THRUST_INCLUDING_ALGORITHMS_HEADER
+#include <algorithm>
+#undef THRUST_INCLUDING_ALGORITHMS_HEADER
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a87333c2267aeb185c1f4e1b6c86026e9bbe124
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.h
@@ -0,0 +1,350 @@
+/*
+ *  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/memory_wrapper.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/pointer_traits.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
+{
+  using yes_type = char;
+  using no_type  = int;
+
+  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);
+
+  using type = thrust::detail::integral_constant<bool, value>;
+};
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+
+// The following fields of std::allocator have been deprecated (since C++17).
+// There's no way to detect it other than explicit specialization.
+#if _CCCL_STD_VER >= 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
+{
+  using type = typename T::pointer;
+};
+
+template <typename T>
+struct nested_const_pointer
+{
+  using type = typename T::const_pointer;
+};
+
+template <typename T>
+struct nested_reference
+{
+  using type = typename T::reference;
+};
+
+template <typename T>
+struct nested_const_reference
+{
+  using type = typename T::const_reference;
+};
+
+template <typename T>
+struct nested_void_pointer
+{
+  using type = typename T::void_pointer;
+};
+
+template <typename T>
+struct nested_const_void_pointer
+{
+  using type = typename T::const_void_pointer;
+};
+
+template <typename T>
+struct nested_difference_type
+{
+  using type = typename T::difference_type;
+};
+
+template <typename T>
+struct nested_size_type
+{
+  using type = typename T::size_type;
+};
+
+template <typename T>
+struct nested_propagate_on_container_copy_assignment
+{
+  using type = typename T::propagate_on_container_copy_assignment;
+};
+
+template <typename T>
+struct nested_propagate_on_container_move_assignment
+{
+  using type = typename T::propagate_on_container_move_assignment;
+};
+
+template <typename T>
+struct nested_propagate_on_container_swap
+{
+  using type = typename T::propagate_on_container_swap;
+};
+
+template <typename T>
+struct nested_is_always_equal
+{
+  using type = typename T::is_always_equal;
+};
+
+template <typename T>
+struct nested_system_type
+{
+  using type = typename T::system_type;
+};
+
+template <typename Alloc>
+struct has_member_system
+{
+  using system_type = typename allocator_system<Alloc>::type;
+
+  using type              = typename has_member_system_impl<Alloc, system_type&()>::type;
+  static const bool value = type::value;
+};
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+template <class Alloc, class U, bool = has_rebind<Alloc, U>::value>
+struct rebind_alloc
+{
+  using type = typename Alloc::template rebind<U>::other;
+};
+
+template <template <typename, typename...> class Alloc, typename T, typename... Args, typename U>
+struct rebind_alloc<Alloc<T, Args...>, U, true>
+{
+  using type = typename Alloc<T, Args...>::template rebind<U>::other;
+};
+
+template <template <typename, typename...> class Alloc, typename T, typename... Args, typename U>
+struct rebind_alloc<Alloc<T, Args...>, U, false>
+{
+  using type = Alloc<U, Args...>;
+};
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc>
+struct allocator_traits
+{
+  using allocator_type = Alloc;
+
+  using value_type = typename allocator_type::value_type;
+
+  using pointer = typename eval_if<allocator_traits_detail::has_pointer<allocator_type>::value,
+                                   allocator_traits_detail::nested_pointer<allocator_type>,
+                                   identity_<value_type*>>::type;
+
+private:
+  template <typename T>
+  struct rebind_pointer
+  {
+    using type = typename pointer_traits<pointer>::template rebind<T>::other;
+  };
+
+public:
+  using const_pointer =
+    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;
+
+  using void_pointer =
+    typename eval_if<allocator_traits_detail::has_void_pointer<allocator_type>::value,
+                     allocator_traits_detail::nested_void_pointer<allocator_type>,
+                     rebind_pointer<void>>::type;
+
+  using const_void_pointer =
+    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;
+
+  using difference_type =
+    typename eval_if<allocator_traits_detail::has_difference_type<allocator_type>::value,
+                     allocator_traits_detail::nested_difference_type<allocator_type>,
+                     pointer_difference<pointer>>::type;
+
+  using size_type = typename eval_if<allocator_traits_detail::has_size_type<allocator_type>::value,
+                                     allocator_traits_detail::nested_size_type<allocator_type>,
+                                     ::cuda::std::make_unsigned<difference_type>>::type;
+
+  using propagate_on_container_copy_assignment =
+    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;
+
+  using propagate_on_container_move_assignment =
+    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;
+
+  using propagate_on_container_swap =
+    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;
+
+  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>,
+                     ::cuda::std::is_empty<allocator_type>>::type;
+
+  using system_type =
+    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;
+
+  // XXX rebind and rebind_traits are alias templates
+  //     and so are omitted while c++11 is unavailable
+
+  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;
+
+  // Deprecated std::allocator aliases that we need:
+  using reference       = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  inline _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n);
+
+  inline _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
+
+  inline _CCCL_HOST_DEVICE static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
+
+  // XXX should probably change T* to pointer below and then relax later
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p);
+
+  template <typename T, typename Arg1>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p, const Arg1& arg1);
+
+  template <typename T, typename... Args>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p, Args&&... args);
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE static void destroy(allocator_type& a, T* p) noexcept;
+
+  inline _CCCL_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 alias
+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
+  using type = 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;
+
+  // the type that get returns
+  using get_result_type =
+    typename eval_if<allocator_traits_detail::has_member_system<Alloc>::value,
+                     ::cuda::std::add_lvalue_reference<type>,
+                     identity_<type>>::type;
+
+  _CCCL_HOST_DEVICE inline static get_result_type get(Alloc& a);
+};
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/allocator_traits.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f786f69c885e2436d86fb3363d6db3db3f4da105
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.inl
@@ -0,0 +1,370 @@
+/*
+ *  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/integer_traits.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/detail/type_traits/is_call_possible.h>
+
+#include <new>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// 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>,
+                     ::cuda::std::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>>;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n)
+  {
+    return superclass::allocate(a, n);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint)
+  {
+    return superclass::allocate(a, n, hint);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static void deallocate(allocator_type& a, pointer p, size_type n) noexcept
+  {
+    superclass::deallocate(a, p, n);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename U, typename... Args>
+  _CCCL_HOST_DEVICE static void construct(allocator_type& a, U* p, Args&&... args)
+  {
+    superclass::construct(a, p, THRUST_FWD(args)...);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename U>
+  _CCCL_HOST_DEVICE static void destroy(allocator_type& a, U* p) noexcept
+  {
+    superclass::destroy(a, p);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static size_type max_size(const allocator_type& a)
+  {
+    return superclass::max_size(a);
+  }
+};
+
+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
+{
+  using pointer            = typename allocator_traits<Alloc>::pointer;
+  using size_type          = typename allocator_traits<Alloc>::size_type;
+  using const_void_pointer = typename allocator_traits<Alloc>::const_void_pointer;
+
+public:
+  using type = typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type, const_void_pointer)>::type;
+  static const bool value = type::value;
+};
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_allocate_with_hint<Alloc>::value,
+                                           typename allocator_traits<Alloc>::pointer>
+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>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_allocate_with_hint<Alloc>::value,
+                                           typename allocator_traits<Alloc>::pointer>
+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*)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_construct1<Alloc, T>::value> construct(Alloc& a, T* p)
+{
+  a.construct(p);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_construct1<Alloc, T>::value> 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&)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename Arg1>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_construct2<Alloc, T, Arg1>::value>
+construct(Alloc& a, T* p, const Arg1& arg1)
+{
+  a.construct(p, arg1);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename Arg1>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_construct2<Alloc, T, Arg1>::value>
+construct(Alloc&, T* p, const Arg1& arg1)
+{
+  ::new (static_cast<void*>(p)) T(arg1);
+}
+
+__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...)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename... Args>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_constructN<Alloc, T, Args...>::value>
+construct(Alloc& a, T* p, Args&&... args)
+{
+  a.construct(p, THRUST_FWD(args)...);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename... Args>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_constructN<Alloc, T, Args...>::value>
+construct(Alloc&, T* p, Args&&... args)
+{
+  ::new (static_cast<void*>(p)) T(THRUST_FWD(args)...);
+}
+
+__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*)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_destroy<Alloc, T>::value> destroy(Alloc& a, T* p)
+{
+  a.destroy(p);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_destroy<Alloc, T>::value> 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
+{
+  using size_type = typename allocator_traits<Alloc>::size_type;
+
+public:
+  using type              = typename has_member_max_size_impl<Alloc, size_type()>::type;
+  static const bool value = type::value;
+};
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_max_size<Alloc>::value, typename allocator_traits<Alloc>::size_type>
+max_size(const Alloc& a)
+{
+  return a.max_size();
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_max_size<Alloc>::value,
+                                           typename allocator_traits<Alloc>::size_type>
+max_size(const Alloc&)
+{
+  using size_type = typename allocator_traits<Alloc>::size_type;
+  return thrust::detail::integer_traits<size_type>::const_max;
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_system<Alloc>::value, typename allocator_system<Alloc>::type&>
+system(Alloc& a)
+{
+  // return the allocator's system
+  return a.system();
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_system<Alloc>::value, typename allocator_system<Alloc>::type>
+system(Alloc&)
+{
+  // return a copy of a value-initialized system
+  return typename allocator_system<Alloc>::type();
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE typename allocator_traits<Alloc>::pointer
+allocator_traits<Alloc>::allocate(Alloc& a, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    _CCCL_EXEC_CHECK_DISABLE
+    static _CCCL_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>
+_CCCL_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>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::deallocate(
+  Alloc& a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n) noexcept
+{
+  struct workaround_warnings
+  {
+    _CCCL_EXEC_CHECK_DISABLE
+    static _CCCL_HOST_DEVICE void deallocate(
+      Alloc& a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n) noexcept
+    {
+      return a.deallocate(p, n);
+    }
+  };
+
+  return workaround_warnings::deallocate(a, p, n);
+}
+
+template <typename Alloc>
+template <typename T>
+_CCCL_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>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::construct(allocator_type& a, T* p, const Arg1& arg1)
+{
+  return allocator_traits_detail::construct(a, p, arg1);
+}
+
+template <typename Alloc>
+template <typename T, typename... Args>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::construct(allocator_type& a, T* p, Args&&... args)
+{
+  return allocator_traits_detail::construct(a, p, THRUST_FWD(args)...);
+}
+
+template <typename Alloc>
+template <typename T>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::destroy(allocator_type& a, T* p) noexcept
+{
+  return allocator_traits_detail::destroy(a, p);
+}
+
+template <typename Alloc>
+_CCCL_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>
+_CCCL_HOST_DEVICE typename allocator_system<Alloc>::get_result_type allocator_system<Alloc>::get(Alloc& a)
+{
+  return allocator_traits_detail::system(a);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8ef16c5f4ee5f75377fb74fcd7e1ba807de2ef4
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.h
@@ -0,0 +1,45 @@
+/*
+ *  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>
+_CCCL_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>
+_CCCL_HOST_DEVICE Pointer copy_construct_range_n(
+  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, Size n, Pointer result);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..42dd32f045ea34e62b01714a684a7700db0c3b2c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.inl
@@ -0,0 +1,242 @@
+/*
+ *  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/advance.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/distance.h>
+#include <thrust/for_each.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+template <typename Allocator, typename InputType, typename OutputType>
+struct copy_construct_with_allocator
+{
+  Allocator& a;
+
+  _CCCL_HOST_DEVICE copy_construct_with_allocator(Allocator& a)
+      : a(a)
+  {}
+
+  template <typename Tuple>
+  inline _CCCL_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
+                         || !::cuda::std::is_trivially_copy_constructible<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, !::cuda::std::is_trivially_copy_constructible<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>
+_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> 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
+  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
+  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
+
+  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
+  using InputType  = typename iterator_traits<InputIterator>::value_type;
+  using OutputType = typename iterator_traits<Pointer>::value_type;
+
+  // 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>
+_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> 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
+  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
+  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first, result));
+
+  // create a functor
+  using InputType  = typename iterator_traits<InputIterator>::value_type;
+  using OutputType = typename iterator_traits<Pointer>::value_type;
+
+  // 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>
+_CCCL_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>
+_CCCL_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>
+_CCCL_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>
+_CCCL_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>
+_CCCL_HOST_DEVICE ::cuda::std::
+  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
+  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>
+_CCCL_HOST_DEVICE ::cuda::std::
+  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
+  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);
+}
+
+} // namespace allocator_traits_detail
+
+template <typename System, typename Allocator, typename InputIterator, typename Pointer>
+_CCCL_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>
+_CCCL_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);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d7d43a4720cdcb89cbcac79b5311673b9cf03d9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.h
@@ -0,0 +1,39 @@
+/*
+ *  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>
+_CCCL_HOST_DEVICE inline void destroy_range(Allocator& a, Pointer p, Size n) noexcept;
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/destroy_range.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e6ad2204b169a4b098e9ad1a1cc2913d4e3f1ead
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.inl
@@ -0,0 +1,137 @@
+/*
+ *  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/allocator_traits.h>
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.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
+    : ::cuda::std::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
+    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
+                             && !::cuda::std::is_trivially_destructible<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
+    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
+                             && ::cuda::std::is_trivially_destructible<typename pointer_element<Pointer>::type>::value>
+{};
+
+template <typename Allocator>
+struct destroy_via_allocator
+{
+  Allocator& a;
+
+  _CCCL_HOST_DEVICE destroy_via_allocator(Allocator& a) noexcept
+      : a(a)
+  {}
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+// destroy_range case 1: destroy via allocator
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case1<Allocator, Pointer>::type
+destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+// we must prepare for His coming
+struct gozer
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case2<Allocator, Pointer>::type
+destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  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>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case3<Allocator, Pointer>::type
+destroy_range(Allocator&, Pointer, Size) noexcept
+{
+  // no op
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE void destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  return allocator_traits_detail::destroy_range(a, p, n);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..94943c861f92a24996d11a9fe14652695c4b0e06
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.h
@@ -0,0 +1,39 @@
+/*
+ *  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, typename T>
+_CCCL_HOST_DEVICE inline void fill_construct_range(Allocator& a, Pointer p, Size n, const T& value);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/fill_construct_range.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f888c0a1c0b5c9b730c387cec32d6ae46390cd68
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.inl
@@ -0,0 +1,99 @@
+/*
+ *  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/memory_wrapper.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
+{
+
+// fill_construct_range has 2 cases:
+// if Allocator has an effectful member function construct:
+//   1. construct via the allocator
+// else
+//   2. construct via uninitialized_fill
+
+template <typename Allocator, typename T, typename Arg1>
+struct has_effectful_member_construct2 : has_member_construct2<Allocator, T, Arg1>
+{};
+
+// std::allocator::construct's only effect is to invoke placement new
+template <typename U, typename T, typename Arg1>
+struct has_effectful_member_construct2<std::allocator<U>, T, Arg1> : thrust::detail::false_type
+{};
+
+template <typename Allocator, typename Arg1>
+struct construct2_via_allocator
+{
+  Allocator& a;
+  Arg1 arg;
+
+  _CCCL_HOST_DEVICE construct2_via_allocator(Allocator& a, const Arg1& arg)
+      : a(a)
+      , arg(arg)
+  {}
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x)
+  {
+    allocator_traits<Allocator>::construct(a, &x, arg);
+  }
+};
+
+template <typename Allocator, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
+fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct2_via_allocator<Allocator, T>(a, value));
+}
+
+template <typename Allocator, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  !has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
+fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, value);
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE void fill_construct_range(Alloc& a, Pointer p, Size n, const T& value)
+{
+  return allocator_traits_detail::fill_construct_range(a, p, n, value);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0896c18dd4f00282be2c6448b1ea1e882f5f174
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.h
@@ -0,0 +1,53 @@
+/*
+ *  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/tagged_allocator.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System, typename Pointer>
+class malloc_allocator : public thrust::detail::tagged_allocator<T, System, Pointer>
+{
+private:
+  using super_t = thrust::detail::tagged_allocator<T, System, Pointer>;
+
+public:
+  using pointer   = typename super_t::pointer;
+  using size_type = typename super_t::size_type;
+
+  pointer allocate(size_type cnt);
+
+  void deallocate(pointer p, size_type n) noexcept;
+};
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/malloc_allocator.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..91eda7b4cc7907b815393043a41bcd6bf310a056
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.inl
@@ -0,0 +1,68 @@
+/*
+ *  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/malloc_allocator.h>
+#include <thrust/detail/malloc_and_free.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/detail/bad_alloc.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System, typename Pointer>
+typename malloc_allocator<T, System, Pointer>::pointer
+malloc_allocator<T, System, Pointer>::allocate(typename malloc_allocator<T, System, Pointer>::size_type cnt)
+{
+  using thrust::system::detail::generic::select_system;
+
+  // XXX should use a hypothetical thrust::static_pointer_cast here
+  System system;
+
+  pointer result = thrust::malloc<T>(select_system(system), cnt);
+
+  if (result.get() == 0)
+  {
+    throw thrust::system::detail::bad_alloc("malloc_allocator::allocate: malloc failed");
+  } // end if
+
+  return result;
+} // end malloc_allocator::allocate()
+
+template <typename T, typename System, typename Pointer>
+void malloc_allocator<T, System, Pointer>::deallocate(typename malloc_allocator<T, System, Pointer>::pointer p,
+                                                      typename malloc_allocator<T, System, Pointer>::size_type) noexcept
+{
+  using thrust::system::detail::generic::select_system;
+
+  System system;
+  thrust::free(select_system(system), p);
+} // end malloc_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/no_throw_allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/no_throw_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..87c3f3cca81ea940ff80d6089b8301d18b41d2ca
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/no_throw_allocator.h
@@ -0,0 +1,76 @@
+/*
+ *  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 <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename BaseAllocator>
+struct no_throw_allocator : BaseAllocator
+{
+private:
+  using super_t = BaseAllocator;
+
+public:
+  inline _CCCL_HOST_DEVICE no_throw_allocator(const BaseAllocator& other = BaseAllocator())
+      : super_t(other)
+  {}
+
+  template <typename U>
+  struct rebind
+  {
+    using other = no_throw_allocator<typename super_t::template rebind<U>::other>;
+  }; // end rebind
+
+  _CCCL_HOST_DEVICE void deallocate(typename super_t::pointer p, typename super_t::size_type n) noexcept
+  {
+    NV_IF_TARGET(
+      NV_IS_HOST,
+      (try { super_t::deallocate(p, n); } // end try
+       catch (...){
+         // catch anything
+       } // end catch
+       ),
+      (super_t::deallocate(p, n);));
+  } // end deallocate()
+
+  inline _CCCL_HOST_DEVICE bool operator==(no_throw_allocator const& other)
+  {
+    return super_t::operator==(other);
+  }
+
+  inline _CCCL_HOST_DEVICE bool operator!=(no_throw_allocator const& other)
+  {
+    return super_t::operator!=(other);
+  }
+}; // end no_throw_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdac004d9bb3036628763bb18b62fe784520e190
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.h
@@ -0,0 +1,102 @@
+/*
+ *  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/type_traits/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename Tag, typename Pointer>
+class tagged_allocator;
+
+template <typename Tag, typename Pointer>
+class tagged_allocator<void, Tag, Pointer>
+{
+public:
+  using value_type      = void;
+  using pointer         = typename thrust::detail::pointer_traits<Pointer>::template rebind<void>::other;
+  using const_pointer   = typename thrust::detail::pointer_traits<Pointer>::template rebind<const void>::other;
+  using size_type       = std::size_t;
+  using difference_type = typename thrust::detail::pointer_traits<Pointer>::difference_type;
+  using system_type     = Tag;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = tagged_allocator<U, Tag, Pointer>;
+  }; // end rebind
+};
+
+template <typename T, typename Tag, typename Pointer>
+class tagged_allocator
+{
+public:
+  using value_type      = T;
+  using pointer         = typename thrust::detail::pointer_traits<Pointer>::template rebind<T>::other;
+  using const_pointer   = typename thrust::detail::pointer_traits<Pointer>::template rebind<const T>::other;
+  using reference       = typename thrust::iterator_reference<pointer>::type;
+  using const_reference = typename thrust::iterator_reference<const_pointer>::type;
+  using size_type       = std::size_t;
+  using difference_type = typename thrust::detail::pointer_traits<pointer>::difference_type;
+  using system_type     = Tag;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = tagged_allocator<U, Tag, Pointer>;
+  }; // end rebind
+
+  _CCCL_HOST_DEVICE inline tagged_allocator();
+
+  _CCCL_HOST_DEVICE inline tagged_allocator(const tagged_allocator&);
+
+  template <typename U, typename OtherPointer>
+  _CCCL_HOST_DEVICE inline tagged_allocator(const tagged_allocator<U, Tag, OtherPointer>&);
+
+  _CCCL_HOST_DEVICE inline ~tagged_allocator();
+
+  _CCCL_HOST_DEVICE pointer address(reference x) const;
+
+  _CCCL_HOST_DEVICE const_pointer address(const_reference x) const;
+
+  size_type max_size() const;
+};
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool
+operator==(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&);
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool
+operator!=(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/tagged_allocator.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..41b369342c5c6236fd3eef79c921ff452b99cac8
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.inl
@@ -0,0 +1,86 @@
+/*
+ *  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/tagged_allocator.h>
+
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator()
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<T, Tag, Pointer>&)
+{}
+
+template <typename T, typename Tag, typename Pointer>
+template <typename U, typename OtherPointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<U, Tag, OtherPointer>&)
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::~tagged_allocator()
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::pointer
+tagged_allocator<T, Tag, Pointer>::address(reference x) const
+{
+  return &x;
+}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::const_pointer
+tagged_allocator<T, Tag, Pointer>::address(const_reference x) const
+{
+  return &x;
+}
+
+template <typename T, typename Tag, typename Pointer>
+typename tagged_allocator<T, Tag, Pointer>::size_type tagged_allocator<T, Tag, Pointer>::max_size() const
+{
+  return (std::numeric_limits<size_type>::max)() / sizeof(T);
+}
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool operator==(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
+{
+  return true;
+}
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool operator!=(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
+{
+  return false;
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..db1b215e597f50861b894c7ac07182d67c1a4eb2
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.h
@@ -0,0 +1,79 @@
+/*
+ *  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/allocator/tagged_allocator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/memory.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// XXX the pointer parameter given to tagged_allocator should be related to
+//     the type of the expression get_temporary_buffer(system, n).first
+//     without decltype, compromise on pointer<T,System>
+template <typename T, typename System>
+class temporary_allocator : public thrust::detail::tagged_allocator<T, System, thrust::pointer<T, System>>
+{
+private:
+  using super_t = thrust::detail::tagged_allocator<T, System, thrust::pointer<T, System>>;
+
+  System& m_system;
+
+public:
+  using pointer   = typename super_t::pointer;
+  using size_type = typename super_t::size_type;
+
+  inline _CCCL_HOST_DEVICE temporary_allocator(const temporary_allocator& other)
+      : super_t()
+      , m_system(other.m_system)
+  {}
+
+  inline _CCCL_HOST_DEVICE explicit temporary_allocator(thrust::execution_policy<System>& system)
+      : super_t()
+      , m_system(thrust::detail::derived_cast(system))
+  {}
+
+  _CCCL_HOST_DEVICE pointer allocate(size_type cnt);
+
+  _CCCL_HOST_DEVICE void deallocate(pointer p, size_type n) noexcept;
+
+  _CCCL_HOST_DEVICE inline System& system()
+  {
+    return m_system;
+  } // end system()
+
+private:
+  using pointer_and_size = thrust::pair<pointer, size_type>;
+}; // end temporary_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/temporary_allocator.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..8da39c41354d21a60e4a9938877bf65d802a281c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.inl
@@ -0,0 +1,81 @@
+/*
+ *  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/temporary_allocator.h>
+#include <thrust/detail/temporary_buffer.h>
+#include <thrust/system/detail/bad_alloc.h>
+
+#include <cassert>
+
+#include <nv/target>
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  if (defined(_NVHPC_CUDA) || defined(__CUDA_ARCH__))
+#    include <thrust/system/cuda/detail/terminate.h>
+#  endif // NVCC device pass or NVC++
+#endif // CUDA
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System>
+_CCCL_HOST_DEVICE typename temporary_allocator<T, System>::pointer
+temporary_allocator<T, System>::allocate(typename temporary_allocator<T, System>::size_type cnt)
+{
+  pointer_and_size result = thrust::get_temporary_buffer<T>(system(), cnt);
+
+  // handle failure
+  if (result.second < cnt)
+  {
+    // deallocate and throw
+    // note that we pass cnt to deallocate, not a value derived from result.second
+    deallocate(result.first, cnt);
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+    NV_IF_TARGET(NV_IS_HOST,
+                 (throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");),
+                 ( // NV_IS_DEVICE
+                   thrust::system::cuda::detail::terminate_with_message("temporary_buffer::allocate: "
+                                                                        "get_temporary_buffer failed");));
+#else
+    throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");
+#endif
+  } // end if
+
+  return result.first;
+} // end temporary_allocator::allocate()
+
+template <typename T, typename System>
+_CCCL_HOST_DEVICE void temporary_allocator<T, System>::deallocate(
+  typename temporary_allocator<T, System>::pointer p, typename temporary_allocator<T, System>::size_type n) noexcept
+{
+  return thrust::return_temporary_buffer(system(), p, n);
+} // end temporary_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..42a68fc85c2a1a2751330decf1ea2d21761501ac
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.h
@@ -0,0 +1,39 @@
+/*
+ *  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>
+_CCCL_HOST_DEVICE inline void value_initialize_range(Allocator& a, Pointer p, Size n);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/value_initialize_range.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..1bd9351245d82344017e7a00df8e873228b7a303
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.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/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;
+
+  _CCCL_HOST_DEVICE construct1_via_allocator(Allocator& a)
+      : a(a)
+  {}
+
+  template <typename T>
+  inline _CCCL_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
+    : ::cuda::std::disjunction<has_member_construct1<Allocator, T>, // if the Allocator does something interesting
+                                                                    // or if T's default constructor does something
+                                                                    // interesting
+                               thrust::detail::not_<::cuda::std::is_trivially_default_constructible<T>>>
+{};
+
+// 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_<::cuda::std::is_trivially_default_constructible<T>>
+{};
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>
+value_initialize_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>
+_CCCL_HOST_DEVICE
+typename disable_if<needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>::type
+value_initialize_range(Allocator& a, Pointer p, Size n)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE void value_initialize_range(Allocator& a, Pointer p, Size n)
+{
+  return allocator_traits_detail::value_initialize_range(a, p, n);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/catrig.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/catrig.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b238657ea513508e0ac41ed6ce5ad06194aea0a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/catrig.h
@@ -0,0 +1,875 @@
+/*
+ *  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>
+
+#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;
+
+_CCCL_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;
+}
+
+_CCCL_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.
+ */
+_CCCL_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.
+ */
+_CCCL_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
+ */
+_CCCL_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).
+ */
+_CCCL_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
+ */
+_CCCL_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.
+ */
+_CCCL_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.
+ */
+_CCCL_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 unnecessarily 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.
+ */
+_CCCL_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.
+ */
+_CCCL_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
+ */
+_CCCL_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).
+ */
+_CCCL_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()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_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>
+_CCCL_HOST_DEVICE inline complex<ValueType> asin(const complex<ValueType>& z)
+{
+  const complex<ValueType> i(0, 1);
+  return -i * asinh(i * z);
+}
+
+template <typename ValueType>
+_CCCL_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>
+_CCCL_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>
+_CCCL_HOST_DEVICE inline complex<ValueType> asinh(const complex<ValueType>& z)
+{
+  return thrust::log(thrust::sqrt(z * z + ValueType(1)) + z);
+}
+
+template <typename ValueType>
+_CCCL_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 <>
+_CCCL_HOST_DEVICE inline complex<double> acos(const complex<double>& z)
+{
+  return detail::complex::cacos(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> asin(const complex<double>& z)
+{
+  return detail::complex::casin(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> atan(const complex<double>& z)
+{
+  return detail::complex::catan(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> acosh(const complex<double>& z)
+{
+  return detail::complex::cacosh(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> asinh(const complex<double>& z)
+{
+  return detail::complex::casinh(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> atanh(const complex<double>& z)
+{
+  return detail::complex::catanh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexp.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexp.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e6d0d1125d5f12bca58b42851973cf51fe63f4e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexp.h
@@ -0,0 +1,195 @@
+/*
+ *  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>
+
+#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
+ */
+_CCCL_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);
+}
+
+_CCCL_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));
+}
+
+_CCCL_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>
+_CCCL_HOST_DEVICE inline complex<ValueType> exp(const complex<ValueType>& z)
+{
+  return polar(std::exp(z.real()), z.imag());
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> exp(const complex<double>& z)
+{
+  return detail::complex::cexp(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexpf.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexpf.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce759873fe40c7a1f1bf0fd5ff1d6475d37b6e82
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/cexpf.h
@@ -0,0 +1,173 @@
+/*
+ *  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>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+_CCCL_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);
+}
+
+_CCCL_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));
+}
+
+_CCCL_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 <>
+_CCCL_HOST_DEVICE inline complex<float> exp(const complex<float>& z)
+{
+  return detail::complex::cexpf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/clogf.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/clogf.h
new file mode 100644
index 0000000000000000000000000000000000000000..844a18b3aabf3c364053e6289002febd7857a1a9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/clogf.h
@@ -0,0 +1,210 @@
+/*
+ *  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>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+/* round down to 8 = 24/3 bits */
+_CCCL_HOST_DEVICE inline float trim(float x)
+{
+  uint32_t hx;
+  get_float_word(hx, x);
+  hx &= 0xffff0000;
+  float ret;
+  set_float_word(ret, hx);
+  return ret;
+}
+
+_CCCL_HOST_DEVICE inline complex<float> clogf(const complex<float>& z)
+{
+  // Adapted from FreeBSDs msun
+  float x, y;
+  float ax, ay;
+  float x0, y0, x1, y1, x2, y2, t, hm1;
+  float val[12];
+  int i, sorted;
+  const float e = 2.7182818284590452354f;
+
+  x = z.real();
+  y = z.imag();
+
+  /* Handle NaNs using the general formula to mix them right. */
+  if (x != x || y != y)
+  {
+    return (complex<float>(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.
+   */
+  // For high values of ay -> hypotf(FLT_MAX,ay) = inf
+  // We expect that for values at or below ay = 1e34f this should not happen
+  if (ay > 1e34f)
+  {
+    return (complex<float>(std::log(hypotf(x / e, y / e)) + 1.0f, std::atan2(y, x)));
+  }
+  if (ax == 1.f)
+  {
+    if (ay < 1e-19f)
+    {
+      return (complex<float>((ay * 0.5f) * ay, std::atan2(y, x)));
+    }
+    return (complex<float>(log1pf(ay * ay) * 0.5f, 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-6f || ay < 1e-6f || ax > 1e6f || ay > 1e6f)
+  {
+    return (complex<float>(std::log(hypotf(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.0f)
+  {
+    return (complex<float>(log1pf((ax - 1.f) * (ax + 1.f) + ay * ay) * 0.5f, atan2(y, x)));
+  }
+
+  if (ax * ax + ay * ay <= 0.7f)
+  {
+    return (complex<float>(std::log(ax * ax + ay * ay) * 0.5f, 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<float>(0.5f * log1pf(hm1), atan2(y, x)));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> log(const complex<float>& z)
+{
+  return detail::complex::clogf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinh.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinh.h
new file mode 100644
index 0000000000000000000000000000000000000000..81e194e1ccdd3ccea4da0afcc6eea9e11b7358cf
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinh.h
@@ -0,0 +1,226 @@
+/*
+ *  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_csinh.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/cexp.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<double> csinh(const complex<double>& z)
+{
+  double x, y, h;
+  uint32_t hx, hy, ix, iy, lx, ly;
+  const double huge = 8.98846567431157953864652595395e+307; // 0x1p1023;
+
+  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 (complex<double>(sinh(x), y));
+    }
+    if (ix < 0x40360000) /* small x: normal case */
+    {
+      return (complex<double>(sinh(x) * cos(y), cosh(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 (complex<double>(copysign(h, x) * cos(y), h * sin(y)));
+    }
+    else if (ix < 0x4096bbaa)
+    {
+      /* x < 1455: scale to avoid overflow */
+      complex<double> z_ = ldexp_cexp(complex<double>(fabs(x), y), -1);
+      return (complex<double>(z_.real() * copysign(1.0, x), z_.imag()));
+    }
+    else
+    {
+      /* x >= 1455: the result always overflows */
+      h = huge * x;
+      return (complex<double>(h * cos(y), h * h * sin(y)));
+    }
+  }
+
+  /*
+   * sinh(+-0 +- I Inf) = sign(d(+-0, dNaN))0 + I dNaN.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as dNaN.  Raise the invalid floating-point exception.
+   *
+   * sinh(+-0 +- I NaN) = sign(d(+-0, NaN))0 + I d(NaN).
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   */
+  if ((ix | lx) == 0 && iy >= 0x7ff00000)
+  {
+    return (complex<double>(copysign(0.0, x * (y - y)), y - y));
+  }
+
+  /*
+   * sinh(+-Inf +- I 0) = +-Inf + I +-0.
+   *
+   * sinh(NaN +- I 0)   = d(NaN) + I +-0.
+   */
+  if ((iy | ly) == 0 && ix >= 0x7ff00000)
+  {
+    if (((hx & 0xfffff) | lx) == 0)
+    {
+      return (complex<double>(x, y));
+    }
+    return (complex<double>(x, copysign(0.0, y)));
+  }
+
+  /*
+   * sinh(x +- I Inf) = dNaN + I dNaN.
+   * Raise the invalid floating-point exception for finite nonzero x.
+   *
+   * sinh(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 (complex<double>(y - y, x * (y - y)));
+  }
+
+  /*
+   * sinh(+-Inf + I NaN)  = +-Inf + I d(NaN).
+   * The sign of Inf in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   *
+   * sinh(+-Inf +- I Inf) = +Inf + I dNaN.
+   * The sign of Inf in the result is unspecified.  Choice = always +.
+   * Raise the invalid floating-point exception.
+   *
+   * sinh(+-Inf + I y)   = +-Inf cos(y) + I Inf sin(y)
+   */
+  if (ix >= 0x7ff00000 && ((hx & 0xfffff) | lx) == 0)
+  {
+    if (iy >= 0x7ff00000)
+    {
+      return (complex<double>(x * x, x * (y - y)));
+    }
+    return (complex<double>(x * cos(y), infinity<double>() * sin(y)));
+  }
+
+  /*
+   * sinh(NaN + I NaN)  = d(NaN) + I d(NaN).
+   *
+   * sinh(NaN +- I Inf) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception.
+   * Choice = raise.
+   *
+   * sinh(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 (complex<double>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+_CCCL_HOST_DEVICE inline complex<double> csin(complex<double> z)
+{
+  /* csin(z) = -I * csinh(I * z) */
+  z = csinh(complex<double>(-z.imag(), z.real()));
+  return (complex<double>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> sin(const complex<ValueType>& z)
+{
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::sin(re) * std::cosh(im), std::cos(re) * std::sinh(im));
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> sinh(const complex<ValueType>& z)
+{
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::sinh(re) * std::cos(im), std::cosh(re) * std::sin(im));
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> sin(const complex<double>& z)
+{
+  return detail::complex::csin(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> sinh(const complex<double>& z)
+{
+  return detail::complex::csinh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinhf.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinhf.h
new file mode 100644
index 0000000000000000000000000000000000000000..88c56df73ea88bfff58812cfa0bf1faa8785907f
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/csinhf.h
@@ -0,0 +1,166 @@
+/*
+ *  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_csinhf.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/cexp.h>
+#include <thrust/detail/complex/cexpf.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<float> csinhf(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>(sinhf(x), y));
+    }
+    if (ix < 0x41100000) /* small x: normal case */
+    {
+      return (complex<float>(sinhf(x) * cosf(y), coshf(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>(copysignf(h, x) * cosf(y), h * sinf(y)));
+    }
+    else if (ix < 0x4340b1e7)
+    {
+      /* x < 192.7: scale to avoid overflow */
+      complex<float> z_ = ldexp_cexpf(complex<float>(fabsf(x), y), -1);
+      return (complex<float>(z_.real() * copysignf(1.0f, x), z_.imag()));
+    }
+    else
+    {
+      /* x >= 192.7: the result always overflows */
+      h = huge * x;
+      return (complex<float>(h * cosf(y), h * h * sinf(y)));
+    }
+  }
+
+  if (ix == 0 && iy >= 0x7f800000)
+  {
+    return (complex<float>(copysignf(0, x * (y - y)), y - y));
+  }
+
+  if (iy == 0 && ix >= 0x7f800000)
+  {
+    if ((hx & 0x7fffff) == 0)
+    {
+      return (complex<float>(x, y));
+    }
+    return (complex<float>(x, copysignf(0.0f, 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 * cosf(y), infinity<float>() * sinf(y)));
+  }
+
+  return (complex<float>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+_CCCL_HOST_DEVICE inline complex<float> csinf(complex<float> z)
+{
+  z = csinhf(complex<float>(-z.imag(), z.real()));
+  return (complex<float>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> sin(const complex<float>& z)
+{
+  return detail::complex::csinf(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> sinh(const complex<float>& z)
+{
+  return detail::complex::csinhf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanh.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanh.h
new file mode 100644
index 0000000000000000000000000000000000000000..a238981f907ac63e6be7dd79d8ffdd2f0504fd45
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanh.h
@@ -0,0 +1,208 @@
+/*
+ *  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
+ * 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 by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/s_ctanh.c
+ */
+
+/*
+ * Hyperbolic tangent of a complex argument z = x + i y.
+ *
+ * The algorithm is from:
+ *
+ *   W. Kahan.  Branch Cuts for Complex Elementary Functions or Much
+ *   Ado About Nothing's Sign Bit.  In The State of the Art in
+ *   Numerical Analysis, pp. 165 ff.  Iserles and Powell, eds., 1987.
+ *
+ * Method:
+ *
+ *   Let t    = tan(x)
+ *       beta = 1/cos^2(y)
+ *       s    = sinh(x)
+ *       rho  = cosh(x)
+ *
+ *   We have:
+ *
+ *   tanh(z) = sinh(z) / cosh(z)
+ *
+ *             sinh(x) cos(y) + i cosh(x) sin(y)
+ *           = ---------------------------------
+ *             cosh(x) cos(y) + i sinh(x) sin(y)
+ *
+ *             cosh(x) sinh(x) / cos^2(y) + i tan(y)
+ *           = -------------------------------------
+ *                    1 + sinh^2(x) / cos^2(y)
+ *
+ *             beta rho s + i t
+ *           = ----------------
+ *               1 + beta s^2
+ *
+ * Modifications:
+ *
+ *   I omitted the original algorithm's handling of overflow in tan(x) after
+ *   verifying with nearpi.c that this can't happen in IEEE single or double
+ *   precision.  I also handle large x differently.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<double> ctanh(const complex<double>& z)
+{
+  double x, y;
+  double t, beta, s, rho, denom;
+  uint32_t hx, ix, lx;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  ix = hx & 0x7fffffff;
+
+  /*
+   * ctanh(NaN + i 0) = NaN + i 0
+   *
+   * ctanh(NaN + i y) = NaN + i NaN		for y != 0
+   *
+   * The imaginary part has the sign of x*sin(2*y), but there's no
+   * special effort to get this right.
+   *
+   * ctanh(+-Inf +- i Inf) = +-1 +- 0
+   *
+   * ctanh(+-Inf + i y) = +-1 + 0 sin(2y)		for y finite
+   *
+   * The imaginary part of the sign is unspecified.  This special
+   * case is only needed to avoid a spurious invalid exception when
+   * y is infinite.
+   */
+  if (ix >= 0x7ff00000)
+  {
+    if ((ix & 0xfffff) | lx) /* x is NaN */
+    {
+      return (complex<double>(x, (y == 0 ? y : x * y)));
+    }
+    set_high_word(x, hx - 0x40000000); /* x = copysign(1, x) */
+    return (complex<double>(x, copysign(0.0, isinf(y) ? y : sin(y) * cos(y))));
+  }
+
+  /*
+   * ctanh(x + i NAN) = NaN + i NaN
+   * ctanh(x +- i Inf) = NaN + i NaN
+   */
+  if (!isfinite(y))
+  {
+    return (complex<double>(y - y, y - y));
+  }
+
+  /*
+   * ctanh(+-huge + i +-y) ~= +-1 +- i 2sin(2y)/exp(2x), using the
+   * approximation sinh^2(huge) ~= exp(2*huge) / 4.
+   * We use a modified formula to avoid spurious overflow.
+   */
+  if (ix >= 0x40360000)
+  { /* x >= 22 */
+    double exp_mx = exp(-fabs(x));
+    return (complex<double>(copysign(1.0, x), 4.0 * sin(y) * cos(y) * exp_mx * exp_mx));
+  }
+
+  /* Kahan's algorithm */
+  t     = tan(y);
+  beta  = 1.0 + t * t; /* = 1 / cos^2(y) */
+  s     = sinh(x);
+  rho   = sqrt(1.0 + s * s); /* = cosh(x) */
+  denom = 1.0 + beta * s * s;
+  return (complex<double>((beta * rho * s) / denom, t / denom));
+}
+
+_CCCL_HOST_DEVICE inline complex<double> ctan(complex<double> z)
+{
+  /* ctan(z) = -I * ctanh(I * z) */
+  z = ctanh(complex<double>(-z.imag(), z.real()));
+  return (complex<double>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> tan(const complex<ValueType>& z)
+{
+  return sin(z) / cos(z);
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> tanh(const complex<ValueType>& z)
+{
+  // This implementation seems better than the simple sin/cos
+  return (thrust::exp(ValueType(2) * z) - ValueType(1)) / (thrust::exp(ValueType(2) * z) + ValueType(1));
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> tan(const complex<double>& z)
+{
+  return detail::complex::ctan(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> tanh(const complex<double>& z)
+{
+  return detail::complex::ctanh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanhf.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanhf.h
new file mode 100644
index 0000000000000000000000000000000000000000..03e5491c30ae3bec562327d62a561c6d7052bcbc
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/complex/ctanhf.h
@@ -0,0 +1,133 @@
+/*
+ *  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
+ * 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 by Filipe Maia, filipe.c.maia@gmail.com:
+ *    freebsd/lib/msun/src/s_ctanhf.c
+ */
+
+/*
+ * Hyperbolic tangent of a complex argument z.  See ctanh.c for details.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<float> ctanhf(const complex<float>& z)
+{
+  float x, y;
+  float t, beta, s, rho, denom;
+  uint32_t hx, ix;
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hx, x);
+  ix = hx & 0x7fffffff;
+
+  if (ix >= 0x7f800000)
+  {
+    if (ix & 0x7fffff)
+    {
+      return (complex<float>(x, (y == 0.0f ? y : x * y)));
+    }
+    set_float_word(x, hx - 0x40000000);
+    return (complex<float>(x, copysignf(0, isinf(y) ? y : sinf(y) * cosf(y))));
+  }
+
+  if (!isfinite(y))
+  {
+    return (complex<float>(y - y, y - y));
+  }
+
+  if (ix >= 0x41300000)
+  { /* x >= 11 */
+    float exp_mx = expf(-fabsf(x));
+    return (complex<float>(copysignf(1.0f, x), 4.0f * sinf(y) * cosf(y) * exp_mx * exp_mx));
+  }
+
+  t     = tanf(y);
+  beta  = 1.0f + t * t;
+  s     = sinhf(x);
+  rho   = sqrtf(1.0f + s * s);
+  denom = 1.0f + beta * s * s;
+  return (complex<float>((beta * rho * s) / denom, t / denom));
+}
+
+_CCCL_HOST_DEVICE inline complex<float> ctanf(complex<float> z)
+{
+  z = ctanhf(complex<float>(-z.imag(), z.real()));
+  return (complex<float>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> tan(const complex<float>& z)
+{
+  return detail::complex::ctanf(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> tanh(const complex<float>& z)
+{
+  return detail::complex::ctanhf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7b3f5222e714e88ca5d7cb920bedf66d62064f5
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config.h
@@ -0,0 +1,31 @@
+/*
+ *  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 config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/config.h> // IWYU pragma: export
+#include <thrust/version.h> // IWYU pragma: export
+
+#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
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..25d8ebfb29e7cb091911e65483b34df501907fa6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler.h
@@ -0,0 +1,119 @@
+/*
+ *  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 compiler.h
+ *  \brief Compiler-specific configuration
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// enumerate host compilers we know about
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_UNKNOWN 0
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_MSVC 1
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_GCC 2
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_CLANG 3
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_INTEL 4
+
+// enumerate device compilers we know about
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_UNKNOWN 0
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_MSVC 1
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_GCC 2
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_CLANG 3
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_NVCC 4
+
+// figure out which host compiler we're using
+#if _CCCL_COMPILER(MSVC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_MSVC
+//! deprecated [Since 2.7]
+#  define THRUST_MSVC_VERSION _MSC_VER
+//! deprecated [Since 2.7]
+#  define THRUST_MSVC_VERSION_FULL _MSC_FULL_VER
+#elif _CCCL_COMPILER(ICC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_INTEL
+#elif _CCCL_COMPILER(CLANG)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_CLANG
+//! deprecated [Since 2.7]
+#  define THRUST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#elif _CCCL_COMPILER(GCC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_GCC
+//! deprecated [Since 2.7]
+#  define THRUST_GCC_VERSION   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#  if _CCCL_COMPILER(GCC, >=, 5)
+//! deprecated [Since 2.7]
+#    define THRUST_MODERN_GCC
+#  else
+//! deprecated [Since 2.7]
+#    define THRUST_LEGACY_GCC
+#  endif
+#else
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_UNKNOWN
+#endif // TRUST_HOST_COMPILER
+
+// figure out which device compiler we're using
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#elif _CCCL_COMPILER(MSVC)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_MSVC
+#elif _CCCL_COMPILER(GCC)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_GCC
+#elif _CCCL_COMPILER(CLANG)
+// CUDA-capable clang should behave similar to NVCC.
+#  if defined(__CUDA__)
+//! deprecated [Since 2.7]
+#    define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#  else
+//! deprecated [Since 2.7]
+#    define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_CLANG
+#  endif
+#else
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_UNKNOWN
+#endif
+
+// is the device compiler capable of compiling omp?
+#if defined(_OPENMP) || defined(_NVHPC_STDPAR_OPENMP)
+#  define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_TRUE
+#else
+#  define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_FALSE
+#endif // _OPENMP
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler_fence.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler_fence.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b93b682c99f0b2efcd21f6b35c882f2574e89ab
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler_fence.h
@@ -0,0 +1,79 @@
+/*
+ *  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/preprocessor.h>
+
+#if _CCCL_COMPILER(MSVC)
+#  pragma message( \
+    "warning: The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 atomics instead.")
+#else
+#warning The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead.
+#endif
+
+// msvc case
+#if _CCCL_COMPILER(MSVC)
+
+#  ifndef _DEBUG
+
+#    include <intrin.h>
+#    pragma intrinsic(_ReadWriteBarrier)
+#    define __thrust_compiler_fence() _ReadWriteBarrier()
+#  else
+
+#    define __thrust_compiler_fence() \
+      do                              \
+      {                               \
+      } while (0)
+
+#  endif // _DEBUG
+
+// gcc case
+#elif _CCCL_COMPILER(GCC)
+
+#  if _CCCL_COMPILER(GCC, >=, 4, 2) // atomic built-ins were introduced ~4.2
+#    define __thrust_compiler_fence() __sync_synchronize()
+#  else
+// allow the code to compile without any guarantees
+#    define __thrust_compiler_fence() \
+      do                              \
+      {                               \
+      } while (0)
+#  endif // _CCCL_COMPILER(GCC, >=, 4, 2)
+
+// unknown case
+#elif _CCCL_COMPILER(CLANG)
+#  define __thrust_compiler_fence() __sync_synchronize()
+#else
+
+// allow the code to compile without any guarantees
+#  define __thrust_compiler_fence() \
+    do                              \
+    {                               \
+    } while (0)
+
+#endif
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/config.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0335230160eff89692707a4fb0649c34d26bcf1
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/config.h
@@ -0,0 +1,45 @@
+/*
+ *  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 config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+// For _CCCL_IMPLICIT_SYSTEM_HEADER
+#include <cuda/__cccl_config> // IWYU pragma: export
+
+#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
+
+// NOTE: The order of these #includes matters.
+
+#include <thrust/detail/config/compiler.h> // IWYU pragma: export
+#include <thrust/detail/config/cpp_compatibility.h> // IWYU pragma: export
+#include <thrust/detail/config/cpp_dialect.h> // IWYU pragma: export
+#include <thrust/detail/config/simple_defines.h> // IWYU pragma: export
+// host_system.h & device_system.h must be #included as early as possible because other config headers depend on it
+#include <thrust/detail/config/host_system.h> // IWYU pragma: export
+
+#include <thrust/detail/config/device_system.h> // IWYU pragma: export
+#include <thrust/detail/config/global_workarounds.h> // IWYU pragma: export
+#include <thrust/detail/config/namespace.h> // IWYU pragma: export
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_compatibility.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_compatibility.h
new file mode 100644
index 0000000000000000000000000000000000000000..36f74614eecc40477021e2549f00932bc7173ce6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_compatibility.h
@@ -0,0 +1,61 @@
+/*
+ *  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
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// deprecated [Since 2.8.0]
+#define THRUST_NODISCARD _CCCL_NODISCARD
+// deprecated [Since 2.8.0]
+#define THRUST_INLINE_CONSTANT _CCCL_GLOBAL_CONSTANT
+// deprecated [Since 2.8.0]
+#define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+
+// These definitions were intended for internal use only and are now obsolete.
+// If you relied on them, consider porting your code to use the functionality
+// in libcu++'s <nv/target> header.
+// For a temporary workaround, define THRUST_PROVIDE_LEGACY_ARCH_MACROS to make
+// them available again. These should be considered deprecated and will be
+// fully removed in a future version.
+#ifdef THRUST_PROVIDE_LEGACY_ARCH_MACROS
+#  ifndef THRUST_IS_DEVICE_CODE
+#    if defined(_NVHPC_CUDA)
+#      define THRUST_IS_DEVICE_CODE      __builtin_is_device_code()
+#      define THRUST_IS_HOST_CODE        (!__builtin_is_device_code())
+#      define THRUST_INCLUDE_DEVICE_CODE 1
+#      define THRUST_INCLUDE_HOST_CODE   1
+#    elif defined(__CUDA_ARCH__)
+#      define THRUST_IS_DEVICE_CODE      1
+#      define THRUST_IS_HOST_CODE        0
+#      define THRUST_INCLUDE_DEVICE_CODE 1
+#      define THRUST_INCLUDE_HOST_CODE   0
+#    else
+#      define THRUST_IS_DEVICE_CODE      0
+#      define THRUST_IS_HOST_CODE        1
+#      define THRUST_INCLUDE_DEVICE_CODE 0
+#      define THRUST_INCLUDE_HOST_CODE   1
+#    endif
+#  endif
+#endif // THRUST_PROVIDE_LEGACY_ARCH_MACROS
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_dialect.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_dialect.h
new file mode 100644
index 0000000000000000000000000000000000000000..44607d97983a91de399dee1a4ba5f631fd3ef690
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_dialect.h
@@ -0,0 +1,100 @@
+/*
+ *  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 cpp_dialect.h
+ *  \brief Detect the version of the C++ standard used by the compiler.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/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/compiler.h> // IWYU pragma: export
+
+// Deprecation warnings may be silenced by defining the following macros. These
+// may be combined.
+// - CCCL_IGNORE_DEPRECATED_CPP_DIALECT:
+//   Ignore all deprecated C++ dialects and outdated compilers.
+// - CCCL_IGNORE_DEPRECATED_CPP_11:
+//   Ignore deprecation warnings when compiling with C++11. C++03 and outdated
+//   compilers will still issue warnings.
+// - CCCL_IGNORE_DEPRECATED_CPP_14:
+//   Ignore deprecation warnings when compiling with C++14. C++03 and outdated
+//   compilers will still issue warnings.
+// - CCCL_IGNORE_DEPRECATED_COMPILER
+//   Ignore deprecation warnings when using deprecated compilers. Compiling
+//   with C++03, C++11 and C++14 will still issue warnings.
+
+#define THRUST_CPP_DIALECT _CCCL_STD_VER
+
+// Define THRUST_COMPILER_DEPRECATION macro:
+#if _CCCL_COMPILER(MSVC) || _CCCL_COMPILER(NVRTC)
+#  define THRUST_COMP_DEPR_IMPL(msg) _CCCL_PRAGMA(message(__FILE__ ":" _CCCL_TO_STRING(__LINE__) ": warning: " #msg))
+#else // clang / gcc:
+#  define THRUST_COMP_DEPR_IMPL(msg) _CCCL_PRAGMA(GCC warning #msg)
+#endif
+
+// clang-format off
+#define THRUST_COMPILER_DEPRECATION(REQ) \
+  THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. Define CCCL_IGNORE_DEPRECATED_COMPILER to suppress this message.)
+
+#define THRUST_COMPILER_DEPRECATION_SOFT(REQ, CUR)                                                        \
+  THRUST_COMP_DEPR_IMPL(                                                                                  \
+    Thrust requires at least REQ. CUR is deprecated but still supported. CUR support will be removed in a \
+      future release. Define CCCL_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.)
+// clang-format on
+
+#ifndef CCCL_IGNORE_DEPRECATED_COMPILER
+
+// Compiler checks:
+#  if _CCCL_COMPILER(GCC, <, 5)
+THRUST_COMPILER_DEPRECATION(GCC 5.0);
+#  elif _CCCL_COMPILER(CLANG, <, 7)
+THRUST_COMPILER_DEPRECATION(Clang 7.0);
+#  elif _CCCL_COMPILER(MSVC, <, 19, 10)
+// <2017. Hard upgrade message:
+THRUST_COMPILER_DEPRECATION(MSVC 2019(19.20 / 16.0 / 14.20));
+#  elif _CCCL_COMPILER(MSVC2017)
+// >=2017, <2019. Soft deprecation message:
+THRUST_COMPILER_DEPRECATION_SOFT(MSVC 2019(19.20 / 16.0 / 14.20), MSVC 2017);
+#  endif
+
+#endif // CCCL_IGNORE_DEPRECATED_COMPILER
+
+#if _CCCL_STD_VER < 2011
+// <C++11. Hard upgrade message:
+THRUST_COMPILER_DEPRECATION(C++ 17);
+#elif _CCCL_STD_VER == 2011 && !defined(CCCL_IGNORE_DEPRECATED_CPP_11)
+// =C++11. Soft upgrade message:
+THRUST_COMPILER_DEPRECATION_SOFT(C++ 17, C++ 11);
+#elif _CCCL_STD_VER == 2014 && !defined(CCCL_IGNORE_DEPRECATED_CPP_14)
+// =C++14. Soft upgrade message:
+THRUST_COMPILER_DEPRECATION_SOFT(C++ 17, C++ 14);
+#endif // _CCCL_STD_VER >= 2017
+
+#undef THRUST_COMPILER_DEPRECATION_SOFT
+#undef THRUST_COMPILER_DEPRECATION
+#undef THRUST_COMP_DEPR_IMPL
+#undef THRUST_COMP_DEPR_IMPL0
+#undef THRUST_COMP_DEPR_IMPL1
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/device_system.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/device_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..79006bbdf3006245defbb731c99ed17da8fc4281
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/device_system.h
@@ -0,0 +1,55 @@
+/*
+ *  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
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// reserve 0 for undefined
+#define THRUST_DEVICE_SYSTEM_CUDA 1
+#define THRUST_DEVICE_SYSTEM_OMP  2
+#define THRUST_DEVICE_SYSTEM_TBB  3
+#define THRUST_DEVICE_SYSTEM_CPP  4
+
+#ifndef THRUST_DEVICE_SYSTEM
+#  define THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_CUDA
+#endif // THRUST_DEVICE_SYSTEM
+
+#ifdef THRUST_DEVICE_BACKEND
+#  error THRUST_DEVICE_BACKEND is no longer supported; use THRUST_DEVICE_SYSTEM instead.
+#endif // THRUST_DEVICE_BACKEND
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE cuda
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_OMP
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE omp
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_TBB
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE tbb
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CPP
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE cpp
+#endif
+
+// clang-format off
+#define __THRUST_DEVICE_SYSTEM_ROOT thrust/system/__THRUST_DEVICE_SYSTEM_NAMESPACE
+// clang-format on
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/global_workarounds.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/global_workarounds.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ee1c5d93c8707993d36d9a2beeeeaf5d65ef64f
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/global_workarounds.h
@@ -0,0 +1,36 @@
+/*
+ *  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
+
+// Internal config header that is only included through thrust/detail/config/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/compiler.h>
+
+// XXX workaround gcc 4.8+'s complaints about unused local aliases by silencing them globally
+#if _CCCL_COMPILER(GCC, >=, 4, 8)
+#  if defined(__NVCC__) && (CUDART_VERSION >= 6000)
+#    pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#  endif // nvcc & cuda 6+
+#endif // gcc 4.8
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/host_system.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/host_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fc6a4f9c1c3b73a2421e41adebc82828bbe6109
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/host_system.h
@@ -0,0 +1,52 @@
+/*
+ *  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
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// reserve 0 for undefined
+#define THRUST_HOST_SYSTEM_CPP 1
+#define THRUST_HOST_SYSTEM_OMP 2
+#define THRUST_HOST_SYSTEM_TBB 3
+
+#ifndef THRUST_HOST_SYSTEM
+#  define THRUST_HOST_SYSTEM THRUST_HOST_SYSTEM_CPP
+#endif // THRUST_HOST_SYSTEM
+
+#ifdef THRUST_HOST_BACKEND
+#  error THRUST_HOST_BACKEND is no longer supported; use THRUST_HOST_SYSTEM instead.
+#endif // THRUST_HOST_BACKEND
+
+#if THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_CPP
+#  define __THRUST_HOST_SYSTEM_NAMESPACE cpp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_OMP
+#  define __THRUST_HOST_SYSTEM_NAMESPACE omp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_TBB
+#  define __THRUST_HOST_SYSTEM_NAMESPACE tbb
+#endif
+
+// clang-format off
+#define __THRUST_HOST_SYSTEM_ROOT thrust/system/__THRUST_HOST_SYSTEM_NAMESPACE
+// clang-format on
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/memory_resource.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a41d03655ff7792820a8267e24f0c432607020c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/memory_resource.h
@@ -0,0 +1,44 @@
+/*
+ *  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/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/alignment.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+
+#include <cstddef>
+
+#define THRUST_MR_DEFAULT_ALIGNMENT alignof(THRUST_NS_QUALIFIER::detail::max_align_t)
+
+#if _CCCL_STD_VER >= 2017
+#  if _CCCL_HAS_INCLUDE(<memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <memory_resource>
+#    define THRUST_MR_STD_MR_NS     std::pmr
+#  elif _CCCL_HAS_INCLUDE(<experimental/memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <experimental/memory_resource>
+#    define THRUST_MR_STD_MR_NS     std::experimental::pmr
+#  endif
+#endif
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/namespace.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/namespace.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5e72d38f40f4a0a08fa5ca53a764633230af717
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/namespace.h
@@ -0,0 +1,162 @@
+/*
+ *  Copyright 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
+
+// Internal config header that is only included through thrust/detail/config/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/device_system.h>
+#include <thrust/version.h>
+
+/**
+ * \file namespace.h
+ * \brief Utilities that allow `thrust::` to be placed inside an
+ * application-specific namespace.
+ */
+
+/**
+ * \def THRUST_CUB_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` and `cub::` namespaces.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_CUB_WRAPPED_NAMESPACE
+#  define THRUST_WRAPPED_NAMESPACE THRUST_CUB_WRAPPED_NAMESPACE
+#endif
+
+/**
+ * \def THRUST_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` namespace.
+ * If THRUST_CUB_WRAPPED_NAMESPACE is set, this will inherit that macro's value.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_WRAPPED_NAMESPACE
+#  define THRUST_NS_PREFIX             \
+    namespace THRUST_WRAPPED_NAMESPACE \
+    {
+
+#  define THRUST_NS_POSTFIX }
+
+#  define THRUST_NS_QUALIFIER ::THRUST_WRAPPED_NAMESPACE::thrust
+#endif
+
+/**
+ * \def THRUST_NS_PREFIX
+ * This macro is inserted prior to all `namespace thrust { ... }` blocks. It is
+ * derived from THRUST_WRAPPED_NAMESPACE, if set, and will be empty otherwise.
+ * It may be defined by users, in which case THRUST_NS_PREFIX,
+ * THRUST_NS_POSTFIX, and THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_PREFIX
+#  define THRUST_NS_PREFIX
+#endif
+
+/**
+ * \def THRUST_NS_POSTFIX
+ * This macro is inserted following the closing braces of all
+ * `namespace thrust { ... }` block. It is defined appropriately when
+ * THRUST_WRAPPED_NAMESPACE is set, and will be empty otherwise. It may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_POSTFIX
+#  define THRUST_NS_POSTFIX
+#endif
+
+/**
+ * \def THRUST_NS_QUALIFIER
+ * This macro is used to qualify members of thrust:: when accessing them from
+ * outside of their namespace. By default, this is just `::thrust`, and will be
+ * set appropriately when THRUST_WRAPPED_NAMESPACE is defined. This macro may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_QUALIFIER
+#  define THRUST_NS_QUALIFIER ::thrust
+#endif
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  if defined(THRUST_DISABLE_ABI_NAMESPACE) || defined(THRUST_WRAPPED_NAMESPACE)
+#    if !defined(THRUST_WRAPPED_NAMESPACE)
+#      if !defined(THRUST_IGNORE_ABI_NAMESPACE_ERROR)
+#        error "Disabling ABI namespace is unsafe without wrapping namespace"
+#      endif // !defined(THRUST_IGNORE_ABI_NAMESPACE_ERROR)
+#    endif // !defined(THRUST_WRAPPED_NAMESPACE)
+#    define THRUST_DETAIL_ABI_NS_BEGIN
+#    define THRUST_DETAIL_ABI_NS_END
+#  else // not defined(THRUST_DISABLE_ABI_NAMESPACE)
+#    if defined(_NVHPC_CUDA)
+#      define THRUST_DETAIL_ABI_NS_BEGIN                                                                           \
+        inline namespace _CCCL_PP_SPLICE_WITH(_, THRUST, THRUST_VERSION, SM, NV_TARGET_SM_INTEGER_LIST, NVHPC, NS) \
+        {
+#      define THRUST_DETAIL_ABI_NS_END }
+#    else // not defined(_NVHPC_CUDA)
+#      define THRUST_DETAIL_ABI_NS_BEGIN                                                             \
+        inline namespace _CCCL_PP_SPLICE_WITH(_, THRUST, THRUST_VERSION, SM, __CUDA_ARCH_LIST__, NS) \
+        {
+#      define THRUST_DETAIL_ABI_NS_END }
+#    endif // not defined(_NVHPC_CUDA)
+#  endif // not defined(THRUST_DISABLE_ABI_NAMESPACE)
+#else // THRUST_DEVICE_SYSTEM != THRUST_DEVICE_SYSTEM_CUDA
+#  define THRUST_DETAIL_ABI_NS_BEGIN
+#  define THRUST_DETAIL_ABI_NS_END
+#endif // THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+
+/**
+ * \def THRUST_NAMESPACE_BEGIN
+ * This macro is used to open a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_BEGIN \
+  THRUST_NS_PREFIX             \
+  namespace thrust             \
+  {                            \
+  THRUST_DETAIL_ABI_NS_BEGIN
+
+/**
+ * \def THRUST_NAMESPACE_END
+ * This macro is used to close a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_END   \
+  THRUST_DETAIL_ABI_NS_END     \
+  } /* end namespace thrust */ \
+  THRUST_NS_POSTFIX
+
+// The following is just here to add docs for the thrust namespace:
+
+THRUST_NS_PREFIX
+
+/*! \namespace thrust
+ *  \brief \p thrust is the top-level namespace which contains all Thrust
+ *         functions and types.
+ */
+namespace thrust
+{
+}
+
+THRUST_NS_POSTFIX
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/simple_defines.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/simple_defines.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa17b6864e83d7492f86a367db5e1b2663c83054
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/simple_defines.h
@@ -0,0 +1,43 @@
+/*
+ *  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 simple_defines.h
+ *  \brief Primitive macros without dependencies.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+#define THRUST_UNKNOWN 0
+#define THRUST_FALSE   0
+#define THRUST_TRUE    1
+
+#define THRUST_UNUSED_VAR(expr) \
+  do                            \
+  {                             \
+    (void) (expr);              \
+  } while (0)
+
+#define THRUST_PREVENT_MACRO_SUBSTITUTION
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..509f210f12ed20052b8dc5ce832303dca4eb6847
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.h
@@ -0,0 +1,72 @@
+/*
+ *  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
+
+template <typename System, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy(const thrust::detail::execution_policy_base<System>& system,
+     InputIterator first,
+     InputIterator last,
+     OutputIterator result);
+
+template <typename System, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy_n(const thrust::detail::execution_policy_base<System>& system, InputIterator first, Size n, OutputIterator result);
+
+template <typename InputIterator, typename OutputIterator>
+OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
+
+template <typename InputIterator, typename Size, typename OutputIterator>
+OutputIterator copy_n(InputIterator first, Size n, OutputIterator result);
+
+namespace detail
+{
+
+template <typename FromSystem, typename ToSystem, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy(
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& two_system,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result);
+
+template <typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy_n(
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& two_system,
+  InputIterator first,
+  Size n,
+  OutputIterator result);
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.inl
new file mode 100644
index 0000000000000000000000000000000000000000..102eb456c5c729e99c96b787f1648d965ab47b84
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.inl
@@ -0,0 +1,123 @@
+/*
+ *  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/copy.h>
+#include <thrust/system/detail/adl/copy.h>
+#include <thrust/system/detail/generic/copy.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+     InputIterator first,
+     InputIterator last,
+     OutputIterator result)
+{
+  using thrust::system::detail::generic::copy;
+  return copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end copy()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator copy_n(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, InputIterator first, Size n, OutputIterator result)
+{
+  using thrust::system::detail::generic::copy_n;
+  return copy_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, result);
+} // end copy_n()
+
+namespace detail
+{
+
+_CCCL_EXEC_CHECK_DISABLE // because we might call e.g. std::ostream_iterator's constructor
+template <typename System1, typename System2, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy(
+  const thrust::execution_policy<System1>& system1,
+  const thrust::execution_policy<System2>& system2,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  return thrust::copy(
+    select_system(thrust::detail::derived_cast(thrust::detail::strip_const(system1)),
+                  thrust::detail::derived_cast(thrust::detail::strip_const(system2))),
+    first,
+    last,
+    result);
+} // end two_system_copy()
+
+_CCCL_EXEC_CHECK_DISABLE // because we might call e.g. std::ostream_iterator's constructor
+template <typename System1, typename System2, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy_n(
+  const thrust::execution_policy<System1>& system1,
+  const thrust::execution_policy<System2>& system2,
+  InputIterator first,
+  Size n,
+  OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  return thrust::copy_n(
+    select_system(thrust::detail::derived_cast(thrust::detail::strip_const(system1)),
+                  thrust::detail::derived_cast(thrust::detail::strip_const(system2))),
+    first,
+    n,
+    result);
+} // end two_system_copy_n()
+
+} // namespace detail
+
+template <typename InputIterator, typename OutputIterator>
+OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
+{
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::detail::two_system_copy(system1, system2, first, last, result);
+} // end copy()
+
+template <typename InputIterator, typename Size, typename OutputIterator>
+OutputIterator copy_n(InputIterator first, Size n, OutputIterator result)
+{
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::detail::two_system_copy_n(system1, system2, first, n, result);
+} // end copy_n()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.h
new file mode 100644
index 0000000000000000000000000000000000000000..affb9270e74877389b9e2e9e9d551782c57c3ec7
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.h
@@ -0,0 +1,62 @@
+/*
+ *  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
+
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  Predicate pred);
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator,
+          typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first,
+  InputIterator1 last,
+  InputIterator2 stencil,
+  OutputIterator result,
+  Predicate pred);
+
+template <typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
+
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+OutputIterator
+copy_if(InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy_if.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.inl
new file mode 100644
index 0000000000000000000000000000000000000000..3f18803e462f424dc24efec11642df26a7776133
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.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/detail/copy_if.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/copy_if.h>
+#include <thrust/system/detail/generic/copy_if.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred);
+} // end copy_if()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator,
+          typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first,
+  InputIterator1 last,
+  InputIterator2 stencil,
+  OutputIterator result,
+  Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred);
+} // end copy_if()
+
+template <typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::copy_if(select_system(system1, system2), first, last, result, pred);
+} // end copy_if()
+
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+OutputIterator
+copy_if(InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<InputIterator1>::type;
+  using System2 = typename thrust::iterator_system<InputIterator2>::type;
+  using System3 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::copy_if(select_system(system1, system2, system3), first, last, stencil, result, pred);
+} // end copy_if()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/count.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5ce2e2b30b911a03b18729c4e6cc4483b1fc05e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/count.h
@@ -0,0 +1,56 @@
+/*
+ *  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
+
+template <typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+_CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+count(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+      InputIterator first,
+      InputIterator last,
+      const EqualityComparable& value);
+
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+         InputIterator first,
+         InputIterator last,
+         Predicate pred);
+
+template <typename InputIterator, typename EqualityComparable>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(InputIterator first, InputIterator last, const EqualityComparable& value);
+
+template <typename InputIterator, typename Predicate>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(InputIterator first, InputIterator last, Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/count.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/dependencies_aware_execution_policy.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/dependencies_aware_execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..83eee59c01d9cd0c1cb6cef59b0daacf28179352
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/dependencies_aware_execution_policy.h
@@ -0,0 +1,85 @@
+/*
+ *  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/execute_with_dependencies.h>
+
+#include <tuple>
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <template <typename> class ExecutionPolicyCRTPBase>
+struct CCCL_DEPRECATED dependencies_aware_execution_policy
+{
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(Dependencies&&... dependencies) const
+  {
+    return {capture_as_dependency(THRUST_FWD(dependencies))...};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(std::tuple<Dependencies...>& dependencies) const
+  {
+    return {capture_as_dependency(dependencies)};
+  }
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(std::tuple<Dependencies...>&& dependencies) const
+  {
+    return {capture_as_dependency(std::move(dependencies))};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(Dependencies&&... dependencies) const
+  {
+    return {capture_as_dependency(THRUST_FWD(dependencies))...};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>& dependencies) const
+  {
+    return {capture_as_dependency(dependencies)};
+  }
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>&& dependencies) const
+  {
+    return {capture_as_dependency(std::move(dependencies))};
+  }
+};
+
+} // namespace detail
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/device_malloc.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/device_malloc.inl
new file mode 100644
index 0000000000000000000000000000000000000000..160ff7a3f2c6b2dc08301314aecc8902c9d380e5
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/device_malloc.inl
@@ -0,0 +1,60 @@
+/*
+ *  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/malloc_and_free.h>
+#include <thrust/device_malloc.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+thrust::device_ptr<void> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using system = thrust::iterator_system<thrust::device_ptr<void>>::type;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<void>(thrust::malloc(s, n).get());
+} // end device_malloc()
+
+template <typename T>
+thrust::device_ptr<T> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using system = thrust::iterator_system<thrust::device_ptr<void>>::type;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<T>(thrust::malloc<T>(s, n).get());
+} // end device_malloc()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/distance.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/distance.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7316dfa91dd518181373674df4cc4949ad2780a7
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/distance.inl
@@ -0,0 +1,43 @@
+/*
+ *  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/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename InputIterator>
+inline _CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+distance(InputIterator first, InputIterator last)
+{
+  return thrust::system::detail::generic::distance(first, last);
+} // end distance()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/execute_with_allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/execute_with_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..91c00e1c5486f84d3dd25fddfbe08dc2bb90e45b
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/execute_with_allocator.h
@@ -0,0 +1,122 @@
+/*
+ *  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/execute_with_allocator_fwd.h>
+#include <thrust/detail/integer_math.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename T, typename Allocator, template <typename> class BaseSystem>
+_CCCL_HOST thrust::pair<T*, std::ptrdiff_t>
+get_temporary_buffer(thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system, std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using void_pointer    = typename alloc_traits::void_pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr), n);
+}
+
+template <typename Pointer, typename Allocator, template <typename> class BaseSystem>
+_CCCL_HOST void return_temporary_buffer(
+  thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system, Pointer p, std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using pointer         = typename alloc_traits::pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+  using T               = typename thrust::detail::pointer_traits<Pointer>::element_type;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+template <typename T, template <typename> class BaseSystem, typename Allocator, typename... Dependencies>
+CCCL_DEPRECATED _CCCL_HOST thrust::pair<T*, std::ptrdiff_t> get_temporary_buffer(
+  thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+  std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using void_pointer    = typename alloc_traits::void_pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr), n);
+}
+
+template <typename Pointer, template <typename> class BaseSystem, typename Allocator, typename... Dependencies>
+_CCCL_HOST void return_temporary_buffer(
+  thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+  Pointer p,
+  std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using pointer         = typename alloc_traits::pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+  using T               = typename thrust::detail::pointer_traits<Pointer>::element_type;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/extrema.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/extrema.inl
new file mode 100644
index 0000000000000000000000000000000000000000..1cbf78146e652f829ecca897ccf80373128e89c6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/extrema.inl
@@ -0,0 +1,172 @@
+/*
+ *  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/extrema.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/extrema.h>
+#include <thrust/system/detail/generic/extrema.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator min_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end min_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE ForwardIterator min_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end min_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator max_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end max_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE ForwardIterator max_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end max_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> minmax_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end minmax_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> minmax_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end minmax_element()
+
+template <typename ForwardIterator>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last);
+} // end min_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last, comp);
+} // end min_element()
+
+template <typename ForwardIterator>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last);
+} // end max_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last, comp);
+} // end max_element()
+
+template <typename ForwardIterator>
+thrust::pair<ForwardIterator, ForwardIterator> minmax_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last);
+} // end minmax_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator, ForwardIterator>
+minmax_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last, comp);
+} // end minmax_element()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/actor.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/actor.h
new file mode 100644
index 0000000000000000000000000000000000000000..2de51b62285d083065c282ddff2cc1ac29de450f
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/actor.h
@@ -0,0 +1,221 @@
+/*
+ *  Copyright 2024 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.
+ */
+
+// Portions of this code are derived from
+//
+// Manjunath Kudlur's Carbon library
+//
+// and
+//
+// Based on Boost.Phoenix v1.2
+// Copyright (c) 2001-2002 Joel de Guzman
+
+#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_deduction.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/tuple.h>
+
+#include <cuda/std/type_traits>
+#include <cuda/std/utility>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+// An actor is a node in an expression template
+template <typename Eval>
+struct actor : Eval
+{
+  constexpr actor() = default;
+
+  _CCCL_HOST_DEVICE actor(const Eval& base)
+      : Eval(base)
+  {}
+
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE auto operator()(Ts&&... ts) const -> decltype(Eval::eval(THRUST_FWD(ts)...))
+  {
+    return Eval::eval(THRUST_FWD(ts)...);
+  }
+
+  template <typename T>
+  _CCCL_HOST_DEVICE auto operator=(const T& _1) const -> decltype(do_assign(*this, _1))
+  {
+    return do_assign(*this, _1);
+  }
+};
+
+template <typename T>
+struct is_actor : ::cuda::std::false_type
+{};
+
+template <typename T>
+struct is_actor<actor<T>> : ::cuda::std::true_type
+{};
+
+// a node selecting and returning one of the arguments to the entire expression template
+template <unsigned int Pos>
+struct argument
+{
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE auto
+  eval(Ts&&... args) const -> decltype(thrust::get<Pos>(thrust::tuple<Ts&&...>{THRUST_FWD(args)...}))
+  {
+    return thrust::get<Pos>(thrust::tuple<Ts&&...>{THRUST_FWD(args)...});
+  }
+};
+
+template <unsigned int Pos>
+struct placeholder
+{
+  using type = actor<argument<Pos>>;
+};
+
+// composition of actors/nodes
+template <typename...>
+struct composite;
+
+template <typename Eval, typename SubExpr>
+struct composite<Eval, SubExpr>
+{
+  constexpr composite() = default;
+
+  // TODO(bgruber): drop ctor and use aggregate initialization in C++17
+  _CCCL_HOST_DEVICE composite(const Eval& eval, const SubExpr& subexpr)
+      : m_eval(eval)
+      , m_subexpr(subexpr)
+  {}
+
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE auto eval(Ts&&... args) const
+    -> decltype(::cuda::std::declval<Eval>().eval(::cuda::std::declval<SubExpr>().eval(THRUST_FWD(args)...)))
+  {
+    return m_eval.eval(m_subexpr.eval(THRUST_FWD(args)...));
+  }
+
+private:
+  Eval m_eval;
+  SubExpr m_subexpr;
+};
+
+template <typename Eval, typename SubExpr1, typename SubExpr2>
+struct composite<Eval, SubExpr1, SubExpr2>
+{
+  constexpr composite() = default;
+
+  // TODO(bgruber): drop ctor and use aggregate initialization in C++17
+  _CCCL_HOST_DEVICE composite(const Eval& eval, const SubExpr1& subexpr1, const SubExpr2& subexpr2)
+      : m_eval(eval)
+      , m_subexpr1(subexpr1)
+      , m_subexpr2(subexpr2)
+  {}
+
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE auto eval(Ts&&... args) const
+    -> decltype(::cuda::std::declval<Eval>().eval(::cuda::std::declval<SubExpr1>().eval(THRUST_FWD(args)...),
+                                                  ::cuda::std::declval<SubExpr2>().eval(THRUST_FWD(args)...)))
+  {
+    return m_eval.eval(m_subexpr1.eval(THRUST_FWD(args)...), m_subexpr2.eval(THRUST_FWD(args)...));
+  }
+
+private:
+  Eval m_eval;
+  SubExpr1 m_subexpr1;
+  SubExpr2 m_subexpr2;
+};
+
+template <typename Eval>
+struct actor;
+
+// Adapts a transparent unary functor from functional.h (e.g. thrust::negate<>) into the Eval interface.
+template <typename F>
+struct operator_adaptor : F
+{
+  constexpr operator_adaptor() = default;
+
+  _CCCL_HOST_DEVICE operator_adaptor(F f)
+      : F(::cuda::std::move(f))
+  {}
+
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE auto eval(Ts&&... args) const -> decltype(F{}(THRUST_FWD(args)...))
+  {
+    return static_cast<const F&>(*this)(THRUST_FWD(args)...);
+  }
+};
+
+// a node returning a fixed value
+template <typename T>
+struct value
+{
+  T m_val;
+
+  template <typename... Ts>
+  _CCCL_HOST_DEVICE T eval(Ts&&...) const
+  {
+    return m_val;
+  }
+};
+
+template <typename T>
+_CCCL_HOST_DEVICE auto make_actor(T&& x) -> actor<value<::cuda::std::decay_t<T>>>
+{
+  return {{THRUST_FWD(x)}};
+}
+
+template <typename Eval>
+_CCCL_HOST_DEVICE auto make_actor(actor<Eval> x) -> actor<Eval>
+{
+  return x;
+}
+
+template <typename Eval, typename SubExpr>
+_CCCL_HOST_DEVICE auto compose(Eval e, const SubExpr& subexpr)
+  -> decltype(actor<composite<operator_adaptor<Eval>, decltype(make_actor(subexpr))>>{
+    {{::cuda::std::move(e)}, make_actor(subexpr)}})
+{
+  return actor<composite<operator_adaptor<Eval>, decltype(make_actor(subexpr))>>{
+    {{::cuda::std::move(e)}, make_actor(subexpr)}};
+}
+
+template <typename Eval, typename SubExpr1, typename SubExpr2>
+_CCCL_HOST_DEVICE auto compose(Eval e, const SubExpr1& subexpr1, const SubExpr2& subexpr2)
+  -> decltype(actor<composite<operator_adaptor<Eval>, decltype(make_actor(subexpr1)), decltype(make_actor(subexpr2))>>{
+    {{::cuda::std::move(e)}, make_actor(subexpr1), make_actor(subexpr2)}})
+{
+  return actor<composite<operator_adaptor<Eval>, decltype(make_actor(subexpr1)), decltype(make_actor(subexpr2))>>{
+    {{::cuda::std::move(e)}, make_actor(subexpr1), make_actor(subexpr2)}};
+}
+} // namespace functional
+
+template <typename Eval, typename... Args>
+struct result_of_adaptable_function<functional::actor<Eval>(Args...)>
+{
+  using type = decltype(::cuda::std::declval<functional::actor<Eval>>()(::cuda::std::declval<Args>()...));
+};
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/operators.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..f4f89f5f7d7ac602fa215584eb93c22224e5a3b0
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/functional/operators.h
@@ -0,0 +1,387 @@
+/*
+ *  Copyright 2024 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.
+ */
+
+// Portions of this code are derived from
+//
+// Manjunath Kudlur's Carbon library
+//
+// and
+//
+// Based on Boost.Phoenix v1.2
+// Copyright (c) 2001-2002 Joel de Guzman
+
+#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/result_of_adaptable_function.h>
+#include <thrust/functional.h>
+#include <thrust/tuple.h>
+
+#include <cuda/std/type_traits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+// there's no standard plus_equal functional, so roll an ad hoc one here
+struct plus_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) += THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) += THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) += THRUST_FWD(t2);
+  }
+};
+
+// there's no standard minus_equal functional, so roll an ad hoc one here
+struct minus_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) -= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) -= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) -= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard multiplies_equal functional, so roll an ad hoc one here
+struct multiplies_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) *= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) *= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) *= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard divides_equal functional, so roll an ad hoc one here
+struct divides_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) /= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) /= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) /= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard modulus_equal functional, so roll an ad hoc one here
+struct modulus_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) %= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) %= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) %= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_and_equal functional, so roll an ad hoc one here
+struct bit_and_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) &= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) &= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) &= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_or_equal functional, so roll an ad hoc one here
+struct bit_or_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) |= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) |= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) |= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_xor_equal functional, so roll an ad hoc one here
+struct bit_xor_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) ^= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) ^= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) ^= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_lshift_equal functional, so roll an ad hoc one here
+struct bit_lshift_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) <<= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) <<= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) <<= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_rshift_equal functional, so roll an ad hoc one here
+struct bit_rshift_equal
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) >>= THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) >>= THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) >>= THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_lshift functional, so roll an ad hoc one here
+struct bit_lshift
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) << THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) << THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) << THRUST_FWD(t2);
+  }
+};
+
+// there's no standard bit_rshift functional, so roll an ad hoc one here
+struct bit_rshift
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1& t1, T2&& t2) const
+    noexcept(noexcept(THRUST_FWD(t1) >> THRUST_FWD(t2))) -> decltype(THRUST_FWD(t1) >> THRUST_FWD(t2))
+  {
+    return THRUST_FWD(t1) >> THRUST_FWD(t2);
+  }
+};
+
+#define MAKE_BINARY_COMPOSITE(op, functor)                                                                       \
+  template <typename A, typename B, ::cuda::std::enable_if_t<is_actor<A>::value || is_actor<B>::value, int> = 0> \
+  _CCCL_HOST_DEVICE auto operator op(const A& a, const B& b)->decltype(compose(functor{}, a, b))                 \
+  {                                                                                                              \
+    return compose(functor{}, a, b);                                                                             \
+  }
+
+MAKE_BINARY_COMPOSITE(==, thrust::equal_to<>)
+MAKE_BINARY_COMPOSITE(!=, thrust::not_equal_to<>)
+MAKE_BINARY_COMPOSITE(<, thrust::less<>)
+MAKE_BINARY_COMPOSITE(<=, thrust::less_equal<>)
+MAKE_BINARY_COMPOSITE(>, thrust::greater<>)
+MAKE_BINARY_COMPOSITE(>=, thrust::greater_equal<>)
+
+MAKE_BINARY_COMPOSITE(+, thrust::plus<>)
+MAKE_BINARY_COMPOSITE(-, thrust::minus<>)
+MAKE_BINARY_COMPOSITE(*, thrust::multiplies<>)
+MAKE_BINARY_COMPOSITE(/, thrust::divides<>)
+MAKE_BINARY_COMPOSITE(%, thrust::modulus<>)
+
+MAKE_BINARY_COMPOSITE(+=, plus_equal)
+MAKE_BINARY_COMPOSITE(-=, minus_equal)
+MAKE_BINARY_COMPOSITE(*=, multiplies_equal)
+MAKE_BINARY_COMPOSITE(/=, divides_equal)
+MAKE_BINARY_COMPOSITE(%=, modulus_equal)
+
+MAKE_BINARY_COMPOSITE(&&, thrust::logical_and<>)
+MAKE_BINARY_COMPOSITE(||, thrust::logical_or<>)
+
+MAKE_BINARY_COMPOSITE(&, thrust::bit_and<>)
+MAKE_BINARY_COMPOSITE(|, thrust::bit_or<>)
+MAKE_BINARY_COMPOSITE(^, thrust::bit_xor<>)
+MAKE_BINARY_COMPOSITE(<<, bit_lshift)
+MAKE_BINARY_COMPOSITE(>>, bit_rshift)
+
+MAKE_BINARY_COMPOSITE(&=, bit_and_equal)
+MAKE_BINARY_COMPOSITE(|=, bit_or_equal)
+MAKE_BINARY_COMPOSITE(^=, bit_xor_equal)
+MAKE_BINARY_COMPOSITE(<<=, bit_lshift_equal)
+MAKE_BINARY_COMPOSITE(>>=, bit_rshift_equal)
+
+#undef MAKE_BINARY_COMPOSITE
+
+// there's no standard unary_plus functional, so roll an ad hoc one here
+struct unary_plus
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(+THRUST_FWD(t1))) -> decltype(+THRUST_FWD(t1))
+  {
+    return +THRUST_FWD(t1);
+  }
+};
+
+// there's no standard prefix_increment functional, so roll an ad hoc one here
+struct prefix_increment
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(++THRUST_FWD(t1))) -> decltype(++THRUST_FWD(t1))
+  {
+    return ++THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+// there's no standard postfix_increment functional, so roll an ad hoc one here
+struct postfix_increment
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(THRUST_FWD(t1)++)) -> decltype(THRUST_FWD(t1)++)
+  {
+    return THRUST_FWD(t1)++;
+  }
+}; // end postfix_increment
+
+// there's no standard prefix_decrement functional, so roll an ad hoc one here
+struct prefix_decrement
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(--THRUST_FWD(t1))) -> decltype(--THRUST_FWD(t1))
+  {
+    return --THRUST_FWD(t1);
+  }
+}; // end prefix_decrement
+
+// there's no standard postfix_decrement functional, so roll an ad hoc one here
+struct postfix_decrement
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(THRUST_FWD(t1)--)) -> decltype(THRUST_FWD(t1)--)
+  {
+    return THRUST_FWD(t1)--;
+  }
+}; // end prefix_increment
+
+// there's no standard bit_not functional, so roll an ad hoc one here
+struct bit_not
+{
+  using is_transparent = void;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1) const
+    noexcept(noexcept(~THRUST_FWD(t1))) -> decltype(~THRUST_FWD(t1))
+  {
+    return ~THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+#define MAKE_UNARY_COMPOSITE(op, functor)                                         \
+  template <typename A, ::cuda::std::enable_if_t<is_actor<A>::value, int> = 0>    \
+  _CCCL_HOST_DEVICE auto operator op(const A& a)->decltype(compose(functor{}, a)) \
+  {                                                                               \
+    return compose(functor{}, a);                                                 \
+  }
+
+MAKE_UNARY_COMPOSITE(+, unary_plus)
+MAKE_UNARY_COMPOSITE(-, thrust::negate<>)
+MAKE_UNARY_COMPOSITE(++, prefix_increment)
+MAKE_UNARY_COMPOSITE(--, prefix_decrement)
+MAKE_UNARY_COMPOSITE(!, thrust::logical_not<>)
+MAKE_UNARY_COMPOSITE(~, bit_not)
+
+#undef MAKE_UNARY_COMPOSITE
+
+#define MAKE_UNARY_COMPOSITE_POSTFIX(op, functor)                                      \
+  template <typename A, ::cuda::std::enable_if_t<is_actor<A>::value, int> = 0>         \
+  _CCCL_HOST_DEVICE auto operator op(const A& a, int)->decltype(compose(functor{}, a)) \
+  {                                                                                    \
+    return compose(functor{}, a);                                                      \
+  }
+
+MAKE_UNARY_COMPOSITE_POSTFIX(++, postfix_increment)
+MAKE_UNARY_COMPOSITE_POSTFIX(--, postfix_decrement)
+
+#undef MAKE_UNARY_COMPOSITE_POSTFIX
+
+// there's no standard assign functional, so roll an ad hoc one here
+struct assign
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T1, typename T2>
+  _CCCL_HOST_DEVICE constexpr auto operator()(T1&& t1, T2&& t2) const
+    THRUST_DECLTYPE_RETURNS(THRUST_FWD(t1) = THRUST_FWD(t2))
+};
+
+template <typename Eval, typename T>
+_CCCL_HOST_DEVICE auto do_assign(const actor<Eval>& _1, const T& _2) -> decltype(compose(assign{}, _1, _2))
+{
+  return compose(assign{}, _1, _2);
+}
+} // namespace functional
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/integer_math.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/integer_math.h
new file mode 100644
index 0000000000000000000000000000000000000000..730b0847674f7425512f19bc077c5a36a94b2615
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/integer_math.h
@@ -0,0 +1,131 @@
+/*
+ *  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/type_deduction.h>
+
+#include <cuda/std/type_traits>
+
+#include <limits>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename Integer>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE Integer clz(Integer x)
+{
+  Integer result;
+
+  NV_IF_TARGET(NV_IS_DEVICE,
+               (result = ::__clz(x);),
+               (int num_bits = 8 * sizeof(Integer); int num_bits_minus_one = num_bits - 1; result = num_bits;
+                for (int i = num_bits_minus_one; i >= 0; --i) {
+                  if ((Integer(1) << i) & x)
+                  {
+                    result = num_bits_minus_one - i;
+                    break;
+                  }
+                }));
+
+  return result;
+}
+
+template <typename Integer>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE bool is_power_of_2(Integer x)
+{
+  return 0 == (x & (x - 1));
+}
+
+template <typename T>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE typename std::enable_if<std::is_signed<T>::value, bool>::type is_negative(T x)
+{
+  return x < 0;
+}
+
+template <typename T>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE typename std::enable_if<std::is_unsigned<T>::value, bool>::type is_negative(T)
+{
+  return false;
+}
+
+template <typename Integer>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE bool is_odd(Integer x)
+{
+  return 1 & x;
+}
+
+template <typename Integer>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE Integer log2(Integer x)
+{
+  Integer num_bits           = 8 * sizeof(Integer);
+  Integer num_bits_minus_one = num_bits - 1;
+
+  return num_bits_minus_one - clz(x);
+}
+
+template <typename Integer>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE Integer log2_ri(Integer x)
+{
+  Integer result = log2(x);
+
+  // This is where we round up to the nearest log.
+  if (!is_power_of_2(x))
+  {
+    ++result;
+  }
+
+  return result;
+}
+
+// x/y rounding towards +infinity for integers
+// Used to determine # of blocks/warps etc.
+template <typename Integer0, typename Integer1>
+_CCCL_HOST_DEVICE _CCCL_FORCEINLINE
+  // FIXME: Should use common_type.
+  auto
+  divide_ri(Integer0 const x, Integer1 const y) THRUST_DECLTYPE_RETURNS((x + (y - 1)) / y)
+
+  // x/y rounding towards zero for integers.
+  // Used to determine # of blocks/warps etc.
+  template <typename Integer0, typename Integer1>
+  _CCCL_HOST_DEVICE _CCCL_FORCEINLINE auto divide_rz(Integer0 const x, Integer1 const y) THRUST_DECLTYPE_RETURNS(x / y)
+
+  // Round x towards infinity to the next multiple of y.
+  template <typename Integer0, typename Integer1>
+  _CCCL_HOST_DEVICE _CCCL_FORCEINLINE auto round_i(Integer0 const x, Integer1 const y)
+    THRUST_DECLTYPE_RETURNS(y* divide_ri(x, y))
+
+  // Round x towards 0 to the next multiple of y.
+  template <typename Integer0, typename Integer1>
+  _CCCL_HOST_DEVICE _CCCL_FORCEINLINE auto round_z(Integer0 const x, Integer1 const y)
+    THRUST_DECLTYPE_RETURNS(y* divide_rz(x, y))
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/logical.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/logical.inl
new file mode 100644
index 0000000000000000000000000000000000000000..afe80b6154e155933444b5140f1685a4840251b1
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/logical.inl
@@ -0,0 +1,107 @@
+/*
+ *  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/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/logical.h>
+#include <thrust/system/detail/generic/logical.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+all_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+       InputIterator first,
+       InputIterator last,
+       Predicate pred)
+{
+  using thrust::system::detail::generic::all_of;
+  return all_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end all_of()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+any_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+       InputIterator first,
+       InputIterator last,
+       Predicate pred)
+{
+  using thrust::system::detail::generic::any_of;
+  return any_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end any_of()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+none_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+        InputIterator first,
+        InputIterator last,
+        Predicate pred)
+{
+  using thrust::system::detail::generic::none_of;
+  return none_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end none_of()
+
+template <typename InputIterator, typename Predicate>
+bool all_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<InputIterator>::type;
+
+  System system;
+
+  return thrust::all_of(select_system(system), first, last, pred);
+}
+
+template <typename InputIterator, typename Predicate>
+bool any_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<InputIterator>::type;
+
+  System system;
+
+  return thrust::any_of(select_system(system), first, last, pred);
+}
+
+template <typename InputIterator, typename Predicate>
+bool none_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<InputIterator>::type;
+
+  System system;
+
+  return thrust::none_of(select_system(system), first, last, pred);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/minmax.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/minmax.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff467f5d835566c90154699bbea7dd138e5b56a4
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/minmax.h
@@ -0,0 +1,55 @@
+/*
+ *  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
+
+template <typename T, typename BinaryPredicate>
+_CCCL_HOST_DEVICE T min THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs, BinaryPredicate comp)
+{
+  return comp(rhs, lhs) ? rhs : lhs;
+} // end min()
+
+template <typename T>
+_CCCL_HOST_DEVICE T min THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs)
+{
+  return rhs < lhs ? rhs : lhs;
+} // end min()
+
+template <typename T, typename BinaryPredicate>
+_CCCL_HOST_DEVICE T max THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs, BinaryPredicate comp)
+{
+  return comp(lhs, rhs) ? rhs : lhs;
+} // end max()
+
+template <typename T>
+_CCCL_HOST_DEVICE T max THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs)
+{
+  return lhs < rhs ? rhs : lhs;
+} // end max()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/mpl/math.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/mpl/math.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3c35d38f477fede9ab3fcf70acc589fa8dec5e6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/mpl/math.h
@@ -0,0 +1,164 @@
+/*
+ *  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 math.h
+ *  \brief Math-related metaprogramming functionality.
+ */
+
+#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
+{
+
+namespace mpl
+{
+
+namespace math
+{
+
+namespace detail
+{
+
+// compute the log base-2 of an integer at compile time
+template <unsigned int N, unsigned int Cur>
+struct log2
+{
+  static const unsigned int value = log2<N / 2, Cur + 1>::value;
+};
+
+template <unsigned int Cur>
+struct log2<1, Cur>
+{
+  static const unsigned int value = Cur;
+};
+
+template <unsigned int Cur>
+struct log2<0, Cur>
+{
+  // undefined
+};
+
+} // end namespace detail
+
+template <unsigned int N>
+struct log2
+{
+  static const unsigned int value = detail::log2<N, 0>::value;
+};
+
+template <typename T, T lhs, T rhs>
+struct min
+{
+  static const T value = (lhs < rhs) ? lhs : rhs;
+};
+
+template <typename T, T lhs, T rhs>
+struct max
+{
+  static const T value = (!(lhs < rhs)) ? lhs : rhs;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct mul
+{
+  static const result_type value = x * y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct mod
+{
+  static const result_type value = x % y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct div
+{
+  static const result_type value = x / y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct geq
+{
+  static const bool value = x >= y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct lt
+{
+  static const bool value = x < y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct gt
+{
+  static const bool value = x > y;
+};
+
+template <bool x, bool y>
+struct or_
+{
+  static const bool value = (x || y);
+};
+
+template <typename result_type, result_type x, result_type y>
+struct bit_and
+{
+  static const result_type value = x & y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct plus
+{
+  static const result_type value = x + y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct minus
+{
+  static const result_type value = x - y;
+};
+
+template <typename result_type, result_type x, result_type y>
+struct equal
+{
+  static const bool value = x == y;
+};
+
+template <typename result_type, result_type x>
+struct is_odd
+{
+  static const bool value = x & 1;
+};
+
+} // end namespace math
+
+} // end namespace mpl
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/pointer.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/pointer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9f2fabc24494f3aafa41a9ed63d5980aea7f208
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/pointer.h
@@ -0,0 +1,231 @@
+/*
+ *  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 pointer to a variable which resides in memory associated with a
+ *  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/detail/reference_forward_declaration.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/iterator_adaptor.h>
+
+#include <cuda/std/type_traits>
+
+#include <cstddef>
+#include <ostream>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Element, typename Tag, typename Reference = use_default, typename Derived = use_default>
+class pointer;
+
+// Specialize `thrust::iterator_traits` to avoid problems with the name of
+// pointer's constructor shadowing its nested pointer type. We do this before
+// pointer is defined so the specialization is correctly used inside the
+// definition.
+template <typename Element, typename Tag, typename Reference, typename Derived>
+struct iterator_traits<thrust::pointer<Element, Tag, Reference, Derived>>
+{
+  using pointer           = thrust::pointer<Element, Tag, Reference, Derived>;
+  using iterator_category = typename pointer::iterator_category;
+  using value_type        = typename pointer::value_type;
+  using difference_type   = typename pointer::difference_type;
+  using reference         = typename pointer::reference;
+};
+
+THRUST_NAMESPACE_END
+
+namespace std
+{
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+struct iterator_traits<THRUST_NS_QUALIFIER::pointer<Element, Tag, Reference, Derived>>
+{
+  using pointer           = THRUST_NS_QUALIFIER::pointer<Element, Tag, Reference, Derived>;
+  using iterator_category = typename pointer::iterator_category;
+  using value_type        = typename pointer::value_type;
+  using difference_type   = typename pointer::difference_type;
+  using reference         = typename pointer::reference;
+};
+
+} // namespace std
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// this metafunction computes the type of iterator_adaptor thrust::pointer should inherit from
+template <typename Element, typename Tag, typename Reference, typename Derived>
+struct pointer_base
+{
+  // void pointers should have no element type
+  // note that we remove_cv from the Element type to get the value_type
+  using value_type = typename thrust::detail::eval_if<::cuda::std::is_void<::cuda::std::remove_cvref_t<Element>>::value,
+                                                      thrust::detail::identity_<void>,
+                                                      ::cuda::std::remove_cv<Element>>::type;
+
+  // if no Derived type is given, just use pointer
+  using derived_type =
+    typename thrust::detail::eval_if<::cuda::std::is_same<Derived, use_default>::value,
+                                     thrust::detail::identity_<pointer<Element, Tag, Reference, Derived>>,
+                                     thrust::detail::identity_<Derived>>::type;
+
+  // void pointers should have no reference type
+  // if no Reference type is given, just use reference
+  using reference_type = typename thrust::detail::eval_if<
+    ::cuda::std::is_void<::cuda::std::remove_cvref_t<Element>>::value,
+    thrust::detail::identity_<void>,
+    thrust::detail::eval_if<::cuda::std::is_same<Reference, use_default>::value,
+                            thrust::detail::identity_<reference<Element, derived_type>>,
+                            thrust::detail::identity_<Reference>>>::type;
+
+  using type =
+    thrust::iterator_adaptor<derived_type,
+                             Element*,
+                             value_type,
+                             Tag,
+                             thrust::random_access_traversal_tag,
+                             reference_type,
+                             std::ptrdiff_t>;
+}; // end pointer_base
+
+} // namespace detail
+
+// the base type for all of thrust's tagged pointers.
+// for reasonable pointer-like semantics, derived types should reimplement the following:
+// 1. no-argument constructor
+// 2. constructor from OtherElement *
+// 3. constructor from OtherPointer related by convertibility
+// 4. constructor from OtherPointer to void
+// 5. assignment from OtherPointer related by convertibility
+// These should just call the corresponding members of pointer.
+template <typename Element, typename Tag, typename Reference, typename Derived>
+class pointer : public thrust::detail::pointer_base<Element, Tag, Reference, Derived>::type
+{
+private:
+  using super_t = typename thrust::detail::pointer_base<Element, Tag, Reference, Derived>::type;
+
+  using derived_type = typename thrust::detail::pointer_base<Element, Tag, Reference, Derived>::derived_type;
+
+  // friend iterator_core_access to give it access to dereference
+  friend class thrust::iterator_core_access;
+
+  _CCCL_HOST_DEVICE typename super_t::reference dereference() const;
+
+  // don't provide access to this part of super_t's interface
+  using super_t::base;
+  using typename super_t::base_type;
+
+public:
+  using raw_pointer = typename super_t::base_type;
+
+  // constructors
+
+  _CCCL_HOST_DEVICE pointer();
+
+  // NOTE: This is needed so that Thrust smart pointers can be used in
+  // `std::unique_ptr`.
+  _CCCL_HOST_DEVICE pointer(std::nullptr_t);
+
+  // OtherValue shall be convertible to Value
+  // XXX consider making the pointer implementation a template parameter which defaults to Element *
+  template <typename OtherElement>
+  _CCCL_HOST_DEVICE explicit pointer(OtherElement* ptr);
+
+  // OtherPointer's element_type shall be convertible to Element
+  // OtherPointer's system shall be convertible to Tag
+  template <typename OtherPointer>
+  _CCCL_HOST_DEVICE pointer(
+    const OtherPointer& other,
+    typename thrust::detail::enable_if_pointer_is_convertible<OtherPointer,
+                                                              pointer<Element, Tag, Reference, Derived>>::type* = 0);
+
+  // OtherPointer's element_type shall be void
+  // OtherPointer's system shall be convertible to Tag
+  template <typename OtherPointer>
+  _CCCL_HOST_DEVICE explicit pointer(
+    const OtherPointer& other,
+    typename thrust::detail::
+      enable_if_void_pointer_is_system_convertible<OtherPointer, pointer<Element, Tag, Reference, Derived>>::type* = 0);
+
+  // assignment
+
+  // NOTE: This is needed so that Thrust smart pointers can be used in
+  // `std::unique_ptr`.
+  _CCCL_HOST_DEVICE derived_type& operator=(std::nullptr_t);
+
+  // OtherPointer's element_type shall be convertible to Element
+  // OtherPointer's system shall be convertible to Tag
+  template <typename OtherPointer>
+  _CCCL_HOST_DEVICE
+  typename thrust::detail::enable_if_pointer_is_convertible<OtherPointer, pointer, derived_type&>::type
+  operator=(const OtherPointer& other);
+
+  // observers
+
+  _CCCL_HOST_DEVICE Element* get() const;
+
+  _CCCL_HOST_DEVICE Element* operator->() const;
+
+  // NOTE: This is needed so that Thrust smart pointers can be used in
+  // `std::unique_ptr`.
+  _CCCL_HOST_DEVICE explicit operator bool() const;
+
+  _CCCL_HOST_DEVICE static derived_type
+  pointer_to(typename thrust::detail::pointer_traits_detail::pointer_to_param<Element>::type r)
+  {
+    return thrust::detail::pointer_traits<derived_type>::pointer_to(r);
+  }
+}; // end pointer
+
+// Output stream operator
+template <typename Element, typename Tag, typename Reference, typename Derived, typename charT, typename traits>
+_CCCL_HOST std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const pointer<Element, Tag, Reference, Derived>& p);
+
+// NOTE: This is needed so that Thrust smart pointers can be used in
+// `std::unique_ptr`.
+template <typename Element, typename Tag, typename Reference, typename Derived>
+_CCCL_HOST_DEVICE bool operator==(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+_CCCL_HOST_DEVICE bool operator==(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+_CCCL_HOST_DEVICE bool operator!=(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+_CCCL_HOST_DEVICE bool operator!=(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/pointer.inl>
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/head_flags.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/head_flags.h
new file mode 100644
index 0000000000000000000000000000000000000000..aed28a5a7d3868f0110b6df6a459affa58523b8c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/head_flags.h
@@ -0,0 +1,116 @@
+/*
+ *  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/functional.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename RandomAccessIterator,
+          typename BinaryPredicate = thrust::equal_to<typename thrust::iterator_value<RandomAccessIterator>::type>,
+          typename ValueType       = bool,
+          typename IndexType       = typename thrust::iterator_difference<RandomAccessIterator>::type>
+class head_flags
+{
+public:
+  struct head_flag_functor
+  {
+    BinaryPredicate binary_pred; // this must be the first member for performance reasons
+    RandomAccessIterator iter;
+
+    using result_type = ValueType;
+
+    _CCCL_HOST_DEVICE head_flag_functor(RandomAccessIterator iter, BinaryPredicate binary_pred = {})
+        : binary_pred(binary_pred)
+        , iter(iter)
+    {}
+
+    _CCCL_HOST_DEVICE _CCCL_FORCEINLINE result_type operator()(const IndexType i)
+    {
+      // note that we do not dereference the iterators i <= 0
+      // and therefore do not dereference a bad location at the boundary
+      if (i <= 0)
+      {
+        return true;
+      }
+
+      return !binary_pred(thrust::raw_reference_cast(iter[i]), thrust::raw_reference_cast(iter[i - 1]));
+    }
+  };
+
+public:
+  using iterator = thrust::transform_iterator<head_flag_functor, thrust::counting_iterator<IndexType>>;
+
+  _CCCL_HOST_DEVICE head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred = {})
+      : m_begin(thrust::make_transform_iterator(
+          thrust::counting_iterator<IndexType>(0), head_flag_functor(first, binary_pred)))
+      , m_count(last - first)
+  {}
+
+  _CCCL_HOST_DEVICE iterator begin() const
+  {
+    return m_begin;
+  }
+
+  _CCCL_HOST_DEVICE iterator end() const
+  {
+    return m_begin + m_count;
+  }
+
+  template <typename OtherIndex>
+  _CCCL_HOST_DEVICE typename iterator::reference operator[](OtherIndex i)
+  {
+    return *(begin() + i);
+  }
+
+  _CCCL_SYNTHESIZE_SEQUENCE_ACCESS(head_flags, iterator);
+
+private:
+  iterator m_begin;
+  IndexType m_count;
+};
+
+template <typename RandomAccessIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE head_flags<RandomAccessIterator, BinaryPredicate>
+make_head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+{
+  return head_flags<RandomAccessIterator, BinaryPredicate>(first, last, binary_pred);
+}
+
+template <typename RandomAccessIterator>
+_CCCL_HOST_DEVICE head_flags<RandomAccessIterator> make_head_flags(RandomAccessIterator first, RandomAccessIterator last)
+{
+  return head_flags<RandomAccessIterator>(first, last);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/tail_flags.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/tail_flags.h
new file mode 100644
index 0000000000000000000000000000000000000000..48470c0f3697c4a32411365c96ac18b177771b29
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/range/tail_flags.h
@@ -0,0 +1,130 @@
+/*
+ *  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/functional.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename RandomAccessIterator,
+          typename BinaryPredicate = thrust::equal_to<typename thrust::iterator_value<RandomAccessIterator>::type>,
+          typename ValueType       = bool,
+          typename IndexType       = typename thrust::iterator_difference<RandomAccessIterator>::type>
+class tail_flags
+{
+  // XXX WAR cudafe bug
+  // private:
+
+public:
+  struct tail_flag_functor
+  {
+    BinaryPredicate binary_pred; // this must be the first member for performance reasons
+    RandomAccessIterator iter;
+    IndexType n;
+
+    using result_type = ValueType;
+
+    _CCCL_HOST_DEVICE tail_flag_functor(RandomAccessIterator first, RandomAccessIterator last)
+        : binary_pred()
+        , iter(first)
+        , n(last - first)
+    {}
+
+    _CCCL_HOST_DEVICE
+    tail_flag_functor(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+        : binary_pred(binary_pred)
+        , iter(first)
+        , n(last - first)
+    {}
+
+    _CCCL_HOST_DEVICE _CCCL_FORCEINLINE result_type operator()(const IndexType& i)
+    {
+      return (i == (n - 1) || !binary_pred(iter[i], iter[i + 1]));
+    }
+  };
+
+  using counting_iterator = thrust::counting_iterator<IndexType>;
+
+public:
+  using iterator = thrust::transform_iterator<tail_flag_functor, counting_iterator>;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE tail_flags(RandomAccessIterator first, RandomAccessIterator last)
+      : m_begin(
+          thrust::make_transform_iterator(thrust::counting_iterator<IndexType>(0), tail_flag_functor(first, last)))
+      , m_end(m_begin + (last - first))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE tail_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+      : m_begin(thrust::make_transform_iterator(
+          thrust::counting_iterator<IndexType>(0), tail_flag_functor(first, last, binary_pred)))
+      , m_end(m_begin + (last - first))
+  {}
+
+  _CCCL_HOST_DEVICE iterator begin() const
+  {
+    return m_begin;
+  }
+
+  _CCCL_HOST_DEVICE iterator end() const
+  {
+    return m_end;
+  }
+
+  template <typename OtherIndex>
+  _CCCL_HOST_DEVICE typename iterator::reference operator[](OtherIndex i)
+  {
+    return *(begin() + i);
+  }
+
+  _CCCL_SYNTHESIZE_SEQUENCE_ACCESS(tail_flags, iterator);
+
+private:
+  iterator m_begin, m_end;
+};
+
+template <typename RandomAccessIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE tail_flags<RandomAccessIterator, BinaryPredicate>
+make_tail_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+{
+  return tail_flags<RandomAccessIterator, BinaryPredicate>(first, last, binary_pred);
+}
+
+template <typename RandomAccessIterator>
+_CCCL_HOST_DEVICE tail_flags<RandomAccessIterator> make_tail_flags(RandomAccessIterator first, RandomAccessIterator last)
+{
+  return tail_flags<RandomAccessIterator>(first, last);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/raw_pointer_cast.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/raw_pointer_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..6db6acf8c4e983781b57e02d63164614a2dc19dc
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/raw_pointer_cast.h
@@ -0,0 +1,52 @@
+/*
+ *  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/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Pointer>
+_CCCL_HOST_DEVICE typename thrust::detail::pointer_traits<Pointer>::raw_pointer raw_pointer_cast(Pointer ptr)
+{
+  return thrust::detail::pointer_traits<Pointer>::get(ptr);
+}
+
+template <typename ToPointer, typename FromPointer>
+_CCCL_HOST_DEVICE ToPointer reinterpret_pointer_cast(FromPointer ptr)
+{
+  using to_element = typename thrust::detail::pointer_element<ToPointer>::type;
+  return ToPointer(reinterpret_cast<to_element*>(thrust::raw_pointer_cast(ptr)));
+}
+
+template <typename ToPointer, typename FromPointer>
+_CCCL_HOST_DEVICE ToPointer static_pointer_cast(FromPointer ptr)
+{
+  using to_element = typename thrust::detail::pointer_element<ToPointer>::type;
+  return ToPointer(static_cast<to_element*>(thrust::raw_pointer_cast(ptr)));
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7480d2919ede24ead194651212e8ead373dfac9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference.h
@@ -0,0 +1,502 @@
+/*
+ *  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
+ *  \brief A pointer to a variable which resides in memory associated with a
+ *  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/detail/reference_forward_declaration.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/assign_value.h>
+#include <thrust/system/detail/adl/get_value.h>
+#include <thrust/system/detail/adl/iter_swap.h>
+#include <thrust/system/detail/generic/memory.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+#include <cuda/std/type_traits>
+
+#include <ostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+template <typename>
+struct is_wrapped_reference;
+}
+
+/*! \p reference acts as a reference-like wrapper for an object residing in
+ *  memory that a \p pointer refers to.
+ */
+template <typename Element, typename Pointer, typename Derived>
+class reference
+{
+private:
+  using derived_type = typename std::conditional<std::is_same<Derived, use_default>::value, reference, Derived>::type;
+
+public:
+  using pointer    = Pointer;
+  using value_type = ::cuda::std::remove_cvref_t<Element>;
+
+  reference(reference const&) = default;
+
+  reference(reference&&) = default;
+
+  /*! Construct a \p reference from another \p reference whose pointer type is
+   *  convertible to \p pointer. After this \p reference is constructed, it
+   *  shall refer to the same object as \p other.
+   *
+   *  \tparam OtherElement The element type of the other \p reference.
+   *  \tparam OtherPointer The pointer type of the other \p reference.
+   *  \tparam OtherDerived The derived type of the other \p reference.
+   *  \param  other        A \p reference to copy from.
+   */
+  template <typename OtherElement, typename OtherPointer, typename OtherDerived>
+  _CCCL_HOST_DEVICE reference(
+    reference<OtherElement, OtherPointer, OtherDerived> const& other
+    /*! \cond
+     */
+    ,
+    typename std::enable_if<std::is_convertible<typename reference<OtherElement, OtherPointer, OtherDerived>::pointer,
+                                                pointer>::value>::type* = nullptr
+    /*! \endcond
+     */
+    )
+      : ptr(other.ptr)
+  {}
+
+  /*! Construct a \p reference that refers to an object pointed to by the given
+   *  \p pointer. After this \p reference is constructed, it shall refer to the
+   *  object pointed to by \p ptr.
+   *
+   *  \param ptr A \p pointer to construct from.
+   */
+  _CCCL_HOST_DEVICE explicit reference(pointer const& p)
+      : ptr(p)
+  {}
+
+  /*! Assign the object referred to \p other to the object referred to by
+   *  this \p reference.
+   *
+   *  \param other The other \p reference to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  _CCCL_HOST_DEVICE derived_type& operator=(reference const& other)
+  {
+    assign_from(&other);
+    return derived();
+  }
+
+  /*! Assign the object referred to by this \p reference with the object
+   *  referred to by another \p reference whose pointer type is convertible to
+   *  \p pointer.
+   *
+   *  \tparam OtherElement The element type of the other \p reference.
+   *  \tparam OtherPointer The pointer type of the other \p reference.
+   *  \tparam OtherDerived The derived type of the other \p reference.
+   *  \param  other        The other \p reference to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  template <typename OtherElement, typename OtherPointer, typename OtherDerived>
+  _CCCL_HOST_DEVICE
+  /*! \cond
+   */
+  typename std::enable_if<
+    std::is_convertible<typename reference<OtherElement, OtherPointer, OtherDerived>::pointer, pointer>::value,
+    /*! \endcond
+     */
+    derived_type&
+    /*! \cond
+     */
+    >::type
+  /*! \endcond
+   */
+  operator=(reference<OtherElement, OtherPointer, OtherDerived> const& other)
+  {
+    assign_from(&other);
+    return derived();
+  }
+
+  /*! Assign \p rhs to the object referred to by this \p tagged_reference.
+   *
+   *  \param rhs The \p value_type to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  _CCCL_HOST_DEVICE derived_type& operator=(value_type const& rhs)
+  {
+    assign_from(&rhs);
+    return derived();
+  }
+
+  /*! Exchanges the value of the object referred to by this \p tagged_reference
+   *  with the object referred to by \p other.
+   *
+   *  \param other The \p tagged_reference to swap with.
+   */
+  _CCCL_HOST_DEVICE void swap(derived_type& other)
+  {
+    // Avoid default-constructing a system; instead, just use a null pointer
+    // for dispatch. This assumes that `get_value` will not access any system
+    // state.
+    typename thrust::iterator_system<pointer>::type* system = nullptr;
+    swap(system, other);
+  }
+
+  _CCCL_HOST_DEVICE pointer operator&() const
+  {
+    return ptr;
+  }
+
+  // This is inherently hazardous, as it discards the strong type information
+  // about what system the object is on.
+  _CCCL_HOST_DEVICE operator value_type() const
+  {
+    // Avoid default-constructing a system; instead, just use a null pointer
+    // for dispatch. This assumes that `get_value` will not access any system
+    // state.
+    typename thrust::iterator_system<pointer>::type* system = nullptr;
+    return convert_to_value_type(system);
+  }
+
+  _CCCL_HOST_DEVICE derived_type& operator++()
+  {
+    // Sadly, this has to make a copy. The only mechanism we have for
+    // modifying the value, which may be in memory inaccessible to this
+    // system, is to get a copy of it, modify the copy, and then update it.
+    value_type tmp = *this;
+    ++tmp;
+    *this = tmp;
+    return derived();
+  }
+
+  _CCCL_HOST_DEVICE value_type operator++(int)
+  {
+    value_type tmp    = *this;
+    value_type result = tmp++;
+    *this             = std::move(tmp);
+    return result;
+  }
+
+  derived_type& operator--()
+  {
+    // Sadly, this has to make a copy. The only mechanism we have for
+    // modifying the value, which may be in memory inaccessible to this
+    // system, is to get a copy of it, modify the copy, and then update it.
+    value_type tmp = *this;
+    --tmp;
+    *this = std::move(tmp);
+    return derived();
+  }
+
+  value_type operator--(int)
+  {
+    value_type tmp    = *this;
+    value_type result = tmp--;
+    *this             = std::move(tmp);
+    return derived();
+  }
+
+  _CCCL_HOST_DEVICE derived_type& operator+=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp += rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator-=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp -= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator*=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp *= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator/=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp /= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator%=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp %= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator<<=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp <<= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator>>=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp >>= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator&=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp &= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator|=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp |= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+  derived_type& operator^=(value_type const& rhs)
+  {
+    value_type tmp = *this;
+    tmp ^= rhs;
+    *this = tmp;
+    return derived();
+  }
+
+private:
+  pointer const ptr;
+
+  // `thrust::detail::is_wrapped_reference` is a trait that indicates whether
+  // a type is a fancy reference. It detects such types by looking for a
+  // nested `wrapped_reference_hint` type.
+  struct wrapped_reference_hint
+  {};
+  template <typename>
+  friend struct thrust::detail::is_wrapped_reference;
+
+  template <typename OtherElement, typename OtherPointer, typename OtherDerived>
+  friend class reference;
+
+  _CCCL_HOST_DEVICE derived_type& derived()
+  {
+    return static_cast<derived_type&>(*this);
+  }
+
+  template <typename System>
+  _CCCL_HOST_DEVICE value_type convert_to_value_type(System* system) const
+  {
+    using thrust::system::detail::generic::select_system;
+    return strip_const_get_value(select_system(*system));
+  }
+
+  template <typename System>
+  _CCCL_HOST_DEVICE value_type strip_const_get_value(System const& system) const
+  {
+    System& non_const_system = const_cast<System&>(system);
+
+    using thrust::system::detail::generic::get_value;
+    return get_value(thrust::detail::derived_cast(non_const_system), ptr);
+  }
+
+  template <typename System0, typename System1, typename OtherPointer>
+  _CCCL_HOST_DEVICE void assign_from(System0* system0, System1* system1, OtherPointer src)
+  {
+    using thrust::system::detail::generic::select_system;
+    strip_const_assign_value(select_system(*system0, *system1), src);
+  }
+
+  template <typename OtherPointer>
+  _CCCL_HOST_DEVICE void assign_from(OtherPointer src)
+  {
+    // Avoid default-constructing systems; instead, just use a null pointer
+    // for dispatch. This assumes that `get_value` will not access any system
+    // state.
+    typename thrust::iterator_system<pointer>::type* system0      = nullptr;
+    typename thrust::iterator_system<OtherPointer>::type* system1 = nullptr;
+    assign_from(system0, system1, src);
+  }
+
+  template <typename System, typename OtherPointer>
+  _CCCL_HOST_DEVICE void strip_const_assign_value(System const& system, OtherPointer src)
+  {
+    System& non_const_system = const_cast<System&>(system);
+
+    using thrust::system::detail::generic::assign_value;
+    assign_value(thrust::detail::derived_cast(non_const_system), ptr, src);
+  }
+
+  template <typename System>
+  _CCCL_HOST_DEVICE void swap(System* system, derived_type& other)
+  {
+    using thrust::system::detail::generic::iter_swap;
+    using thrust::system::detail::generic::select_system;
+
+    iter_swap(select_system(*system, *system), ptr, other.ptr);
+  }
+};
+
+template <typename Pointer, typename Derived>
+class reference<void, Pointer, Derived>
+{};
+
+template <typename Pointer, typename Derived>
+class reference<void const, Pointer, Derived>
+{};
+
+template <typename Element, typename Pointer, typename Derived, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, reference<Element, Pointer, Derived> const& r)
+{
+  using value_type = typename reference<Element, Pointer, Derived>::value_type;
+  return os << static_cast<value_type>(r);
+}
+
+template <typename Element, typename Tag>
+class tagged_reference;
+
+/*! \p tagged_reference acts as a reference-like wrapper for an object residing
+ *  in memory associated with system \p Tag that a \p pointer refers to.
+ */
+template <typename Element, typename Tag>
+class tagged_reference
+    : public thrust::
+        reference<Element, thrust::pointer<Element, Tag, tagged_reference<Element, Tag>>, tagged_reference<Element, Tag>>
+{
+private:
+  using base_type = thrust::
+    reference<Element, thrust::pointer<Element, Tag, tagged_reference<Element, Tag>>, tagged_reference<Element, Tag>>;
+
+public:
+  using value_type = typename base_type::value_type;
+  using pointer    = typename base_type::pointer;
+
+  tagged_reference(tagged_reference const&) = default;
+
+  tagged_reference(tagged_reference&&) = default;
+
+  /*! Construct a \p tagged_reference from another \p tagged_reference whose
+   *  pointer type is convertible to \p pointer. After this \p tagged_reference
+   *  is constructed, it shall refer to the same object as \p other.
+   *
+   *  \tparam OtherElement The element type of the other \p tagged_reference.
+   *  \tparam OtherTag     The tag type of the other \p tagged_reference.
+   *  \param  other        A \p tagged_reference to copy from.
+   */
+  template <typename OtherElement, typename OtherTag>
+  _CCCL_HOST_DEVICE tagged_reference(tagged_reference<OtherElement, OtherTag> const& other)
+      : base_type(other)
+  {}
+
+  /*! Construct a \p tagged_reference that refers to an object pointed to by
+   *  the given \p pointer. After this \p tagged_reference is constructed, it
+   *  shall refer to the object pointed to by \p ptr.
+   *
+   *  \param ptr A \p pointer to construct from.
+   */
+  _CCCL_HOST_DEVICE explicit tagged_reference(pointer const& p)
+      : base_type(p)
+  {}
+
+  /*! Assign the object referred to \p other to the object referred to by
+   *  this \p tagged_reference.
+   *
+   *  \param other The other \p tagged_reference to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  _CCCL_HOST_DEVICE tagged_reference& operator=(tagged_reference const& other)
+  {
+    return base_type::operator=(other);
+  }
+
+  /*! Assign the object referred to by this \p tagged_reference with the object
+   *  referred to by another \p tagged_reference whose pointer type is
+   *  convertible to \p pointer.
+   *
+   *  \tparam OtherElement The element type of the other \p tagged_reference.
+   *  \tparam OtherTag     The tag type of the other \p tagged_reference.
+   *  \param  other        The other \p tagged_reference to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  template <typename OtherElement, typename OtherTag>
+  _CCCL_HOST_DEVICE tagged_reference& operator=(tagged_reference<OtherElement, OtherTag> const& other)
+  {
+    return base_type::operator=(other);
+  }
+
+  /*! Assign \p rhs to the object referred to by this \p tagged_reference.
+   *
+   *  \param rhs The \p value_type to assign from.
+   *
+   *  \return <tt>*this</tt>.
+   */
+  _CCCL_HOST_DEVICE tagged_reference& operator=(value_type const& rhs)
+  {
+    return base_type::operator=(rhs);
+  }
+};
+
+template <typename Tag>
+class tagged_reference<void, Tag>
+{};
+
+template <typename Tag>
+class tagged_reference<void const, Tag>
+{};
+
+/*! Exchanges the values of two objects referred to by \p tagged_reference.
+ *
+ *  \param x The first \p tagged_reference of interest.
+ *  \param y The second \p tagged_reference of interest.
+ */
+// note: this is not a hidden friend, because we have template specializations of tagged_reference
+template <typename Element, typename Tag>
+_CCCL_HOST_DEVICE void
+swap(tagged_reference<Element, Tag>& x, tagged_reference<Element, Tag>& y) noexcept(noexcept(x.swap(y)))
+{
+  x.swap(y);
+}
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference_forward_declaration.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference_forward_declaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..eeee0aedc4426005bbe66c057b45542ce26206f0
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reference_forward_declaration.h
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2008-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/detail/use_default.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Element, typename Pointer, typename Derived = use_default>
+class reference;
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reverse.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reverse.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7b7ec8a09cd50141750a3b9ac17fea960f22843c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/reverse.inl
@@ -0,0 +1,84 @@
+/*
+ *  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/iterator/iterator_traits.h>
+#include <thrust/reverse.h>
+#include <thrust/system/detail/adl/reverse.h>
+#include <thrust/system/detail/generic/reverse.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename BidirectionalIterator>
+_CCCL_HOST_DEVICE void reverse(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+                               BidirectionalIterator first,
+                               BidirectionalIterator last)
+{
+  using thrust::system::detail::generic::reverse;
+  return reverse(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end reverse()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename BidirectionalIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator reverse_copy(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  BidirectionalIterator first,
+  BidirectionalIterator last,
+  OutputIterator result)
+{
+  using thrust::system::detail::generic::reverse_copy;
+  return reverse_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end reverse_copy()
+
+template <typename BidirectionalIterator>
+void reverse(BidirectionalIterator first, BidirectionalIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<BidirectionalIterator>::type;
+
+  System system;
+
+  return thrust::reverse(select_system(system), first, last);
+} // end reverse()
+
+template <typename BidirectionalIterator, typename OutputIterator>
+OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<BidirectionalIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::reverse_copy(select_system(system1, system2), first, last, result);
+} // end reverse_copy()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/swap_ranges.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/swap_ranges.inl
new file mode 100644
index 0000000000000000000000000000000000000000..fd3d988266506eee6a1c106d335136972bed5e94
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/swap_ranges.inl
@@ -0,0 +1,63 @@
+/*
+ *  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/iterator/iterator_traits.h>
+#include <thrust/swap.h>
+#include <thrust/system/detail/adl/swap_ranges.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/swap_ranges.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator1, typename ForwardIterator2>
+_CCCL_HOST_DEVICE ForwardIterator2 swap_ranges(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator1 first1,
+  ForwardIterator1 last1,
+  ForwardIterator2 first2)
+{
+  using thrust::system::detail::generic::swap_ranges;
+  return swap_ranges(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2);
+} // end swap_ranges()
+
+template <typename ForwardIterator1, typename ForwardIterator2>
+ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<ForwardIterator1>::type;
+  using System2 = typename thrust::iterator_system<ForwardIterator2>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::swap_ranges(select_system(system1, system2), first1, last1, first2);
+} // end swap_ranges()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/temporary_buffer.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/temporary_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..11f26e0ac1480f77c18ac81b1d58829c820751e3
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/temporary_buffer.h
@@ -0,0 +1,81 @@
+/*
+ *  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/execute_with_allocator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/pair.h>
+#include <thrust/system/detail/adl/temporary_buffer.h>
+#include <thrust/system/detail/generic/temporary_buffer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename DerivedPolicy, typename Pair>
+_CCCL_HOST_DEVICE
+thrust::pair<thrust::pointer<T, DerivedPolicy>, typename thrust::pointer<T, DerivedPolicy>::difference_type>
+down_cast_pair(Pair p)
+{
+  // XXX should use a hypothetical thrust::static_pointer_cast here
+  thrust::pointer<T, DerivedPolicy> ptr =
+    thrust::pointer<T, DerivedPolicy>(static_cast<T*>(thrust::raw_pointer_cast(p.first)));
+
+  using result_type =
+    thrust::pair<thrust::pointer<T, DerivedPolicy>, typename thrust::pointer<T, DerivedPolicy>::difference_type>;
+  return result_type(ptr, p.second);
+} // end down_cast_pair()
+
+} // namespace detail
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename T, typename DerivedPolicy>
+_CCCL_HOST_DEVICE
+thrust::pair<thrust::pointer<T, DerivedPolicy>, typename thrust::pointer<T, DerivedPolicy>::difference_type>
+get_temporary_buffer(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+                     typename thrust::pointer<T, DerivedPolicy>::difference_type n)
+{
+  using thrust::detail::get_temporary_buffer; // execute_with_allocator
+  using thrust::system::detail::generic::get_temporary_buffer;
+
+  return thrust::detail::down_cast_pair<T, DerivedPolicy>(
+    get_temporary_buffer<T>(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n));
+} // end get_temporary_buffer()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename Pointer>
+_CCCL_HOST_DEVICE void
+return_temporary_buffer(const thrust::detail::execution_policy_base<DerivedPolicy>& exec, Pointer p, std::ptrdiff_t n)
+{
+  using thrust::detail::return_temporary_buffer; // execute_with_allocator
+  using thrust::system::detail::generic::return_temporary_buffer;
+
+  return return_temporary_buffer(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), p, n);
+} // end return_temporary_buffer()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/transform_scan.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/transform_scan.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f36fe9e348786e974bbdb6532e81a74ad34a584d
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/transform_scan.inl
@@ -0,0 +1,155 @@
+/*
+ *  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/iterator/iterator_traits.h>
+#include <thrust/scan.h>
+#include <thrust/system/detail/adl/transform_scan.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform_scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename UnaryFunction,
+          typename AssociativeOperator>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename UnaryFunction,
+          typename T,
+          typename AssociativeOperator>
+_CCCL_HOST_DEVICE OutputIterator transform_inclusive_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_inclusive_scan;
+  return transform_inclusive_scan(
+    thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, init, binary_op);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename UnaryFunction,
+          typename T,
+          typename AssociativeOperator>
+_CCCL_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;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  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_inclusive_scan(
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  UnaryFunction unary_op,
+  T init,
+  AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_inclusive_scan(
+    select_system(system1, system2), first, last, result, unary_op, init, 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;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  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/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/tuple_transform.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/tuple_transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..49ccdf11cdd79b7498f4571d7270700ad80a3cac
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/tuple_transform.h
@@ -0,0 +1,79 @@
+/*
+ *  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/tuple_meta_transform.h>
+#include <thrust/tuple.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 _CCCL_HOST typename tuple_meta_transform<Tuple, UnaryMetaFunction>::type
+  do_it_on_the_host(const Tuple& t, UnaryFunction f)
+  {
+    using XfrmTuple = typename tuple_meta_transform<Tuple, UnaryMetaFunction>::type;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+
+  static _CCCL_HOST_DEVICE typename tuple_meta_transform<Tuple, UnaryMetaFunction>::type
+  do_it_on_the_host_or_device(const Tuple& t, UnaryFunction f)
+  {
+    using XfrmTuple = typename tuple_meta_transform<Tuple, UnaryMetaFunction>::type;
+
+    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 _CCCL_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);
+}
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_deduction.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_deduction.h
new file mode 100644
index 0000000000000000000000000000000000000000..717edc366ee223afe61cc48ad892fe43d9b8ae4e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_deduction.h
@@ -0,0 +1,102 @@
+// 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/preprocessor.h>
+
+#include <type_traits>
+#include <utility>
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \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.
+/// deprecated [Since 2.8]
+#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.
+/// deprecated [Since 2.8]
+#define THRUST_RETOF(...) THRUST_PP_DISPATCH(THRUST_RETOF, __VA_ARGS__)
+/// deprecated [Since 2.8]
+#define THRUST_RETOF1(C) decltype(::std::declval<C>()())
+/// deprecated [Since 2.8]
+#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(_CCCL_DOXYGEN_INVOKED)
+#  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(_CCCL_DOXYGEN_INVOKED)
+#  define THRUST_DECLTYPE_RETURNS(...) \
+    {                                  \
+      return (__VA_ARGS__);            \
+    }                                  \
+    /**/
+#else
+/// deprecated [Since 2.8]
+#  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
+
+///////////////////////////////////////////////////////////////////////////////
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/is_call_possible.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/is_call_possible.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdfdeee45cd358409286681448e9dd681809fbc4
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/is_call_possible.h
@@ -0,0 +1,167 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+
+// inspired by Roman Perepelitsa's presentation from comp.lang.c++.moderated
+// based on the implementation here: http://www.rsdn.ru/forum/cpp/2759773.1.aspx
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace is_call_possible_detail
+{
+
+template <typename T>
+class void_exp_result
+{};
+
+template <typename T, typename U>
+U const& operator,(U const&, void_exp_result<T>);
+
+template <typename T, typename U>
+U& operator,(U&, void_exp_result<T>);
+
+template <typename src_type, typename dest_type>
+struct clone_constness
+{
+  using type = dest_type;
+};
+
+template <typename src_type, typename dest_type>
+struct clone_constness<const src_type, dest_type>
+{
+  using type = const dest_type;
+};
+
+} // namespace is_call_possible_detail
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#define __THRUST_DEFINE_IS_CALL_POSSIBLE(trait_name, member_function_name)                                             \
+  __THRUST_DEFINE_HAS_MEMBER_FUNCTION(trait_name##_has_member, member_function_name)                                   \
+                                                                                                                       \
+  template <typename T, typename Signature>                                                                            \
+  struct trait_name                                                                                                    \
+  {                                                                                                                    \
+  private:                                                                                                             \
+    struct yes                                                                                                         \
+    {};                                                                                                                \
+    struct no                                                                                                          \
+    {                                                                                                                  \
+      yes m[2];                                                                                                        \
+    };                                                                                                                 \
+    struct derived : public T                                                                                          \
+    {                                                                                                                  \
+      using T::member_function_name;                                                                                   \
+      no member_function_name(...) const;                                                                              \
+    };                                                                                                                 \
+                                                                                                                       \
+    using derived_type = typename thrust::detail::is_call_possible_detail::clone_constness<T, derived>::type;          \
+                                                                                                                       \
+    template <typename U, typename Result>                                                                             \
+    struct return_value_check                                                                                          \
+    {                                                                                                                  \
+      static yes deduce(Result);                                                                                       \
+      static no deduce(...);                                                                                           \
+      static no deduce(no);                                                                                            \
+      static no deduce(thrust::detail::is_call_possible_detail::void_exp_result<T>);                                   \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <typename U>                                                                                              \
+    struct return_value_check<U, void>                                                                                 \
+    {                                                                                                                  \
+      static yes deduce(...);                                                                                          \
+      static no deduce(no);                                                                                            \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <bool has_the_member_of_interest, typename F>                                                             \
+    struct impl                                                                                                        \
+    {                                                                                                                  \
+      static const bool value = false;                                                                                 \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <typename Result, typename Arg>                                                                           \
+    struct impl<true, Result(Arg)>                                                                                     \
+    {                                                                                                                  \
+      static ::cuda::std::add_lvalue_reference_t<derived_type> test_me;                                                \
+      static ::cuda::std::add_lvalue_reference_t<Arg> arg;                                                             \
+                                                                                                                       \
+      static const bool value =                                                                                        \
+        sizeof(return_value_check<T, Result>::deduce(                                                                  \
+          (test_me.member_function_name(arg), thrust::detail::is_call_possible_detail::void_exp_result<T>())))         \
+        == sizeof(yes);                                                                                                \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <typename Result, typename Arg1, typename Arg2>                                                           \
+    struct impl<true, Result(Arg1, Arg2)>                                                                              \
+    {                                                                                                                  \
+      static ::cuda::std::add_lvalue_reference_t<derived_type> test_me;                                                \
+      static ::cuda::std::add_lvalue_reference_t<Arg1> arg1;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg2> arg2;                                                           \
+                                                                                                                       \
+      static const bool value =                                                                                        \
+        sizeof(return_value_check<T, Result>::deduce(                                                                  \
+          (test_me.member_function_name(arg1, arg2), thrust::detail::is_call_possible_detail::void_exp_result<T>())))  \
+        == sizeof(yes);                                                                                                \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <typename Result, typename Arg1, typename Arg2, typename Arg3>                                            \
+    struct impl<true, Result(Arg1, Arg2, Arg3)>                                                                        \
+    {                                                                                                                  \
+      static ::cuda::std::add_lvalue_reference_t<derived_type> test_me;                                                \
+      static ::cuda::std::add_lvalue_reference_t<Arg1> arg1;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg2> arg2;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg3> arg3;                                                           \
+                                                                                                                       \
+      static const bool value =                                                                                        \
+        sizeof(return_value_check<T, Result>::deduce((test_me.member_function_name(arg1, arg2, arg3),                  \
+                                                      thrust::detail::is_call_possible_detail::void_exp_result<T>()))) \
+        == sizeof(yes);                                                                                                \
+    };                                                                                                                 \
+                                                                                                                       \
+    template <typename Result, typename Arg1, typename Arg2, typename Arg3, typename Arg4>                             \
+    struct impl<true, Result(Arg1, Arg2, Arg3, Arg4)>                                                                  \
+    {                                                                                                                  \
+      static ::cuda::std::add_lvalue_reference_t<derived_type> test_me;                                                \
+      static ::cuda::std::add_lvalue_reference_t<Arg1> arg1;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg2> arg2;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg3> arg3;                                                           \
+      static ::cuda::std::add_lvalue_reference_t<Arg4> arg4;                                                           \
+                                                                                                                       \
+      static const bool value =                                                                                        \
+        sizeof(return_value_check<T, Result>::deduce((test_me.member_function_name(arg1, arg2, arg3, arg4),            \
+                                                      thrust::detail::is_call_possible_detail::void_exp_result<T>()))) \
+        == sizeof(yes);                                                                                                \
+    };                                                                                                                 \
+                                                                                                                       \
+  public:                                                                                                              \
+    static const bool value = impl<trait_name##_has_member<T, Signature>::value, Signature>::value;                    \
+    using type              = thrust::detail::integral_constant<bool, value>;                                          \
+  };
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/iterator/is_output_iterator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/iterator/is_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..2741ca38212461e91d0d708cf092d5252ad98b59
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/iterator/is_output_iterator.h
@@ -0,0 +1,62 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/iterator/detail/any_assign.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename T>
+struct is_void_like
+    : ::cuda::std::disjunction<::cuda::std::is_void<T>, ::cuda::std::is_same<T, thrust::detail::any_assign>>
+{}; // end is_void_like
+
+template <typename T>
+struct lazy_is_void_like : is_void_like<typename T::type>
+{}; // end lazy_is_void_like
+
+// XXX this meta function should first check that T is actually an iterator
+//
+//     if thrust::iterator_value<T> is defined and thrust::iterator_value<T>::type == void
+//       return false
+//     else
+//       return true
+template <typename T>
+struct is_output_iterator
+    : eval_if<is_metafunction_defined<thrust::iterator_value<T>>::value,
+              lazy_is_void_like<thrust::iterator_value<T>>,
+              thrust::detail::true_type>::type
+{}; // end is_output_iterator
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/pointer_traits.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/pointer_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ac54ee7860975cb2c793a21324775be063a72f1
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/type_traits/pointer_traits.h
@@ -0,0 +1,366 @@
+/*
+ *  Copyright 2008-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/detail/type_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/iterator/iterator_traits.h>
+
+#include <cstddef>
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename Ptr>
+struct pointer_element;
+
+template <template <typename...> class Ptr, typename FirstArg, typename... Args>
+struct pointer_element<Ptr<FirstArg, Args...>>
+{
+  using type = FirstArg;
+};
+
+template <typename T>
+struct pointer_element<T*>
+{
+  using type = T;
+};
+
+template <typename Ptr>
+struct pointer_difference
+{
+  using type = typename Ptr::difference_type;
+};
+
+template <typename T>
+struct pointer_difference<T*>
+{
+  using type = std::ptrdiff_t;
+};
+
+template <typename Ptr, typename T>
+struct rebind_pointer;
+
+template <typename T, typename U>
+struct rebind_pointer<T*, U>
+{
+  using type = U*;
+};
+
+// Rebind generic fancy pointers.
+template <template <typename, typename...> class Ptr, typename OldT, typename... Tail, typename T>
+struct rebind_pointer<Ptr<OldT, Tail...>, T>
+{
+  using type = Ptr<T, Tail...>;
+};
+
+// Rebind `thrust::pointer`-like things with `thrust::reference`-like references.
+template <template <typename, typename, typename, typename...> class Ptr,
+          typename OldT,
+          typename Tag,
+          template <typename...>
+          class Ref,
+          typename... RefTail,
+          typename... PtrTail,
+          typename T>
+struct rebind_pointer<Ptr<OldT, Tag, Ref<OldT, RefTail...>, PtrTail...>, T>
+{
+  //  static_assert(std::is_same<OldT, Tag>::value, "0");
+  using type = Ptr<T, Tag, Ref<T, RefTail...>, PtrTail...>;
+};
+
+// Rebind `thrust::pointer`-like things with `thrust::reference`-like references
+// and templated derived types.
+template <template <typename, typename, typename, typename...> class Ptr,
+          typename OldT,
+          typename Tag,
+          template <typename...>
+          class Ref,
+          typename... RefTail,
+          template <typename...>
+          class DerivedPtr,
+          typename... DerivedPtrTail,
+          typename T>
+struct rebind_pointer<Ptr<OldT, Tag, Ref<OldT, RefTail...>, DerivedPtr<OldT, DerivedPtrTail...>>, T>
+{
+  //  static_assert(std::is_same<OldT, Tag>::value, "1");
+  using type = Ptr<T, Tag, Ref<T, RefTail...>, DerivedPtr<T, DerivedPtrTail...>>;
+};
+
+// Rebind `thrust::pointer`-like things with native reference types.
+template <template <typename, typename, typename, typename...> class Ptr,
+          typename OldT,
+          typename Tag,
+          typename... PtrTail,
+          typename T>
+struct rebind_pointer<Ptr<OldT, Tag, typename std::add_lvalue_reference<OldT>::type, PtrTail...>, T>
+{
+  //  static_assert(std::is_same<OldT, Tag>::value, "2");
+  using type = Ptr<T, Tag, typename std::add_lvalue_reference<T>::type, PtrTail...>;
+};
+
+// Rebind `thrust::pointer`-like things with native reference types and templated
+// derived types.
+template <template <typename, typename, typename, typename...> class Ptr,
+          typename OldT,
+          typename Tag,
+          template <typename...>
+          class DerivedPtr,
+          typename... DerivedPtrTail,
+          typename T>
+struct rebind_pointer<Ptr<OldT, Tag, typename std::add_lvalue_reference<OldT>::type, DerivedPtr<OldT, DerivedPtrTail...>>,
+                      T>
+{
+  //  static_assert(std::is_same<OldT, Tag>::value, "3");
+  using type = Ptr<T, Tag, typename std::add_lvalue_reference<T>::type, DerivedPtr<T, DerivedPtrTail...>>;
+};
+
+namespace pointer_traits_detail
+{
+
+template <typename Ptr, typename Enable = void>
+struct pointer_raw_pointer_impl
+{};
+
+template <typename T>
+struct pointer_raw_pointer_impl<T*>
+{
+  using type = T*;
+};
+
+template <typename Ptr>
+struct pointer_raw_pointer_impl<Ptr, ::cuda::std::void_t<typename Ptr::raw_pointer>>
+{
+  using type = typename Ptr::raw_pointer;
+};
+
+} // namespace pointer_traits_detail
+
+template <typename T>
+struct pointer_raw_pointer : pointer_traits_detail::pointer_raw_pointer_impl<T>
+{};
+
+namespace pointer_traits_detail
+{
+
+template <typename Void>
+struct capture_address
+{
+  template <typename T>
+  _CCCL_HOST_DEVICE capture_address(T& r)
+      : m_addr(&r)
+  {}
+
+  inline _CCCL_HOST_DEVICE Void* operator&() const
+  {
+    return m_addr;
+  }
+
+  Void* m_addr;
+};
+
+// metafunction to compute the type of pointer_to's parameter below
+template <typename T>
+struct pointer_to_param
+    : thrust::detail::eval_if<::cuda::std::is_void<T>::value,
+                              thrust::detail::identity_<capture_address<T>>,
+                              ::cuda::std::add_lvalue_reference<T>>
+{};
+
+} // namespace pointer_traits_detail
+
+template <typename Ptr>
+struct pointer_traits
+{
+  using pointer         = Ptr;
+  using reference       = typename Ptr::reference;
+  using element_type    = typename pointer_element<Ptr>::type;
+  using difference_type = typename pointer_difference<Ptr>::type;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = typename rebind_pointer<Ptr, U>::type;
+  };
+
+  _CCCL_HOST_DEVICE inline static pointer
+  pointer_to(typename pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    // XXX this is supposed to be pointer::pointer_to(&r); (i.e., call a static member function of pointer called
+    // pointer_to)
+    //     assume that pointer has a constructor from raw pointer instead
+
+    return pointer(&r);
+  }
+
+  // thrust additions follow
+  using raw_pointer = typename pointer_raw_pointer<Ptr>::type;
+
+  _CCCL_HOST_DEVICE inline static raw_pointer get(pointer ptr)
+  {
+    return ptr.get();
+  }
+};
+
+template <typename T>
+struct pointer_traits<T*>
+{
+  using pointer         = T*;
+  using reference       = T&;
+  using element_type    = T;
+  using difference_type = typename pointer_difference<T*>::type;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = U*;
+  };
+
+  _CCCL_HOST_DEVICE inline static pointer
+  pointer_to(typename pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  using raw_pointer = typename pointer_raw_pointer<T*>::type;
+
+  _CCCL_HOST_DEVICE inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template <>
+struct pointer_traits<void*>
+{
+  using pointer         = void*;
+  using reference       = void;
+  using element_type    = void;
+  using difference_type = pointer_difference<void*>::type;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = U*;
+  };
+
+  _CCCL_HOST_DEVICE inline static pointer pointer_to(pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  using raw_pointer = pointer_raw_pointer<void*>::type;
+
+  _CCCL_HOST_DEVICE inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template <>
+struct pointer_traits<const void*>
+{
+  using pointer         = const void*;
+  using reference       = const void;
+  using element_type    = const void;
+  using difference_type = pointer_difference<const void*>::type;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = U*;
+  };
+
+  _CCCL_HOST_DEVICE inline static pointer pointer_to(pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  using raw_pointer = pointer_raw_pointer<const void*>::type;
+
+  _CCCL_HOST_DEVICE inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template <typename FromPtr, typename ToPtr>
+struct is_pointer_system_convertible
+    : ::cuda::std::is_convertible<typename iterator_system<FromPtr>::type, typename iterator_system<ToPtr>::type>
+{};
+
+template <typename FromPtr, typename ToPtr>
+struct is_pointer_convertible
+    : ::cuda::std::_And<
+        ::cuda::std::is_convertible<typename pointer_element<FromPtr>::type*, typename pointer_element<ToPtr>::type*>,
+        is_pointer_system_convertible<FromPtr, ToPtr>>
+{};
+
+template <typename FromPtr, typename ToPtr>
+struct is_void_pointer_system_convertible
+    : ::cuda::std::_And<::cuda::std::is_same<typename pointer_element<FromPtr>::type, void>,
+                        is_pointer_system_convertible<FromPtr, ToPtr>>
+{};
+
+// this could be a lot better, but for our purposes, it's probably
+// sufficient just to check if pointer_raw_pointer<T> has meaning
+template <typename T>
+struct is_thrust_pointer : is_metafunction_defined<pointer_raw_pointer<T>>
+{};
+
+// avoid inspecting traits of the arguments if they aren't known to be pointers
+template <typename FromPtr, typename ToPtr>
+struct lazy_is_pointer_convertible
+    : thrust::detail::eval_if<is_thrust_pointer<FromPtr>::value && is_thrust_pointer<ToPtr>::value,
+                              is_pointer_convertible<FromPtr, ToPtr>,
+                              thrust::detail::identity_<thrust::detail::false_type>>
+{};
+
+template <typename FromPtr, typename ToPtr>
+struct lazy_is_void_pointer_system_convertible
+    : thrust::detail::eval_if<is_thrust_pointer<FromPtr>::value && is_thrust_pointer<ToPtr>::value,
+                              is_void_pointer_system_convertible<FromPtr, ToPtr>,
+                              thrust::detail::identity_<thrust::detail::false_type>>
+{};
+
+template <typename FromPtr, typename ToPtr, typename T = void>
+struct enable_if_pointer_is_convertible
+    : ::cuda::std::enable_if<lazy_is_pointer_convertible<FromPtr, ToPtr>::type::value, T>
+{};
+
+template <typename FromPtr, typename ToPtr, typename T = void>
+struct enable_if_void_pointer_is_system_convertible
+    : ::cuda::std::enable_if<lazy_is_void_pointer_system_convertible<FromPtr, ToPtr>::type::value, T>
+{};
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/unique.inl b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/unique.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2750cb5e10d3b00d94fe040987adaf62263b5d64
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/unique.inl
@@ -0,0 +1,353 @@
+/*
+ *  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/temporary_array.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/unique.h>
+#include <thrust/system/detail/adl/unique_by_key.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/unique.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryPredicate>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator1, typename ForwardIterator2>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename BinaryPredicate>
+_CCCL_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;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  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;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<ForwardIterator1>::type;
+  using System2 = typename thrust::iterator_system<ForwardIterator2>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<ForwardIterator1>::type;
+  using System2 = typename thrust::iterator_system<ForwardIterator2>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<InputIterator1>::type;
+  using System2 = typename thrust::iterator_system<InputIterator2>::type;
+  using System3 = typename thrust::iterator_system<OutputIterator1>::type;
+  using System4 = typename thrust::iterator_system<OutputIterator2>::type;
+
+  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;
+
+  using System1 = typename thrust::iterator_system<InputIterator1>::type;
+  using System2 = typename thrust::iterator_system<InputIterator2>::type;
+  using System3 = typename thrust::iterator_system<OutputIterator1>::type;
+  using System4 = typename thrust::iterator_system<OutputIterator2>::type;
+
+  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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_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()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename ForwardIterator, typename BinaryPredicate>
+_CCCL_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;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last, binary_pred);
+} // end unique_count()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename ForwardIterator>
+_CCCL_HOST_DEVICE typename thrust::iterator_traits<ForwardIterator>::difference_type
+unique_count(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last);
+} // end unique_count()
+
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/util/align.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/util/align.h
new file mode 100644
index 0000000000000000000000000000000000000000..589735e8a971d0585135b5729eed2b131cd916d4
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/util/align.h
@@ -0,0 +1,59 @@
+/*
+ *  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 <cstdint>
+
+// functions to handle memory alignment
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace util
+{
+
+template <typename T>
+_CCCL_HOST_DEVICE T* align_up(T* ptr, std::uintptr_t bytes)
+{
+  return (T*) (bytes * (((std::uintptr_t) ptr + (bytes - 1)) / bytes));
+}
+
+template <typename T>
+_CCCL_HOST_DEVICE T* align_down(T* ptr, std::uintptr_t bytes)
+{
+  return (T*) (bytes * (std::uintptr_t(ptr) / bytes));
+}
+
+template <typename T>
+_CCCL_HOST_DEVICE bool is_aligned(T* ptr, std::uintptr_t bytes = sizeof(T))
+{
+  return std::uintptr_t(ptr) % bytes == 0;
+}
+
+} // end namespace util
+} // end namespace detail
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/allocator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..37bc08c74279d4036505df168df78aa1fde2b3b6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/allocator.h
@@ -0,0 +1,229 @@
+/*
+ *  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 <thrust/detail/config.h>
+
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/mr/polymorphic_adaptor.h>
+#include <thrust/mr/validator.h>
+
+#include <limits>
+
+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. */
+  using void_pointer = typename MR::pointer;
+
+  /*! The value type allocated by this allocator. Equivalent to \p T. */
+  using value_type = T;
+  /*! The pointer type allocated by this allocator. Equivaled to the pointer type of \p MR rebound to \p T. */
+  using pointer = typename thrust::detail::pointer_traits<void_pointer>::template rebind<T>::other;
+  /*! The pointer to const type. Equivalent to a pointer type of \p MR rebound to <tt>const T</tt>. */
+  using const_pointer = typename thrust::detail::pointer_traits<void_pointer>::template rebind<const T>::other;
+  /*! The reference to the type allocated by this allocator. Supports smart references. */
+  using reference = typename thrust::detail::pointer_traits<pointer>::reference;
+  /*! The const reference to the type allocated by this allocator. Supports smart references. */
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+  /*! The size type of this allocator. Always \p std::size_t. */
+  using size_type = std::size_t;
+  /*! The difference type between pointers allocated by this allocator. */
+  using difference_type = typename thrust::detail::pointer_traits<pointer>::difference_type;
+
+  /*! Specifies that the allocator shall be propagated on container copy assignment. */
+  using propagate_on_container_copy_assignment = detail::true_type;
+  /*! Specifies that the allocator shall be propagated on container move assignment. */
+  using propagate_on_container_move_assignment = detail::true_type;
+  /*! Specifies that the allocator shall be propagated on container swap. */
+  using propagate_on_container_swap = detail::true_type;
+
+  /*! 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 alias \p other gives the type of the rebound \p allocator.
+     */
+    using other = allocator<U, MR>;
+  };
+
+  /*! 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.
+   */
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_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.
+   */
+  _CCCL_HOST_DEVICE allocator(MR* resource)
+      : mem_res(resource)
+  {}
+
+  /*! Copy constructor. Copies the resource pointer. */
+  template <typename U>
+  _CCCL_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.
+   */
+  _CCCL_NODISCARD _CCCL_HOST pointer allocate(size_type n)
+  {
+    return static_cast<pointer>(mem_res->do_allocate(n * sizeof(T), 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
+   */
+  _CCCL_HOST void deallocate(pointer p, size_type n) noexcept
+  {
+    return mem_res->do_deallocate(p, n * sizeof(T), alignof(T));
+  }
+
+  /*! Extracts the memory resource used by this allocator.
+   *
+   *  \return the memory resource used by this allocator.
+   */
+  _CCCL_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>
+_CCCL_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>
+_CCCL_HOST_DEVICE bool operator!=(const allocator<T, MR>& lhs, const allocator<T, MR>& rhs) noexcept
+{
+  return !(lhs == rhs);
+}
+
+template <typename T, typename Pointer>
+using polymorphic_allocator = allocator<T, polymorphic_adaptor_resource<Pointer>>;
+
+/*! 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>
+{
+  using base = thrust::mr::allocator<T, Upstream>;
+
+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 alias \p other gives the type of the rebound \p stateless_resource_allocator.
+     */
+    using other = stateless_resource_allocator<U, Upstream>;
+  };
+
+  /*! 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.
+   */
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE stateless_resource_allocator()
+      : base(get_global_resource<Upstream>())
+  {}
+
+  /*! Copy constructor. Copies the memory resource pointer. */
+  _CCCL_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>
+  _CCCL_HOST_DEVICE stateless_resource_allocator(const stateless_resource_allocator<U, Upstream>& other)
+      : base(other)
+  {}
+
+  stateless_resource_allocator& operator=(const stateless_resource_allocator&) = default;
+
+  /*! Destructor. */
+  _CCCL_HOST_DEVICE ~stateless_resource_allocator() {}
+};
+
+/*! \} // allocators
+ */
+
+} // namespace mr
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_pool.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..b97aa4fb43b1469edf3e90beff0f38bafd96cc13
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_pool.h
@@ -0,0 +1,462 @@
+/*
+ *  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/config.h>
+
+#include <thrust/binary_search.h>
+#include <thrust/detail/algorithm_wrapper.h>
+#include <thrust/detail/seq.h>
+#include <thrust/host_vector.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/memory_resource.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:
+  using void_ptr = typename Upstream::pointer;
+  using char_ptr = typename thrust::detail::pointer_traits<void_ptr>::template rebind<char>::other;
+
+  struct chunk_descriptor
+  {
+    std::size_t size;
+    void_ptr pointer;
+  };
+
+  using chunk_vector = thrust::host_vector<chunk_descriptor, allocator<chunk_descriptor, Bookkeeper>>;
+
+  struct oversized_block_descriptor
+  {
+    std::size_t size;
+    std::size_t alignment;
+    void_ptr pointer;
+
+    _CCCL_HOST_DEVICE bool operator==(const oversized_block_descriptor& other) const
+    {
+      return size == other.size && alignment == other.alignment && pointer == other.pointer;
+    }
+
+    _CCCL_HOST_DEVICE bool operator<(const oversized_block_descriptor& other) const
+    {
+      return size < other.size || (size == other.size && alignment < other.alignment);
+    }
+  };
+
+  struct equal_pointers
+  {
+  public:
+    _CCCL_HOST_DEVICE equal_pointers(void_ptr p)
+        : p(p)
+    {}
+
+    _CCCL_HOST_DEVICE bool operator()(const oversized_block_descriptor& desc) const
+    {
+      return desc.pointer == p;
+    }
+
+  private:
+    void_ptr p;
+  };
+
+  struct matching_alignment
+  {
+  public:
+    _CCCL_HOST_DEVICE matching_alignment(std::size_t requested)
+        : requested(requested)
+    {}
+
+    _CCCL_HOST_DEVICE bool operator()(const oversized_block_descriptor& desc) const
+    {
+      return desc.alignment >= requested;
+    }
+
+  private:
+    std::size_t requested;
+  };
+
+  using oversized_block_vector =
+    thrust::host_vector<oversized_block_descriptor, allocator<oversized_block_descriptor, Bookkeeper>>;
+
+  using pointer_vector = thrust::host_vector<void_ptr, allocator<void_ptr, Bookkeeper>>;
+
+  struct pool
+  {
+    _CCCL_HOST pool(const pointer_vector& free)
+        : free_blocks(free)
+        , previous_allocated_count(0)
+    {}
+
+    _CCCL_HOST pool(const pool& other)
+        : free_blocks(other.free_blocks)
+        , previous_allocated_count(other.previous_allocated_count)
+    {}
+
+    pool& operator=(const pool&) = default;
+
+    _CCCL_HOST ~pool() {}
+
+    pointer_vector free_blocks;
+    std::size_t previous_allocated_count;
+  };
+
+  using pool_vector = thrust::host_vector<pool, allocator<pool, Bookkeeper>>;
+
+  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();
+  }
+
+  _CCCL_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
+ */
+
+} // namespace mr
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_tls_pool.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_tls_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad10bea0b582830a3b841064a46d0eaec43c9a21
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/disjoint_tls_pool.h
@@ -0,0 +1,68 @@
+/*
+ *  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/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>
+_CCCL_HOST thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper>&
+tls_disjoint_pool(Upstream* upstream = nullptr, Bookkeeper* bookkeeper = nullptr)
+{
+  static thread_local auto adaptor = [&] {
+    assert(upstream && bookkeeper);
+    return thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper>(upstream, bookkeeper);
+  }();
+
+  return adaptor;
+}
+
+/*! \}
+ */
+
+} // namespace mr
+THRUST_NAMESPACE_END
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/universal_memory_resource.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/universal_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d38638c093fd31d1bcc214f5033de611e0fab9f
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/mr/universal_memory_resource.h
@@ -0,0 +1,29 @@
+/*
+ *  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>